1 /**CFile****************************************************************
2
3 FileName [vecStr.h]
4
5 SystemName [ABC: Logic synthesis and verification system.]
6
7 PackageName [Resizable arrays.]
8
9 Synopsis [Resizable arrays of characters.]
10
11 Author [Alan Mishchenko]
12
13 Affiliation [UC Berkeley]
14
15 Date [Ver. 1.0. Started - June 20, 2005.]
16
17 Revision [$Id: vecStr.h,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
18
19 ***********************************************************************/
20
21 #ifndef ABC__misc__vec__vecStr_h
22 #define ABC__misc__vec__vecStr_h
23
24
25 ////////////////////////////////////////////////////////////////////////
26 /// INCLUDES ///
27 ////////////////////////////////////////////////////////////////////////
28
29 #include <stdio.h>
30
31 ABC_NAMESPACE_HEADER_START
32
33
34 ////////////////////////////////////////////////////////////////////////
35 /// PARAMETERS ///
36 ////////////////////////////////////////////////////////////////////////
37
38 ////////////////////////////////////////////////////////////////////////
39 /// BASIC TYPES ///
40 ////////////////////////////////////////////////////////////////////////
41
42 typedef struct Vec_Str_t_ Vec_Str_t;
43 struct Vec_Str_t_
44 {
45 int nCap;
46 int nSize;
47 char * pArray;
48 };
49
50 ////////////////////////////////////////////////////////////////////////
51 /// MACRO DEFINITIONS ///
52 ////////////////////////////////////////////////////////////////////////
53
54 #define Vec_StrForEachEntry( vVec, Entry, i ) \
55 for ( i = 0; (i < Vec_StrSize(vVec)) && (((Entry) = Vec_StrEntry(vVec, i)), 1); i++ )
56
57 ////////////////////////////////////////////////////////////////////////
58 /// FUNCTION DEFINITIONS ///
59 ////////////////////////////////////////////////////////////////////////
60
61 /**Function*************************************************************
62
63 Synopsis [Allocates a vector with the given capacity.]
64
65 Description []
66
67 SideEffects []
68
69 SeeAlso []
70
71 ***********************************************************************/
Vec_StrAlloc(int nCap)72 static inline Vec_Str_t * Vec_StrAlloc( int nCap )
73 {
74 Vec_Str_t * p;
75 p = ABC_ALLOC( Vec_Str_t, 1 );
76 if ( nCap > 0 && nCap < 16 )
77 nCap = 16;
78 p->nSize = 0;
79 p->nCap = nCap;
80 p->pArray = p->nCap? ABC_ALLOC( char, p->nCap ) : NULL;
81 return p;
82 }
Vec_StrAllocExact(int nCap)83 static inline Vec_Str_t * Vec_StrAllocExact( int nCap )
84 {
85 Vec_Str_t * p;
86 assert( nCap >= 0 );
87 p = ABC_ALLOC( Vec_Str_t, 1 );
88 p->nSize = 0;
89 p->nCap = nCap;
90 p->pArray = p->nCap? ABC_ALLOC( char, p->nCap ) : NULL;
91 return p;
92 }
93
94 /**Function*************************************************************
95
96 Synopsis [Allocates a vector with the given size and cleans it.]
97
98 Description []
99
100 SideEffects []
101
102 SeeAlso []
103
104 ***********************************************************************/
Vec_StrStart(int nSize)105 static inline Vec_Str_t * Vec_StrStart( int nSize )
106 {
107 Vec_Str_t * p;
108 p = Vec_StrAlloc( nSize );
109 p->nSize = nSize;
110 memset( p->pArray, 0, sizeof(char) * (size_t)nSize );
111 return p;
112 }
113
114 /**Function*************************************************************
115
116 Synopsis [Creates the vector from an integer array of the given size.]
117
118 Description []
119
120 SideEffects []
121
122 SeeAlso []
123
124 ***********************************************************************/
Vec_StrAllocArray(char * pArray,int nSize)125 static inline Vec_Str_t * Vec_StrAllocArray( char * pArray, int nSize )
126 {
127 Vec_Str_t * p;
128 p = ABC_ALLOC( Vec_Str_t, 1 );
129 p->nSize = nSize;
130 p->nCap = nSize;
131 p->pArray = pArray;
132 return p;
133 }
134
135 /**Function*************************************************************
136
137 Synopsis [Creates the vector from an integer array of the given size.]
138
139 Description []
140
141 SideEffects []
142
143 SeeAlso []
144
145 ***********************************************************************/
Vec_StrAllocArrayCopy(char * pArray,int nSize)146 static inline Vec_Str_t * Vec_StrAllocArrayCopy( char * pArray, int nSize )
147 {
148 Vec_Str_t * p;
149 p = ABC_ALLOC( Vec_Str_t, 1 );
150 p->nSize = nSize;
151 p->nCap = nSize;
152 p->pArray = ABC_ALLOC( char, nSize );
153 memcpy( p->pArray, pArray, sizeof(char) * (size_t)nSize );
154 return p;
155 }
156
157 /**Function*************************************************************
158
159 Synopsis [Duplicates the integer array.]
160
161 Description []
162
163 SideEffects []
164
165 SeeAlso []
166
167 ***********************************************************************/
Vec_StrDup(Vec_Str_t * pVec)168 static inline Vec_Str_t * Vec_StrDup( Vec_Str_t * pVec )
169 {
170 Vec_Str_t * p;
171 p = ABC_ALLOC( Vec_Str_t, 1 );
172 p->nSize = pVec->nSize;
173 p->nCap = pVec->nCap;
174 p->pArray = p->nCap? ABC_ALLOC( char, p->nCap ) : NULL;
175 memcpy( p->pArray, pVec->pArray, sizeof(char) * (size_t)pVec->nSize );
176 return p;
177 }
178
179 /**Function*************************************************************
180
181 Synopsis [Transfers the array into another vector.]
182
183 Description []
184
185 SideEffects []
186
187 SeeAlso []
188
189 ***********************************************************************/
Vec_StrDupArray(Vec_Str_t * pVec)190 static inline Vec_Str_t * Vec_StrDupArray( Vec_Str_t * pVec )
191 {
192 Vec_Str_t * p;
193 p = ABC_ALLOC( Vec_Str_t, 1 );
194 p->nSize = pVec->nSize;
195 p->nCap = pVec->nCap;
196 p->pArray = pVec->pArray;
197 pVec->nSize = 0;
198 pVec->nCap = 0;
199 pVec->pArray = NULL;
200 return p;
201 }
202
203 /**Function*************************************************************
204
205 Synopsis []
206
207 Description []
208
209 SideEffects []
210
211 SeeAlso []
212
213 ***********************************************************************/
Vec_StrZero(Vec_Str_t * p)214 static inline void Vec_StrZero( Vec_Str_t * p )
215 {
216 p->pArray = NULL;
217 p->nSize = 0;
218 p->nCap = 0;
219 }
Vec_StrErase(Vec_Str_t * p)220 static inline void Vec_StrErase( Vec_Str_t * p )
221 {
222 ABC_FREE( p->pArray );
223 p->nSize = 0;
224 p->nCap = 0;
225 }
Vec_StrFree(Vec_Str_t * p)226 static inline void Vec_StrFree( Vec_Str_t * p )
227 {
228 ABC_FREE( p->pArray );
229 ABC_FREE( p );
230 }
231
232 /**Function*************************************************************
233
234 Synopsis []
235
236 Description []
237
238 SideEffects []
239
240 SeeAlso []
241
242 ***********************************************************************/
Vec_StrFreeP(Vec_Str_t ** p)243 static inline void Vec_StrFreeP( Vec_Str_t ** p )
244 {
245 if ( *p == NULL )
246 return;
247 ABC_FREE( (*p)->pArray );
248 ABC_FREE( (*p) );
249 }
250
251 /**Function*************************************************************
252
253 Synopsis []
254
255 Description []
256
257 SideEffects []
258
259 SeeAlso []
260
261 ***********************************************************************/
Vec_StrReleaseArray(Vec_Str_t * p)262 static inline char * Vec_StrReleaseArray( Vec_Str_t * p )
263 {
264 char * pArray = p->pArray;
265 p->nCap = 0;
266 p->nSize = 0;
267 p->pArray = NULL;
268 return pArray;
269 }
270
271 /**Function*************************************************************
272
273 Synopsis []
274
275 Description []
276
277 SideEffects []
278
279 SeeAlso []
280
281 ***********************************************************************/
Vec_StrArray(Vec_Str_t * p)282 static inline char * Vec_StrArray( Vec_Str_t * p )
283 {
284 return p->pArray;
285 }
Vec_StrLimit(Vec_Str_t * p)286 static inline char * Vec_StrLimit( Vec_Str_t * p )
287 {
288 return p->pArray + p->nSize;
289 }
290
291 /**Function*************************************************************
292
293 Synopsis []
294
295 Description []
296
297 SideEffects []
298
299 SeeAlso []
300
301 ***********************************************************************/
Vec_StrSize(Vec_Str_t * p)302 static inline int Vec_StrSize( Vec_Str_t * p )
303 {
304 return p->nSize;
305 }
Vec_StrSetSize(Vec_Str_t * p,int nSize)306 static inline void Vec_StrSetSize( Vec_Str_t * p, int nSize )
307 {
308 p->nSize = nSize;
309 }
310
311 /**Function*************************************************************
312
313 Synopsis []
314
315 Description []
316
317 SideEffects []
318
319 SeeAlso []
320
321 ***********************************************************************/
Vec_StrCap(Vec_Str_t * p)322 static inline int Vec_StrCap( Vec_Str_t * p )
323 {
324 return p->nCap;
325 }
326
327 /**Function*************************************************************
328
329 Synopsis []
330
331 Description []
332
333 SideEffects []
334
335 SeeAlso []
336
337 ***********************************************************************/
Vec_StrMemory(Vec_Str_t * p)338 static inline double Vec_StrMemory( Vec_Str_t * p )
339 {
340 return !p ? 0.0 : 1.0 * sizeof(char) * (size_t)p->nCap + sizeof(Vec_Str_t);
341 }
342
343 /**Function*************************************************************
344
345 Synopsis []
346
347 Description []
348
349 SideEffects []
350
351 SeeAlso []
352
353 ***********************************************************************/
Vec_StrEntry(Vec_Str_t * p,int i)354 static inline char Vec_StrEntry( Vec_Str_t * p, int i )
355 {
356 assert( i >= 0 && i < p->nSize );
357 return p->pArray[i];
358 }
359
360 /**Function*************************************************************
361
362 Synopsis []
363
364 Description []
365
366 SideEffects []
367
368 SeeAlso []
369
370 ***********************************************************************/
Vec_StrEntryP(Vec_Str_t * p,int i)371 static inline char * Vec_StrEntryP( Vec_Str_t * p, int i )
372 {
373 assert( i >= 0 && i < p->nSize );
374 return p->pArray + i;
375 }
376
377 /**Function*************************************************************
378
379 Synopsis []
380
381 Description []
382
383 SideEffects []
384
385 SeeAlso []
386
387 ***********************************************************************/
Vec_StrWriteEntry(Vec_Str_t * p,int i,char Entry)388 static inline void Vec_StrWriteEntry( Vec_Str_t * p, int i, char Entry )
389 {
390 assert( i >= 0 && i < p->nSize );
391 p->pArray[i] = Entry;
392 }
393
394 /**Function*************************************************************
395
396 Synopsis []
397
398 Description []
399
400 SideEffects []
401
402 SeeAlso []
403
404 ***********************************************************************/
Vec_StrEntryLast(Vec_Str_t * p)405 static inline char Vec_StrEntryLast( Vec_Str_t * p )
406 {
407 assert( p->nSize > 0 );
408 return p->pArray[p->nSize-1];
409 }
410
411 /**Function*************************************************************
412
413 Synopsis [Resizes the vector to the given capacity.]
414
415 Description []
416
417 SideEffects []
418
419 SeeAlso []
420
421 ***********************************************************************/
Vec_StrGrow(Vec_Str_t * p,int nCapMin)422 static inline void Vec_StrGrow( Vec_Str_t * p, int nCapMin )
423 {
424 if ( p->nCap >= nCapMin )
425 return;
426 p->pArray = ABC_REALLOC( char, p->pArray, nCapMin );
427 p->nCap = nCapMin;
428 }
429
430 /**Function*************************************************************
431
432 Synopsis [Fills the vector with given number of entries.]
433
434 Description []
435
436 SideEffects []
437
438 SeeAlso []
439
440 ***********************************************************************/
Vec_StrFill(Vec_Str_t * p,int nSize,char Fill)441 static inline void Vec_StrFill( Vec_Str_t * p, int nSize, char Fill )
442 {
443 int i;
444 Vec_StrGrow( p, nSize );
445 p->nSize = nSize;
446 for ( i = 0; i < p->nSize; i++ )
447 p->pArray[i] = Fill;
448 }
449
450 /**Function*************************************************************
451
452 Synopsis [Fills the vector with given number of entries.]
453
454 Description []
455
456 SideEffects []
457
458 SeeAlso []
459
460 ***********************************************************************/
Vec_StrFillExtra(Vec_Str_t * p,int nSize,char Fill)461 static inline void Vec_StrFillExtra( Vec_Str_t * p, int nSize, char Fill )
462 {
463 int i;
464 if ( nSize <= p->nSize )
465 return;
466 if ( nSize > 2 * p->nCap )
467 Vec_StrGrow( p, nSize );
468 else if ( nSize > p->nCap )
469 Vec_StrGrow( p, 2 * p->nCap );
470 for ( i = p->nSize; i < nSize; i++ )
471 p->pArray[i] = Fill;
472 p->nSize = nSize;
473 }
474
475 /**Function*************************************************************
476
477 Synopsis [Returns the entry even if the place not exist.]
478
479 Description []
480
481 SideEffects []
482
483 SeeAlso []
484
485 ***********************************************************************/
Vec_StrGetEntry(Vec_Str_t * p,int i)486 static inline char Vec_StrGetEntry( Vec_Str_t * p, int i )
487 {
488 Vec_StrFillExtra( p, i + 1, 0 );
489 return Vec_StrEntry( p, i );
490 }
491
492 /**Function*************************************************************
493
494 Synopsis [Inserts the entry even if the place does not exist.]
495
496 Description []
497
498 SideEffects []
499
500 SeeAlso []
501
502 ***********************************************************************/
Vec_StrSetEntry(Vec_Str_t * p,int i,char Entry)503 static inline void Vec_StrSetEntry( Vec_Str_t * p, int i, char Entry )
504 {
505 Vec_StrFillExtra( p, i + 1, 0 );
506 Vec_StrWriteEntry( p, i, Entry );
507 }
508
509 /**Function*************************************************************
510
511 Synopsis []
512
513 Description []
514
515 SideEffects []
516
517 SeeAlso []
518
519 ***********************************************************************/
Vec_StrShrink(Vec_Str_t * p,int nSizeNew)520 static inline void Vec_StrShrink( Vec_Str_t * p, int nSizeNew )
521 {
522 assert( p->nSize >= nSizeNew );
523 p->nSize = nSizeNew;
524 }
525
526 /**Function*************************************************************
527
528 Synopsis []
529
530 Description []
531
532 SideEffects []
533
534 SeeAlso []
535
536 ***********************************************************************/
Vec_StrClear(Vec_Str_t * p)537 static inline void Vec_StrClear( Vec_Str_t * p )
538 {
539 p->nSize = 0;
540 }
541
542 /**Function*************************************************************
543
544 Synopsis []
545
546 Description []
547
548 SideEffects []
549
550 SeeAlso []
551
552 ***********************************************************************/
Vec_StrPush(Vec_Str_t * p,char Entry)553 static inline void Vec_StrPush( Vec_Str_t * p, char Entry )
554 {
555 if ( p->nSize == p->nCap )
556 {
557 if ( p->nCap < 16 )
558 Vec_StrGrow( p, 16 );
559 else
560 Vec_StrGrow( p, 2 * p->nCap );
561 }
562 p->pArray[p->nSize++] = Entry;
563 }
Vec_StrPushBuffer(Vec_Str_t * p,char * pBuffer,int nSize)564 static inline void Vec_StrPushBuffer( Vec_Str_t * p, char * pBuffer, int nSize )
565 {
566 if ( p->nSize + nSize > p->nCap )
567 Vec_StrGrow( p, 2 * (p->nSize + nSize) );
568 memcpy( p->pArray + p->nSize, pBuffer, (size_t)nSize );
569 p->nSize += nSize;
570 }
571
572 /**Function*************************************************************
573
574 Synopsis [Returns the last entry and removes it from the list.]
575
576 Description []
577
578 SideEffects []
579
580 SeeAlso []
581
582 ***********************************************************************/
Vec_StrPop(Vec_Str_t * p)583 static inline char Vec_StrPop( Vec_Str_t * p )
584 {
585 assert( p->nSize > 0 );
586 return p->pArray[--p->nSize];
587 }
588
589 /**Function*************************************************************
590
591 Synopsis []
592
593 Description []
594
595 SideEffects []
596
597 SeeAlso []
598
599 ***********************************************************************/
Vec_StrIntPrint(Vec_Str_t * p)600 static inline void Vec_StrIntPrint( Vec_Str_t * p )
601 {
602 int i;
603 printf( "Vector has %d entries: {", Vec_StrSize(p) );
604 for ( i = 0; i < Vec_StrSize(p); i++ )
605 printf( " %d", (int)Vec_StrEntry(p, i) );
606 printf( " }\n" );
607 }
608
609 /**Function*************************************************************
610
611 Synopsis []
612
613 Description []
614
615 SideEffects []
616
617 SeeAlso []
618
619 ***********************************************************************/
Vec_StrPrintNum(Vec_Str_t * p,int Num)620 static inline void Vec_StrPrintNum( Vec_Str_t * p, int Num )
621 {
622 int i;
623 char Digits[16];
624 if ( Num == 0 )
625 {
626 Vec_StrPush( p, '0' );
627 return;
628 }
629 if ( Num < 0 )
630 {
631 Vec_StrPush( p, '-' );
632 Num = -Num;
633 }
634 for ( i = 0; Num; Num /= 10, i++ )
635 Digits[i] = Num % 10;
636 for ( i--; i >= 0; i-- )
637 Vec_StrPush( p, (char)('0' + Digits[i]) );
638 }
Vec_StrPrintNumStar(Vec_Str_t * p,int Num,int nDigits)639 static inline void Vec_StrPrintNumStar( Vec_Str_t * p, int Num, int nDigits )
640 {
641 int i;
642 char Digits[16] = {0};
643 if ( Num == 0 )
644 {
645 for ( i = 0; i < nDigits; i++ )
646 Vec_StrPush( p, '0' );
647 return;
648 }
649 if ( Num < 0 )
650 {
651 Vec_StrPush( p, '-' );
652 Num = -Num;
653 nDigits--;
654 }
655 for ( i = 0; Num; Num /= 10, i++ )
656 Digits[i] = Num % 10;
657 for ( i = Abc_MaxInt(i, nDigits)-1; i >= 0; i-- )
658 Vec_StrPush( p, (char)('0' + Digits[i]) );
659 }
660
661 /**Function*************************************************************
662
663 Synopsis []
664
665 Description []
666
667 SideEffects []
668
669 SeeAlso []
670
671 ***********************************************************************/
Vec_StrPrintStr(Vec_Str_t * p,const char * pStr)672 static inline void Vec_StrPrintStr( Vec_Str_t * p, const char * pStr )
673 {
674 int i, Length = (int)strlen(pStr);
675 for ( i = 0; i < Length; i++ )
676 Vec_StrPush( p, pStr[i] );
677 }
678
679
680 /**Function*************************************************************
681
682 Synopsis []
683
684 Description []
685
686 SideEffects []
687
688 SeeAlso []
689
690 ***********************************************************************/
691 #ifdef WIN32
692 #define vsnprintf _vsnprintf
693 #endif
694
Vec_StrPrintF(Vec_Str_t * p,const char * format,...)695 static inline char * Vec_StrPrintF( Vec_Str_t * p, const char * format, ... )
696 {
697 int nAdded, nSize = 1000;
698 va_list args; va_start( args, format );
699 Vec_StrGrow( p, Vec_StrSize(p) + nSize );
700 nAdded = vsnprintf( Vec_StrLimit(p), nSize, format, args );
701 if ( nAdded > nSize )
702 {
703 Vec_StrGrow( p, Vec_StrSize(p) + nAdded + nSize );
704 nSize = vsnprintf( Vec_StrLimit(p), nAdded, format, args );
705 assert( nSize == nAdded );
706 }
707 p->nSize += nAdded;
708 va_end( args );
709 return Vec_StrLimit(p) - nAdded;
710 }
711
712 /**Function*************************************************************
713
714 Synopsis [Appends the string to the char vector.]
715
716 Description []
717
718 SideEffects []
719
720 SeeAlso []
721
722 ***********************************************************************/
Vec_StrAppend(Vec_Str_t * p,const char * pString)723 static inline void Vec_StrAppend( Vec_Str_t * p, const char * pString )
724 {
725 Vec_StrPrintStr( p, pString );
726 }
Vec_StrCopy(Vec_Str_t * p,const char * pString)727 static inline void Vec_StrCopy( Vec_Str_t * p, const char * pString )
728 {
729 Vec_StrClear( p );
730 Vec_StrAppend( p, pString );
731 Vec_StrPush( p, '\0' );
732 }
733
734 /**Function*************************************************************
735
736 Synopsis [Reverses the order of entries.]
737
738 Description []
739
740 SideEffects []
741
742 SeeAlso []
743
744 ***********************************************************************/
Vec_StrReverseOrder(Vec_Str_t * p)745 static inline void Vec_StrReverseOrder( Vec_Str_t * p )
746 {
747 int i, Temp;
748 for ( i = 0; i < p->nSize/2; i++ )
749 {
750 Temp = p->pArray[i];
751 p->pArray[i] = p->pArray[p->nSize-1-i];
752 p->pArray[p->nSize-1-i] = Temp;
753 }
754 }
755
756 /**Function*************************************************************
757
758 Synopsis []
759
760 Description []
761
762 SideEffects []
763
764 SeeAlso []
765
766 ***********************************************************************/
Vec_StrSum(Vec_Str_t * p)767 static inline int Vec_StrSum( Vec_Str_t * p )
768 {
769 int i, Counter = 0;
770 for ( i = 0; i < p->nSize; i++ )
771 Counter += (int)p->pArray[i];
772 return Counter;
773 }
774
775 /**Function*************************************************************
776
777 Synopsis []
778
779 Description []
780
781 SideEffects []
782
783 SeeAlso []
784
785 ***********************************************************************/
Vec_StrCountEntry(Vec_Str_t * p,char Entry)786 static inline int Vec_StrCountEntry( Vec_Str_t * p, char Entry )
787 {
788 int i, Counter = 0;
789 for ( i = 0; i < p->nSize; i++ )
790 Counter += (p->pArray[i] == Entry);
791 return Counter;
792 }
Vec_StrCountLarger(Vec_Str_t * p,char Entry)793 static inline int Vec_StrCountLarger( Vec_Str_t * p, char Entry )
794 {
795 int i, Counter = 0;
796 for ( i = 0; i < p->nSize; i++ )
797 Counter += (p->pArray[i] > Entry);
798 return Counter;
799 }
Vec_StrCountSmaller(Vec_Str_t * p,char Entry)800 static inline int Vec_StrCountSmaller( Vec_Str_t * p, char Entry )
801 {
802 int i, Counter = 0;
803 for ( i = 0; i < p->nSize; i++ )
804 Counter += (p->pArray[i] < Entry);
805 return Counter;
806 }
807
808 /**Function*************************************************************
809
810 Synopsis []
811
812 Description []
813
814 SideEffects []
815
816 SeeAlso []
817
818 ***********************************************************************/
Vec_StrCountEntryLit(Vec_Str_t * p,char Entry)819 static inline int Vec_StrCountEntryLit( Vec_Str_t * p, char Entry )
820 {
821 int i, Counter = 0;
822 for ( i = 0; i < p->nSize; i++ )
823 Counter += (Abc_Lit2Var((int)p->pArray[i]) == Entry);
824 return Counter;
825 }
Vec_StrCountLargerLit(Vec_Str_t * p,char Entry)826 static inline int Vec_StrCountLargerLit( Vec_Str_t * p, char Entry )
827 {
828 int i, Counter = 0;
829 for ( i = 0; i < p->nSize; i++ )
830 Counter += (Abc_Lit2Var((int)p->pArray[i]) > Entry);
831 return Counter;
832 }
Vec_StrCountSmallerLit(Vec_Str_t * p,char Entry)833 static inline int Vec_StrCountSmallerLit( Vec_Str_t * p, char Entry )
834 {
835 int i, Counter = 0;
836 for ( i = 0; i < p->nSize; i++ )
837 Counter += (Abc_Lit2Var((int)p->pArray[i]) < Entry);
838 return Counter;
839 }
840
841 /**Function*************************************************************
842
843 Synopsis [Compares two strings.]
844
845 Description []
846
847 SideEffects []
848
849 SeeAlso []
850
851 ***********************************************************************/
Vec_StrEqual(Vec_Str_t * p1,Vec_Str_t * p2)852 static inline int Vec_StrEqual( Vec_Str_t * p1, Vec_Str_t * p2 )
853 {
854 int i;
855 if ( p1->nSize != p2->nSize )
856 return 0;
857 for ( i = 0; i < p1->nSize; i++ )
858 if ( p1->pArray[i] != p2->pArray[i] )
859 return 0;
860 return 1;
861 }
862
863 /**Function*************************************************************
864
865 Synopsis [Comparison procedure for two clauses.]
866
867 Description []
868
869 SideEffects []
870
871 SeeAlso []
872
873 ***********************************************************************/
Vec_StrSortCompare1(char * pp1,char * pp2)874 static int Vec_StrSortCompare1( char * pp1, char * pp2 )
875 {
876 // for some reason commenting out lines (as shown) led to crashing of the release version
877 if ( *pp1 < *pp2 )
878 return -1;
879 if ( *pp1 > *pp2 ) //
880 return 1;
881 return 0; //
882 }
883
884 /**Function*************************************************************
885
886 Synopsis [Comparison procedure for two clauses.]
887
888 Description []
889
890 SideEffects []
891
892 SeeAlso []
893
894 ***********************************************************************/
Vec_StrSortCompare2(char * pp1,char * pp2)895 static int Vec_StrSortCompare2( char * pp1, char * pp2 )
896 {
897 // for some reason commenting out lines (as shown) led to crashing of the release version
898 if ( *pp1 > *pp2 )
899 return -1;
900 if ( *pp1 < *pp2 ) //
901 return 1;
902 return 0; //
903 }
904
905 /**Function*************************************************************
906
907 Synopsis [Sorting the entries by their integer value.]
908
909 Description []
910
911 SideEffects []
912
913 SeeAlso []
914
915 ***********************************************************************/
Vec_StrSort(Vec_Str_t * p,int fReverse)916 static inline void Vec_StrSort( Vec_Str_t * p, int fReverse )
917 {
918 if ( fReverse )
919 qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(char),
920 (int (*)(const void *, const void *)) Vec_StrSortCompare2 );
921 else
922 qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(char),
923 (int (*)(const void *, const void *)) Vec_StrSortCompare1 );
924 }
925
926 /**Function*************************************************************
927
928 Synopsis []
929
930 Description []
931
932 SideEffects []
933
934 SeeAlso []
935
936 ***********************************************************************/
Vec_StrCompareVec(Vec_Str_t * p1,Vec_Str_t * p2)937 static inline int Vec_StrCompareVec( Vec_Str_t * p1, Vec_Str_t * p2 )
938 {
939 if ( p1 == NULL || p2 == NULL )
940 return (p1 != NULL) - (p2 != NULL);
941 if ( Vec_StrSize(p1) != Vec_StrSize(p2) )
942 return Vec_StrSize(p1) - Vec_StrSize(p2);
943 return memcmp( Vec_StrArray(p1), Vec_StrArray(p2), (size_t)Vec_StrSize(p1) );
944 }
945
946
947 /**Function*************************************************************
948
949 Synopsis [Binary I/O for numbers (int/float/etc) and strings (char *).]
950
951 Description []
952
953 SideEffects []
954
955 SeeAlso []
956
957 ***********************************************************************/
Vec_StrPutI_ne(Vec_Str_t * vOut,int Val)958 static inline void Vec_StrPutI_ne( Vec_Str_t * vOut, int Val )
959 {
960 int i;
961 // for ( i = 0; i < 4; i++ )
962 for ( i = 3; i >= 0; i-- )
963 Vec_StrPush( vOut, (char)(Val >> (8*i)) );
964 }
Vec_StrGetI_ne(Vec_Str_t * vOut,int * pPos)965 static inline int Vec_StrGetI_ne( Vec_Str_t * vOut, int * pPos )
966 {
967 int i;
968 int Val = 0;
969 // for ( i = 0; i < 4; i++ )
970 for ( i = 3; i >= 0; i-- )
971 Val |= ((int)(unsigned char)Vec_StrEntry(vOut, (*pPos)++) << (8*i));
972 return Val;
973 }
974
Vec_StrPutI(Vec_Str_t * vOut,int Val)975 static inline void Vec_StrPutI( Vec_Str_t * vOut, int Val )
976 {
977 for ( ; Val >= 0x80; Val >>= 7 )
978 Vec_StrPush( vOut, (unsigned char)(Val | 0x80) );
979 Vec_StrPush( vOut, (unsigned char)Val );
980 }
Vec_StrGetI(Vec_Str_t * vOut,int * pPos)981 static inline int Vec_StrGetI( Vec_Str_t * vOut, int * pPos )
982 {
983 unsigned char ch;
984 int i = 0, Val = 0;
985 while ( (ch = Vec_StrEntry(vOut, (*pPos)++)) & 0x80 )
986 Val |= ((ch & 0x7f) << (7 * i++));
987 return Val | (ch << (7 * i));
988 }
989
Vec_StrPutW(Vec_Str_t * vOut,word Val)990 static inline void Vec_StrPutW( Vec_Str_t * vOut, word Val )
991 {
992 int i;
993 for ( i = 0; i < 8; i++ )
994 Vec_StrPush( vOut, (char)(Val >> (8*i)) );
995 }
Vec_StrGetW(Vec_Str_t * vOut,int * pPos)996 static inline word Vec_StrGetW( Vec_Str_t * vOut, int * pPos )
997 {
998 int i;
999 word Val = 0;
1000 for ( i = 0; i < 8; i++ )
1001 Val |= ((word)(unsigned char)Vec_StrEntry(vOut, (*pPos)++) << (8*i));
1002 return Val;
1003 }
1004
Vec_StrPutF(Vec_Str_t * vOut,float Val)1005 static inline void Vec_StrPutF( Vec_Str_t * vOut, float Val )
1006 {
1007 union { float num; unsigned char data[4]; } tmp;
1008 tmp.num = Val;
1009 Vec_StrPush( vOut, tmp.data[0] );
1010 Vec_StrPush( vOut, tmp.data[1] );
1011 Vec_StrPush( vOut, tmp.data[2] );
1012 Vec_StrPush( vOut, tmp.data[3] );
1013 }
Vec_StrGetF(Vec_Str_t * vOut,int * pPos)1014 static inline float Vec_StrGetF( Vec_Str_t * vOut, int * pPos )
1015 {
1016 union { float num; unsigned char data[4]; } tmp;
1017 tmp.data[0] = Vec_StrEntry( vOut, (*pPos)++ );
1018 tmp.data[1] = Vec_StrEntry( vOut, (*pPos)++ );
1019 tmp.data[2] = Vec_StrEntry( vOut, (*pPos)++ );
1020 tmp.data[3] = Vec_StrEntry( vOut, (*pPos)++ );
1021 return tmp.num;
1022 }
1023
Vec_StrPutD(Vec_Str_t * vOut,double Val)1024 static inline void Vec_StrPutD( Vec_Str_t * vOut, double Val )
1025 {
1026 union { double num; unsigned char data[8]; } tmp;
1027 int i, Lim = sizeof(double);
1028 tmp.num = Val;
1029 for ( i = 0; i < Lim; i++ )
1030 Vec_StrPush( vOut, tmp.data[i] );
1031 }
Vec_StrGetD(Vec_Str_t * vOut,int * pPos)1032 static inline double Vec_StrGetD( Vec_Str_t * vOut, int * pPos )
1033 {
1034 union { double num; unsigned char data[8]; } tmp;
1035 int i, Lim = sizeof(double);
1036 for ( i = 0; i < Lim; i++ )
1037 tmp.data[i] = Vec_StrEntry( vOut, (*pPos)++ );
1038 return tmp.num;
1039 }
1040
Vec_StrPutS(Vec_Str_t * vOut,char * pStr)1041 static inline void Vec_StrPutS( Vec_Str_t * vOut, char * pStr )
1042 {
1043 while ( *pStr )
1044 Vec_StrPush( vOut, *pStr++ );
1045 Vec_StrPush( vOut, (char)0 );
1046 }
Vec_StrGetS(Vec_Str_t * vOut,int * pPos)1047 static inline char * Vec_StrGetS( Vec_Str_t * vOut, int * pPos )
1048 {
1049 char * pStr = Vec_StrEntryP( vOut, *pPos );
1050 while ( Vec_StrEntry(vOut, (*pPos)++) );
1051 return Abc_UtilStrsav(pStr);
1052 }
1053
Vec_StrPutC(Vec_Str_t * vOut,char c)1054 static inline void Vec_StrPutC( Vec_Str_t * vOut, char c )
1055 {
1056 Vec_StrPush( vOut, c );
1057 }
Vec_StrGetC(Vec_Str_t * vOut,int * pPos)1058 static inline char Vec_StrGetC( Vec_Str_t * vOut, int * pPos )
1059 {
1060 return Vec_StrEntry(vOut, (*pPos)++);
1061 }
1062
1063
1064
1065 ABC_NAMESPACE_HEADER_END
1066
1067 #endif
1068
1069 ////////////////////////////////////////////////////////////////////////
1070 /// END OF FILE ///
1071 ////////////////////////////////////////////////////////////////////////
1072
1073