zuluCrypt  5.7.1
About: zuluCrypt is a simple but feature rich solution for hard drives encryption. It can manage PLAIN dm-crypt, LUKS, TrueCrypt and VeraCrypt encrypted volumes.
  Fossies Dox: zuluCrypt-5.7.1.tar.xz  ("unofficial" and yet experimental doxygen-generated source code documentation)  

StringList.c
Go to the documentation of this file.
1 /*
2  *
3  * Copyright (c) 2011-2015
4  * name : Francis Banyikwa
5  * email: mhogomchungu@gmail.com
6  * This program is free software: you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation, either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program. If not, see <http://www.gnu.org/licenses/>.
18  */
19 
20 #include <stdio.h>
21 #include "StringList.h"
22 
23 /*
24  * buffer size will grow exponentially by a multiple of this number
25  */
26 #define FACTOR 2
27 
28 /*
29  * initial buffer size
30  */
31 #define INIT_SIZE 8
32 
34 {
35  size_t size ; /* size of the array*/
36  size_t length ; /* size of the buffer of thr array */
37  string_t * stp ; /* pointer to String_t array */
38 };
39 
40 struct StringType
41 {
42  char * string ;
43  size_t size ;
44  size_t length ;
45  int owned ;
46 };
47 
48 static void _f( void )
49 {
50 }
51 
52 static void ( *_memory_error )( void ) = _f ;
53 
54 void StringListExitOnMemoryExaustion( void ( *f )( void ) )
55 {
56  _memory_error = f ;
57 }
58 
59 static void * _StringListError( void )
60 {
61  _memory_error() ;
62  return NULL ;
63 }
64 
65 void StringListForEach( stringList_t stl,void (*fct)( string_t ) )
66 {
67  size_t i ;
68  size_t j ;
69  string_t * q ;
70  string_t p ;
71 
72  if( stl != StringListVoid ){
73  j = stl->size ;
74  q = stl->stp ;
75  for( i = 0 ; i < j ; i++ ){
76  p = *( q + i ) ;
77  if( p != StringVoid ){
78  fct( p ) ;
79  }
80  }
81  }
82 }
83 
84 void StringListForEach_1( stringList_t stl,void (*fct)( string_t,void * ),void * arg )
85 {
86  size_t i ;
87  size_t j ;
88  string_t * q ;
89  string_t p ;
90 
91  if( stl != StringListVoid ){
92  j = stl->size ;
93  q = stl->stp ;
94  for( i = 0 ; i < j ; i++ ){
95  p = *( q + i ) ;
96  if( p != StringVoid ){
97  fct( p,arg ) ;
98  }
99  }
100  }
101 }
102 
103 void StringListForEachString( stringList_t stl,void (*fct)( const char * ) )
104 {
105  size_t i ;
106  size_t j ;
107  string_t * q ;
108  string_t p ;
109 
110  if( stl != StringListVoid ){
111  j = stl->size ;
112  q = stl->stp ;
113  for( i = 0 ; i < j ; i++ ){
114  p = *( q + i ) ;
115  if( p != StringVoid ){
116  fct( p->string ) ;
117  }
118  }
119  }
120 }
121 
122 void StringListForEachString_1( stringList_t stl,void (*fct)( const char *,void * ),void * arg )
123 {
124  size_t i ;
125  size_t j ;
126  string_t * q ;
127  string_t p ;
128 
129  if( stl != StringListVoid ){
130  j = stl->size ;
131  q = stl->stp ;
132  for( i = 0 ; i < j ; i++ ){
133  p = *( q + i ) ;
134  if( p!= StringVoid ){
135  fct( p->string,arg ) ;
136  }
137  }
138  }
139 }
140 
141 static inline string_t * __ExpandMemory( stringList_t stl )
142 {
143  string_t * p ;
144  if( stl->size >= stl->length ){
145  stl->length = stl->length * FACTOR ;
146  p = realloc( stl->stp,sizeof( string_t ) * ( stl->length ) ) ;
147  if( p == NULL ){
148  return _StringListError() ;
149  }else{
150  return p ;
151  }
152  }else{
153  return stl->stp ;
154  }
155 }
156 
157 stringList_t StringList( const char * cstring )
158 {
159  stringList_t stl ;
160 
161  if( cstring == NULL ){
162  return StringListVoid ;
163  }
164 
165  stl = malloc( sizeof( struct StringListType ) ) ;
166 
167  if( stl == NULL ){
168  return _StringListError() ;
169  }
170 
171  stl->stp = malloc( sizeof( string_t ) * INIT_SIZE ) ;
172 
173  if( stl->stp == NULL ){
174  free( stl ) ;
175  return _StringListError() ;
176  }
177 
178  stl->stp[0] = String( cstring ) ;
179 
180  if( stl->stp[0] == StringVoid ){
181  free( stl->stp ) ;
182  free( stl ) ;
183  return _StringListError() ;
184  }else{
185  stl->stp[0]->owned = 1 ;
186  stl->size = 1 ;
187  stl->length = INIT_SIZE ;
188  return stl ;
189  }
190 }
191 
193 {
194  if( stl == StringListVoid ){
195  return NULL ;
196  }else{
197  return stl->stp ;
198  }
199 }
200 
202 {
203  if( stl == StringListVoid ){
204  return NULL ;
205  }else{
206  return stl->stp + stl->size ;
207  }
208 }
209 
211 {
212  if( stl == StringListVoid ){
213  *begin = NULL ;
214  *end = NULL ;
215  }else{
216  *begin = stl->stp;
217  *end = stl->stp + stl->size ;
218  }
219 }
220 
222 {
223  string_t * p ;
224 
225  if( stl == StringListVoid ){
226  return NULL ;
227  }
228 
229  p = __ExpandMemory( stl ) ;
230 
231  if( p == NULL ){
232  return _StringListError() ;
233  }else{
234  stl->stp = p ;
235  stl->stp[ stl->size ] = StringVoid ;
236  p = &stl->stp[ stl->size ] ;
237 
238  stl->size = stl->size + 1 ;
239 
240  return p ;
241  }
242 }
243 
244 string_t * StringListArray( stringList_t * stz,size_t arraySize )
245 {
246  stringList_t stl = malloc( sizeof( struct StringListType ) ) ;
247 
248  if( stl == NULL ){
249  return _StringListError() ;
250  }
251 
252  stl->stp = malloc( sizeof( string_t ) * arraySize ) ;
253 
254  if( stl->stp == NULL ){
255  free( stl ) ;
256  return _StringListError() ;
257  }
258 
259  stl->size = arraySize ;
260  stl->length = arraySize ;
261 
262  memset( stl->stp,'\0',sizeof( string_t ) * arraySize ) ;
263 
264  *stz = stl ;
265  return stl->stp ;
266 }
267 
269 {
270  string_t * p ;
271 
272  if( stl == StringListVoid ){
273  return st ;
274  }
275 
276  p = __ExpandMemory( stl ) ;
277 
278  if( p == NULL ){
279  return _StringListError() ;
280  }else{
281  stl->stp = p ;
282 
283  if( st != NULL ){
284  st->owned = 1 ;
285  }
286 
287  stl->stp[ stl->size ] = st ;
288  stl->size = stl->size + 1 ;
289  return st ;
290  }
291 }
292 
294 {
295  stringList_t stl = malloc( sizeof( struct StringListType ) ) ;
296 
297  if( stl == NULL ){
298  return _StringListError() ;
299  }
300 
301  stl->stp = malloc( sizeof( string_t ) * INIT_SIZE ) ;
302 
303  if( stl->stp == NULL ){
304  free( stl ) ;
305  return _StringListError() ;
306  }else{
307  stl->size = 0 ;
308  stl->length = INIT_SIZE ;
309  return stl ;
310  }
311 }
312 
313 stringList_t StringListWithSize( char ** c, size_t s,size_t t )
314 {
315  stringList_t stl ;
316  if( c == NULL ){
317  return StringListVoid ;
318  }
319  stl = malloc( sizeof( struct StringListType ) ) ;
320  if( stl == NULL ){
321  return _StringListError() ;
322  }
323  stl->stp = malloc( sizeof( string_t ) * INIT_SIZE ) ;
324  if( stl->stp == NULL ){
325  free( stl ) ;
326  return _StringListError() ;
327  }
328  stl->stp[0] = StringInheritWithSize( c,s,t ) ;
329  if( stl->stp[0] == StringVoid ){
330  free( stl->stp ) ;
331  free( stl ) ;
332  return _StringListError() ;
333  }else{
334  stl->stp[0]->owned = 1 ;
335  stl->size = 1 ;
336  stl->length = INIT_SIZE ;
337  return stl ;
338  }
339 }
340 
341 stringList_t StringListAppendWithSize( stringList_t stl,char ** c, size_t s,size_t l )
342 {
343  string_t * p ;
344  string_t q ;
345  if( stl == StringListVoid ){
346  return StringListWithSize( c,s,l ) ;
347  }
348 
349  q = StringInheritWithSize( c,s,l ) ;
350 
351  if( q == StringVoid ){
352  return stl ;
353  }
354  p = __ExpandMemory( stl ) ;
355 
356  if( p == NULL ){
357  StringDelete( &q ) ;
358  return _StringListError() ;
359  }else{
360  stl->stp = p ;
361  q->owned = 1 ;
362  stl->stp[ stl->size ] = q ;
363  stl->size = stl->size + 1 ;
364  return stl ;
365  }
366 }
367 
368 stringList_t StringListAppendSize( stringList_t stl,const char * cstring,size_t len )
369 {
370  stringList_t p ;
371  char * c ;
372 
373  if( cstring == NULL ){
374  return stl ;
375  }
376 
377  c = malloc( sizeof( char ) * ( len + 1 ) ) ;
378 
379  if( c == NULL ){
380  return _StringListError() ;
381  }
382  memcpy( c,cstring,len ) ;
383  *( c + len ) = '\0' ;
384  p = StringListAppendWithSize( stl,&c,len,len + 1 ) ;
385  if( p == StringListVoid ){
386  free( c ) ;
387  return _StringListError() ;
388  }else{
389  return p ;
390  }
391 }
392 
394 {
395  size_t j ;
396  size_t i ;
397  string_t * z ;
398  string_t k ;
399 
400  if( q == StringListVoid ){
401  return p ;
402  }
403  if( p == StringListVoid ){
404  return StringListCopy( q ) ;
405  }
406 
407  j = StringListSize( q ) ;
408  z = q->stp ;
409 
410  for( i = 0 ; i < j ; i++ ){
411  k = *( z + i ) ;
412  if( k != StringVoid ){
413  StringListAppendSize( p,k->string,k->size ) ;
414  }
415  }
416  return p ;
417 }
418 
420 {
421  if( st == StringVoid ){
422  return stl ;
423  }else{
424  return StringListAppendSize( stl,st->string,st->size ) ;
425  }
426 }
427 
428 stringList_t StringListSplit( const char * cstring,char splitter )
429 {
430  const char * b = cstring ;
431  char * d ;
432  char * e ;
433  char s[ 2 ] ;
434 
435  size_t sp_len = sizeof( char ) ;
436  size_t len ;
437 
439  stringList_t stx ;
440 
441  if( cstring == NULL ){
442  return StringListVoid ;
443  }
444 
445  s[ 1 ] = '\0' ;
446  s[ 0 ] = splitter ;
447 
448  while( 1 ){
449  d = strstr( b,s ) ;
450  if( d == NULL ){
451  if( *b != '\0' ){
452  if( b == cstring || *b != splitter ){
453  stl = StringListAppend( stl,b ) ;
454  }
455  }
456  break ;
457  }else{
458  len = d - b ;
459  if( len > 0 ){
460  e = malloc( sizeof( char ) * ( len + 1 ) ) ;
461  if( e == NULL ){
462  StringListDelete( &stl ) ;
463  return _StringListError() ;
464  }
465  memcpy( e,b,len ) ;
466  *( e + len ) = '\0' ;
467  stx = StringListAppendWithSize( stl,&e,len,len + 1 ) ;
468  if( stx == StringListVoid ){
469  StringListDelete( &stl ) ;
470  free( e ) ;
471  return _StringListError() ;
472  }else{
473  stl = stx ;
474  }
475  }
476  b = d + sp_len ;
477  }
478  }
479 
480  return stl ;
481 }
482 
484 {
485  if( st == StringVoid ){
486  return StringListVoid ;
487  }else{
488  return StringListSplit( st->string,splitter ) ;
489  }
490 }
491 
493 {
494  if( stl == StringListVoid ){
495  return 0 ;
496  }else{
497  return stl->size ;
498  }
499 }
500 
501 const char * StringListContentAt( stringList_t stl,size_t index )
502 {
503  if( stl == StringListVoid ){
504  return NULL ;
505  }else{
506  if( index >= stl->size ){
507  return NULL ;
508  }else{
509  return stl->stp[ index ]->string ;
510  }
511  }
512 }
513 
514 int StringListContentAtEqual( stringList_t stl,size_t index,const char * cstring )
515 {
516  if( stl == StringListVoid || cstring == NULL ){
517  return 0 ;
518  }else{
519  if( index >= stl->size ){
520  return 0 ;
521  }else{
522  return strcmp( stl->stp[ index ]->string,cstring ) == 0 ;
523  }
524  }
525 }
526 
528 {
529  if( stl == StringListVoid ){
530  return NULL ;
531  }else{
532  if( stl->size < 1 ){
533  return NULL ;
534  }else{
535  return stl->stp[ stl->size - 1 ]->string ;
536  }
537  }
538 }
539 
541 {
542  if( stl == StringListVoid ){
543  return StringVoid ;
544  }else{
545  if( stl->size < 1 ){
546  return StringVoid ;
547  }else{
548  return stl->stp[ stl->size - 1 ] ;
549  }
550  }
551 }
552 
553 stringList_t StringListInsertAt( stringList_t stl,const char * cstring,size_t index )
554 {
555  string_t * p ;
556  string_t q ;
557  size_t size = sizeof( string_t ) ;
558 
559  if( stl == StringListVoid ){
560  return StringListVoid ;
561  }
562  if( cstring == NULL ){
563  return stl ;
564  }
565  if( index > stl->size ){
566  return stl ;
567  }
568 
569  q = String( cstring ) ;
570 
571  if( q == StringVoid ){
572  return _StringListError() ;
573  }
574 
575  p = __ExpandMemory( stl ) ;
576 
577  if( p == NULL ){
578  StringDelete( &q ) ;
579  return _StringListError() ;
580  }else{
581  stl->stp = p ;
582  memmove( stl->stp + index + 1,stl->stp + index,size * ( stl->size - index ) ) ;
583  q->owned = 1 ;
584  stl->stp[index] = q ;
585  stl->size = stl->size + 1 ;
586  return stl ;
587  }
588 }
589 
590 static int _StringListStringInsertAt( stringList_t stl,string_t * st,size_t index )
591 {
592  string_t * p ;
593  size_t size = sizeof( string_t ) ;
594 
595  if( stl == StringListVoid ){
596  return 0 ;
597  }
598  if( index > stl->size ){
599  return 0 ;
600  }
601 
602  p = __ExpandMemory( stl ) ;
603 
604  if( p == NULL ){
605  _StringListError() ;
606  return 0 ;
607  }else{
608  stl->stp = p ;
609  memmove( stl->stp + index + 1,stl->stp + index,size * ( stl->size - index ) ) ;
610  stl->stp[index] = *st ;
611  if( stl->stp[index] != StringVoid ){
612  stl->stp[index]->owned = 1 ;
613  }
614  stl->size = stl->size + 1 ;
615  return 1 ;
616  }
617 }
618 
620 {
621  stringList_t stl = malloc( sizeof( struct StringListType ) ) ;
622 
623  if( stl == NULL ){
624  _StringListError() ;
625  return 0 ;
626  }
627  stl->stp = malloc( sizeof( string_t ) * INIT_SIZE ) ;
628  if( stl->stp == NULL ){
629  free( stl ) ;
630  _StringListError() ;
631  return 0 ;
632  }
633  if( *st != StringVoid ){
634  stl->stp[ 0 ] = *st ;
635  stl->stp[ 0 ]->owned = 1 ;
636  }else{
637  stl->stp[ 0 ] = StringVoid ;
638  }
639 
640  stl->size = 1 ;
641  stl->length = INIT_SIZE ;
642 
643  *r = stl ;
644  return 1 ;
645 }
646 
648 {
650 
651  if( st && *st ){
652  if( _StringListString( st,&stl ) ){
653  *st = StringVoid ;
654  }
655  }
656  return stl ;
657 }
658 
660 {
661  if( st && *st && stl ){
662  if( *stl == StringListVoid ){
663  if( _StringListString( st,stl ) ){
664  *st = StringVoid ;
665  }
666  }else{
667  if( _StringListStringInsertAt( *stl,st,( *stl )->size ) ){
668  *st = StringVoid ;
669  }
670  }
671  }
672 }
673 
675 {
676  if( st && *st ){
677  if( _StringListStringInsertAt( stl,st,index ) ){
678  *st = StringVoid ;
679  }
680  }
681  return stl ;
682 }
683 
684 stringList_t StringListInsertAtSize( stringList_t stl,const char * cstring,size_t len,size_t index )
685 {
686  char * c ;
687  string_t * p ;
688  string_t q ;
689  size_t size = sizeof( string_t ) ;
690 
691  if( stl == StringListVoid || cstring == NULL ){
692  return stl ;
693  }
694  if( index > stl->size ){
695  return stl ;
696  }
697 
698  c = malloc( sizeof( char ) * ( len + 1 ) ) ;
699 
700  if( c == NULL ){
701  return _StringListError() ;
702  }
703 
704  memcpy( c,cstring,len );
705  *( c + len ) = '\0' ;
706  q = StringInheritWithSize( &c,len,len + 1 ) ;
707 
708  if( q == StringVoid ){
709  free( c ) ;
710  return _StringListError() ;
711  }
712 
713  p = __ExpandMemory( stl ) ;
714 
715  if( p == NULL ){
716  StringDelete( &q ) ;
717  return _StringListError() ;
718  }else{
719  stl->stp = p ;
720  memmove( stl->stp + index + 1,stl->stp + index,size * ( stl->size - index ) ) ;
721  q->owned = 1 ;
722  stl->stp[index] = q ;
723  stl->size = stl->size + 1 ;
724  return stl ;
725  }
726 }
727 
728 stringList_t StringListPrependSize( stringList_t stl,const char * cstring,size_t len )
729 {
730  char * c ;
731  stringList_t p ;
732  if( cstring == NULL ){
733  return stl ;
734  }
735  if( stl == StringListVoid ){
736  c = malloc( sizeof( char ) * ( len + 1 ) ) ;
737  if( c == NULL ){
738  return _StringListError() ;
739  }
740  memcpy( c,cstring,len ) ;
741  *( c + len ) = '\0' ;
742  p = StringListWithSize( &c,len,len + 1 ) ;
743  if( p == StringListVoid ){
744  free( c ) ;
745  return _StringListError() ;
746  }else{
747  return p ;
748  }
749  }else{
750  return StringListInsertAtSize( stl,cstring,len,0 ) ;
751  }
752 }
753 
754 stringList_t StringListPrepend( stringList_t stl,const char * cstring )
755 {
756  if( stl == StringListVoid ){
757  return StringList( cstring ) ;
758  }else{
759  return StringListInsertAt( stl,cstring,0 ) ;
760  }
761 }
762 
763 stringList_t StringListAppend( stringList_t stl,const char * cstring )
764 {
765  string_t q ;
766 
767  if( stl == StringListVoid ){
768  return StringList( cstring ) ;
769  }
770 
771  if( cstring == NULL ){
772  return stl ;
773  }
774 
775  q = String( cstring ) ;
776 
777  if( q == StringVoid ){
778  return _StringListError() ;
779  }
780 
781  stl->stp = __ExpandMemory( stl ) ;
782 
783  if( stl->stp == NULL ){
784  StringDelete( &q ) ;
785  return _StringListError() ;
786  }else{
787  q->owned = 1 ;
788  stl->stp[ stl->size ] = q ;
789  stl->size = stl->size + 1 ;
790  return stl ;
791  }
792 }
793 
795 {
796  if( stl == StringListVoid ){
797  return StringList( cstring ) ;
798  }else{
799  if( StringListContains( stl,cstring ) == -1 ){
800  StringListAppend( stl,cstring ) ;
801  }
802  return stl ;
803  }
804 }
805 
806 ssize_t StringListContains( stringList_t stl,const char * cstring )
807 {
808  size_t i ;
809  size_t size ;
810  string_t * k ;
811  string_t e ;
812 
813  if( stl == StringListVoid || cstring == NULL ){
814  return -1 ;
815  }
816 
817  size = stl->size ;
818 
819  k = stl->stp ;
820 
821  for( i = 0 ; i < size ; i++ ){
822  e = *( k + i ) ;
823  if( e != StringVoid ){
824  if( strcmp( e->string,cstring ) == 0 ){
825  return i ;
826  }
827  }
828  }
829  return -1 ;
830 }
831 
832 ssize_t StringListHasSequence( stringList_t stl,const char * str )
833 {
834  size_t i ;
835  size_t size ;
836  string_t * k ;
837  string_t e ;
838 
839  if( stl == StringListVoid || str == NULL ){
840  return -1 ;
841  }
842 
843  size = stl->size ;
844  k = stl->stp ;
845 
846  for( i = 0 ; i < size ; i++ ){
847  e = *( k + i ) ;
848  if( e != StringVoid ){
849  if( strstr( e->string,str ) != NULL ){
850  return i ;
851  }
852  }
853  }
854 
855  return -1 ;
856 }
857 
859 {
860  ssize_t e = StringListHasSequence( stl,str ) ;
861 
862  if( e == -1 ){
863  return StringVoid ;
864  }else{
865  return *( stl->stp + e ) ;
866  }
867 }
868 
869 ssize_t StringListHasStartSequence( stringList_t stl,const char * str )
870 {
871  size_t i ;
872  size_t size ;
873  string_t * k ;
874  string_t e ;
875  size_t len ;
876 
877  if( stl == StringListVoid || str == NULL ){
878  return -1 ;
879  }
880 
881  len = strlen( str ) ;
882  size = stl->size ;
883  k = stl->stp ;
884 
885  for( i = 0 ; i < size ; i++ ){
886  e = *( k + i ) ;
887  if( e != StringVoid ){
888  if( strncmp( e->string,str,len ) == 0 ){
889  return i ;
890  }
891  }
892  }
893 
894  return -1 ;
895 }
896 
898 {
899  ssize_t e = StringListHasStartSequence( stl,str ) ;
900 
901  if( e == -1 ){
902  return StringVoid ;
903  }else{
904  return *( stl->stp + e ) ;
905  }
906 }
907 
908 char * const * StringListStringArray( stringList_t stl )
909 {
910  size_t i ;
911  size_t j ;
912  char ** q ;
913  string_t * p ;
914  string_t z ;
915 
916  if( stl == StringListVoid ){
917  q = malloc( sizeof( char * ) ) ;
918  if( q == NULL ){
919  return _StringListError() ;
920  }else{
921  *q = NULL ;
922  }
923  }else{
924  j = stl->size ;
925  p = stl->stp ;
926  q = malloc( sizeof( char * ) * ( j + 1 ) ) ;
927  if( q == NULL ){
928  return _StringListError() ;
929  }
930  *( q + j ) = NULL ;
931  for( i = 0 ; i < j ; i++ ){
932  z = *( p + i ) ;
933  if( z != StringVoid ){
934  *( q + i ) = z->string ;
935  }else{
936  *( q + i ) = NULL ;
937  }
938  }
939  }
940  return q ;
941 }
942 
943 void StringListStringArray_1( char * const ** buffer,size_t * size ,stringList_t stl )
944 {
945  size_t i ;
946  size_t j ;
947  string_t * p ;
948  string_t z ;
949 
950  char ** e ;
951 
952  if( buffer == NULL || size == NULL || stl == StringListVoid ){
953  return ;
954  }
955 
956  e = ( char ** ) *buffer ;
957 
958  j = stl->size ;
959  p = stl->stp ;
960 
961  if( *size < j ){
962  e = realloc( e,sizeof( char * ) * ( j + 1 ) ) ;
963  if( e == NULL ){
964  _StringListError() ;
965  *size = 0 ;
966  }else{
967  *size = j ;
968  *( e + j ) = NULL ;
969  }
970  }
971 
972  for( i = 0 ; i < j ; i++ ){
973  z = *( p + i ) ;
974  if( z != StringVoid ){
975  *( e + i ) = z->string ;
976  }else{
977  *( e + i ) = NULL ;
978  }
979  }
980 
981  *buffer = e ;
982 }
983 
984 size_t StringListRemoveIfStringStartsWith( stringList_t stl,const char * str )
985 {
986  string_t z ;
987  string_t * it ;
988  string_t * end ;
989  string_t * result ;
990  size_t count = 0 ;
991  size_t len ;
992 
993  if( stl == StringListVoid || str == NULL ){
994  return 0 ;
995  }
996 
997  it = stl->stp ;
998  end = it + stl->size ;
999  result = it ;
1000  count = 0 ;
1001  len = strlen( str ) ;
1002 
1003  while( it != end ){
1004  z = *it ;
1005  it++ ;
1006  if( z != StringVoid ){
1007  if( strncmp( z->string,str,len ) == 0 ){
1008  free( z->string ) ;
1009  free( z ) ;
1010  count++ ;
1011  stl->size-- ;
1012  }else{
1013  *result = z ;
1014  result++ ;
1015  }
1016  }else{
1017  *result = z ;
1018  result++ ;
1019  }
1020  }
1021 
1022  return count ;
1023 }
1024 
1026 {
1027  return StringListRemoveIfPresent( stl,st->string ) ;
1028 }
1029 
1030 size_t StringListRemoveIfPresent( stringList_t stl,const char * str )
1031 {
1032  string_t z ;
1033  string_t * it ;
1034  string_t * end ;
1035  string_t * result ;
1036  size_t count = 0 ;
1037 
1038  if( stl == StringListVoid || str == NULL ){
1039  return 0 ;
1040  }
1041 
1042  it = stl->stp ;
1043  end = it + stl->size ;
1044  result = it ;
1045  count = 0 ;
1046 
1047  while( it != end ){
1048  z = *it ;
1049  it++ ;
1050  if( z != StringVoid ){
1051  if( strcmp( z->string,str ) == 0 ){
1052  free( z->string ) ;
1053  free( z ) ;
1054  count++ ;
1055  stl->size-- ;
1056  }else{
1057  *result = z ;
1058  result++ ;
1059  }
1060  }else{
1061  *result = z ;
1062  result++ ;
1063  }
1064  }
1065 
1066  return count ;
1067 }
1068 
1069 
1070 size_t StringListRemoveIfStringContains( stringList_t stl,const char * str )
1071 {
1072  string_t z ;
1073  string_t * it ;
1074  string_t * end ;
1075  string_t * result ;
1076  size_t count = 0 ;
1077 
1078  if( stl == StringListVoid || str == NULL ){
1079  return 0 ;
1080  }
1081 
1082  it = stl->stp ;
1083  end = it + stl->size ;
1084  result = it ;
1085  count = 0 ;
1086 
1087  while( it != end ){
1088  z = *it ;
1089  it++ ;
1090  if( z != StringVoid ){
1091  if( strstr( z->string,str ) != NULL ){
1092  free( z->string ) ;
1093  free( z ) ;
1094  count++ ;
1095  stl->size-- ;
1096  }else{
1097  *result = z ;
1098  result++ ;
1099  }
1100  }else{
1101  *result = z ;
1102  result++ ;
1103  }
1104  }
1105 
1106  return count ;
1107 }
1108 
1110 {
1111  size_t size ;
1112 
1113  if( stl == StringListVoid ){
1114  return StringListVoid ;
1115  }
1116  if( index >= stl->size ){
1117  return stl ;
1118  }
1119  size = sizeof( string_t ) ;
1120  if( stl->stp[index] != StringVoid ){
1121  stl->stp[index]->owned = 0 ;
1122  }
1123  StringDelete( &stl->stp[index] ) ;
1124  memmove( stl->stp + index,stl->stp + index + 1,size * ( stl->size - 1 - index ) ) ;
1125  stl->size = stl->size - 1 ;
1126  return stl ;
1127 }
1128 
1130 {
1131  StringListRemoveAt( stl,at - stl->stp ) ;
1132  *end = *end - 1 ;
1133 }
1134 
1136 {
1137  string_t st;
1138  size_t size ;
1139 
1140  if( stl == StringListVoid ){
1141  return StringVoid ;
1142  }
1143  if( index >= stl->size ){
1144  return StringVoid ;
1145  }
1146 
1147  st = stl->stp[index] ;
1148  size = sizeof( string_t ) ;
1149 
1150  memmove( stl->stp + index,stl->stp + index + 1,size * ( stl->size - 1 - index ) ) ;
1151  stl->size = stl->size - 1 ;
1152 
1153  if( st != StringVoid ){
1154  st->owned = 0 ;
1155  }
1156 
1157  return st ;
1158 }
1159 
1160 ssize_t StringListRemoveString( stringList_t stl,const char * cstring )
1161 {
1162  ssize_t index = StringListContains( stl,cstring ) ;
1163  if( index == -1 ){
1164  return -1 ;
1165  }else{
1166  StringListRemoveAt( stl,index ) ;
1167  return index ;
1168  }
1169 }
1170 
1172 {
1173  if( stl == StringListVoid ){
1174  return StringVoid ;
1175  }else{
1176  if( index >= stl->size ){
1177  return StringVoid ;
1178  }else{
1179  return stl->stp[index] ;
1180  }
1181  }
1182 }
1183 
1185 {
1186  size_t i ;
1187  stringList_t stx ;
1188  size_t size ;
1189  string_t * k ;
1190  string_t e ;
1191 
1192  if( stl == NULL ){
1193  return ;
1194  }
1195  if( *stl == StringListVoid ){
1196  return ;
1197  }
1198 
1199  stx = *stl ;
1200  size = stx->size ;
1201  *stl = StringListVoid ;
1202 
1203  k = stx->stp ;
1204 
1205  for( i = 0 ; i < size ; i++ ){
1206  e = *( k + i ) ;
1207  if( e != StringVoid ){
1208  free( e->string ) ;
1209  free( e ) ;
1210  }
1211  }
1212  free( stx->stp ) ;
1213  free( stx );
1214 }
1215 
1217 {
1218  size_t i ;
1219  stringList_t stx ;
1220  size_t size ;
1221  string_t * k ;
1222  string_t e ;
1223 
1224  if( stl == NULL ){
1225  return ;
1226  }
1227  if( *stl == StringListVoid ){
1228  return ;
1229  }
1230 
1231  stx = *stl ;
1232  size = stx->size ;
1233  *stl = StringListVoid ;
1234 
1235  k = stx->stp ;
1236 
1237  for( i = 0 ; i < size ; i++ ){
1238  e = *( k + i ) ;
1239  if( e != StringVoid ){
1240  memset( e->string,'\0',e->length ) ;
1241  free( e->string ) ;
1242  free( e ) ;
1243  }
1244  }
1245  free( stx->stp ) ;
1246  free( stx );
1247 }
1248 
1250 {
1251  stringList_t * entry ;
1252  va_list list ;
1253  va_start( list,stl ) ;
1254 
1255  StringListDelete( stl ) ;
1256 
1257  while( 1 ){
1258  entry = va_arg( list,stringList_t * ) ;
1259 
1260  if( entry == NULL ){
1261  break ;
1262  }
1263  StringListDelete( entry ) ;
1264  }
1265 
1266  va_end( list ) ;
1267 }
1268 
1270 {
1271  size_t i ;
1272  size_t j ;
1273 
1274  string_t * st ;
1275  string_t * xt ;
1276 
1277  string_t st_1 ;
1278 
1279  stringList_t stx ;
1280  if( stl == StringListVoid ){
1281  return StringListVoid ;
1282  }
1283  j = stl->size ;
1284  stx = malloc( sizeof( struct StringListType ) ) ;
1285  if( stx == NULL ){
1286  return _StringListError() ;
1287  }
1288  stx->stp = malloc( sizeof( string_t ) * j ) ;
1289  if( stx->stp == NULL ){
1290  free( stx ) ;
1291  return _StringListError() ;
1292  }
1293  stx->size = stl->size ;
1294  xt = stx->stp ;
1295  st = stl->stp ;
1296  for( i = 0 ; i < j ; i++ ){
1297  st_1 = *( st + i ) ;
1298  if( st_1 == StringVoid ){
1299  xt[ i ] = StringVoid ;
1300  }else{
1301  xt[ i ] = StringWithSize( st_1->string,st_1->size ) ;
1302  xt[ i ]->owned = 1 ;
1303  }
1304  }
1305  return stx ;
1306 }
1307 
1309 {
1310  if( stl == StringListVoid ){
1311  return StringVoid ;
1312  }
1313  if( pos >= stl->size ){
1314  return StringVoid ;
1315  }
1316  return StringCopy( *( stl->stp + pos ) ) ;
1317 }
1318 
1319 stringList_t StringListSwap( stringList_t stl, size_t x,size_t y )
1320 {
1321  string_t p ;
1322 
1323  if( stl == StringListVoid || x >= stl->size || y >= stl->size ){
1324  return stl ;
1325  }else{
1326  p = stl->stp[ x ] ;
1327  stl->stp[ x ] = stl->stp[ y ] ;
1328  stl->stp[ y ] = p ;
1329 
1330  return stl ;
1331  }
1332 }
1333 
1334 void StringListPrintAt( stringList_t stl,size_t index )
1335 {
1336  if( stl != StringListVoid ){
1337  if( index < stl->size ){
1338  printf("%s",stl->stp[ index ]->string ) ;
1339  }
1340  }
1341 }
1342 
1343 void StringListPrintLineAt( stringList_t stl,size_t index )
1344 {
1345  if( stl != StringListVoid ){
1346  if( index < stl->size ){
1347  printf("%s\n",stl->stp[ index ]->string ) ;
1348  }
1349  }
1350 }
1351 
1353 {
1354  size_t i ;
1355  size_t j ;
1356  string_t * p ;
1357  string_t q ;
1358 
1359  if( stl == StringListVoid ){
1360  return ;
1361  }
1362 
1363  j = stl->size ;
1364  p = stl->stp ;
1365 
1366  for( i = 0 ; i < j ; i++ ){
1367  q = *( p + i ) ;
1368  if( q != StringVoid ){
1369  printf("%s\n",q->string ) ;
1370  }
1371  }
1372 }
1373 
StringListVoid
#define StringListVoid
Definition: StringList.h:41
StringListAssign
string_t * StringListAssign(stringList_t stl)
Definition: StringList.c:221
StringListRemoveIfStringStartsWith
size_t StringListRemoveIfStringStartsWith(stringList_t stl, const char *str)
Definition: StringList.c:984
StringListCopyStringAt
string_t StringListCopyStringAt(stringList_t stl, size_t pos)
Definition: StringList.c:1308
StringType::size
size_t size
Definition: String.c:58
StringListAssignString
string_t StringListAssignString(stringList_t stl, string_t st)
Definition: StringList.c:268
__ExpandMemory
static string_t * __ExpandMemory(stringList_t stl)
Definition: StringList.c:141
StringListInsertAtSize
stringList_t StringListInsertAtSize(stringList_t stl, const char *cstring, size_t len, size_t index)
Definition: StringList.c:684
StringCopy
string_t StringCopy(string_t st)
Definition: String.c:260
StringType::length
size_t length
Definition: String.c:62
_StringListError
static void * _StringListError(void)
Definition: StringList.c:59
StringListRemoveString
ssize_t StringListRemoveString(stringList_t stl, const char *cstring)
Definition: StringList.c:1160
StringInheritWithSize
string_t StringInheritWithSize(char **data, size_t size, size_t length)
Definition: String.c:429
StringListContentAtEqual
int StringListContentAtEqual(stringList_t stl, size_t index, const char *cstring)
Definition: StringList.c:514
StringListSize
size_t StringListSize(stringList_t stl)
Definition: StringList.c:492
StringListAppendList
stringList_t StringListAppendList(stringList_t p, stringList_t q)
Definition: StringList.c:393
StringListType::size
size_t size
Definition: StringList.c:35
StringListHasStartSequence_1
string_t StringListHasStartSequence_1(stringList_t stl, const char *str)
Definition: StringList.c:897
StringListForEachString_1
void StringListForEachString_1(stringList_t stl, void(*fct)(const char *, void *), void *arg)
Definition: StringList.c:122
StringListAppendString_1
void StringListAppendString_1(stringList_t *stl, string_t *st)
Definition: StringList.c:659
StringListAppendSize
stringList_t StringListAppendSize(stringList_t stl, const char *cstring, size_t len)
Definition: StringList.c:368
StringListGetIterators
void StringListGetIterators(stringList_t stl, StringListIterator *begin, StringListIterator *end)
Definition: StringList.c:210
StringListPrepend
stringList_t StringListPrepend(stringList_t stl, const char *cstring)
Definition: StringList.c:754
StringListForEach_1
void StringListForEach_1(stringList_t stl, void(*fct)(string_t, void *), void *arg)
Definition: StringList.c:84
StringListDetachAt
string_t StringListDetachAt(stringList_t stl, size_t index)
Definition: StringList.c:1135
_f
static void _f(void)
Definition: StringList.c:48
StringListAppendWithSize
stringList_t StringListAppendWithSize(stringList_t stl, char **c, size_t s, size_t l)
Definition: StringList.c:341
StringListInit
stringList_t StringListInit(void)
Definition: StringList.c:293
StringListHasStartSequence
ssize_t StringListHasStartSequence(stringList_t stl, const char *str)
Definition: StringList.c:869
StringListString
stringList_t StringListString(string_t *st)
Definition: StringList.c:647
StringListDelete
void StringListDelete(stringList_t *stl)
Definition: StringList.c:1184
StringListInsertAt
stringList_t StringListInsertAt(stringList_t stl, const char *cstring, size_t index)
Definition: StringList.c:553
StringListEnd
StringListIterator StringListEnd(stringList_t stl)
Definition: StringList.c:201
StringListRemoveIfPresent
size_t StringListRemoveIfPresent(stringList_t stl, const char *str)
Definition: StringList.c:1030
StringListPrependSize
stringList_t StringListPrependSize(stringList_t stl, const char *cstring, size_t len)
Definition: StringList.c:728
StringListStringSplit
stringList_t StringListStringSplit(string_t st, char splitter)
Definition: StringList.c:483
StringListContentAtLast
const char * StringListContentAtLast(stringList_t stl)
Definition: StringList.c:527
StringListStringAt
string_t StringListStringAt(stringList_t stl, size_t index)
Definition: StringList.c:1171
StringListAppendIfAbsent
stringList_t StringListAppendIfAbsent(stringList_t stl, const char *cstring)
Definition: StringList.c:794
StringListContains
ssize_t StringListContains(stringList_t stl, const char *cstring)
Definition: StringList.c:806
StringListMultipleDelete
void StringListMultipleDelete(stringList_t *stl,...)
Definition: StringList.c:1249
StringType
Definition: String.c:49
StringListType::length
size_t length
Definition: StringList.c:36
StringListHasSequence_1
string_t StringListHasSequence_1(stringList_t stl, const char *str)
Definition: StringList.c:858
StringListForEachString
void StringListForEachString(stringList_t stl, void(*fct)(const char *))
Definition: StringList.c:103
StringListPrintList
void StringListPrintList(stringList_t stl)
Definition: StringList.c:1352
StringListCopy
stringList_t StringListCopy(stringList_t stl)
Definition: StringList.c:1269
StringListBegin
StringListIterator StringListBegin(stringList_t stl)
Definition: StringList.c:192
StringList.h
StringListPrintLineAt
void StringListPrintLineAt(stringList_t stl, size_t index)
Definition: StringList.c:1343
_memory_error
static void(* _memory_error)(void)
Definition: StringList.c:52
String
string_t String(const char *cstring)
Definition: String.c:318
StringType::string
char * string
Definition: String.c:54
StringListHasSequence
ssize_t StringListHasSequence(stringList_t stl, const char *str)
Definition: StringList.c:832
StringListType::stp
string_t * stp
Definition: StringList.c:37
StringListArray
string_t * StringListArray(stringList_t *stz, size_t arraySize)
Definition: StringList.c:244
StringListWithSize
stringList_t StringListWithSize(char **c, size_t s, size_t t)
Definition: StringList.c:313
StringListType
Definition: StringList.c:33
StringListAppendString
stringList_t StringListAppendString(stringList_t stl, string_t st)
Definition: StringList.c:419
_StringListStringInsertAt
static int _StringListStringInsertAt(stringList_t stl, string_t *st, size_t index)
Definition: StringList.c:590
StringListForEach
void StringListForEach(stringList_t stl, void(*fct)(string_t))
Definition: StringList.c:65
StringListRemoveAt_1
void StringListRemoveAt_1(stringList_t stl, StringListIterator at, StringListIterator *end)
Definition: StringList.c:1129
StringListStringArray
char *const * StringListStringArray(stringList_t stl)
Definition: StringList.c:908
StringListStringAtLast
string_t StringListStringAtLast(stringList_t stl)
Definition: StringList.c:540
e
static QString e
Definition: about.cpp:31
StringListStringInsertAt
stringList_t StringListStringInsertAt(stringList_t stl, string_t *st, size_t index)
Definition: StringList.c:674
StringListSplit
stringList_t StringListSplit(const char *cstring, char splitter)
Definition: StringList.c:428
StringDelete
void StringDelete(string_t *st)
Definition: String.c:162
StringListSwap
stringList_t StringListSwap(stringList_t stl, size_t x, size_t y)
Definition: StringList.c:1319
StringListAppend
stringList_t StringListAppend(stringList_t stl, const char *cstring)
Definition: StringList.c:763
StringListClearDelete
void StringListClearDelete(stringList_t *stl)
Definition: StringList.c:1216
StringListRemoveIfPresent_1
size_t StringListRemoveIfPresent_1(stringList_t stl, string_t st)
Definition: StringList.c:1025
StringWithSize
string_t StringWithSize(const char *s, size_t len)
Definition: String.c:453
StringList
stringList_t StringList(const char *cstring)
Definition: StringList.c:157
StringListContentAt
const char * StringListContentAt(stringList_t stl, size_t index)
Definition: StringList.c:501
INIT_SIZE
#define INIT_SIZE
Definition: StringList.c:31
StringListPrintAt
void StringListPrintAt(stringList_t stl, size_t index)
Definition: StringList.c:1334
StringType::owned
int owned
Definition: String.c:66
FACTOR
#define FACTOR
Definition: StringList.c:26
StringListRemoveAt
stringList_t StringListRemoveAt(stringList_t stl, size_t index)
Definition: StringList.c:1109
StringListStringArray_1
void StringListStringArray_1(char *const **buffer, size_t *size, stringList_t stl)
Definition: StringList.c:943
StringListRemoveIfStringContains
size_t StringListRemoveIfStringContains(stringList_t stl, const char *str)
Definition: StringList.c:1070
_StringListString
static int _StringListString(string_t *st, stringList_t *r)
Definition: StringList.c:619
StringListExitOnMemoryExaustion
void StringListExitOnMemoryExaustion(void(*f)(void))
Definition: StringList.c:54
string_t
struct StringType * string_t
Definition: String.h:41
StringVoid
#define StringVoid
Definition: String.h:47