abc-master
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
utilNam.c
Go to the documentation of this file.
1 /**CFile****************************************************************
2 
3  FileName [utilNam.c]
4 
5  SystemName [ABC: Logic synthesis and verification system.]
6 
7  PackageName [Manager for character strings.]
8 
9  Synopsis [Manager for character strings.]
10 
11  Author [Alan Mishchenko]
12 
13  Affiliation [UC Berkeley]
14 
15  Date [Ver. 1.0. Started - June 20, 2005.]
16 
17  Revision [$Id: utilNam.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
18 
19 ***********************************************************************/
20 
21 
22 #include <stdio.h>
23 #include <string.h>
24 #include <stdlib.h>
25 #include <assert.h>
26 
27 #include "abc_global.h"
28 #include "misc/vec/vec.h"
29 #include "utilNam.h"
30 
31 ABC_NAMESPACE_IMPL_START
32 
33 
34 ////////////////////////////////////////////////////////////////////////
35 /// DECLARATIONS ///
36 ////////////////////////////////////////////////////////////////////////
37 
38 // this package maps non-empty character strings into natural numbers and back
39 
40 // name manager
41 struct Abc_Nam_t_
42 {
43  // info storage for names
44  int nStore; // the size of allocated storage
45  int iHandle; // the current free handle
46  char * pStore; // storage for name objects
47  // internal number mappings
48  Vec_Int_t * vInt2Handle; // mapping integers into handles
49  Vec_Int_t * vInt2Next; // mapping integers into nexts
50  // hash table for names
51  int * pBins; // the hash table bins
52  int nBins; // the number of bins
53  // manager recycling
54  int nRefs; // reference counter for the manager
55 };
56 
57 static inline char * Abc_NamHandleToStr( Abc_Nam_t * p, int h ) { return (char *)(p->pStore + h); }
58 static inline int Abc_NamIntToHandle( Abc_Nam_t * p, int i ) { return Vec_IntEntry(p->vInt2Handle, i); }
59 static inline char * Abc_NamIntToStr( Abc_Nam_t * p, int i ) { return Abc_NamHandleToStr(p, Abc_NamIntToHandle(p,i)); }
60 static inline int Abc_NamIntToNext( Abc_Nam_t * p, int i ) { return Vec_IntEntry(p->vInt2Next, i); }
61 static inline int * Abc_NamIntToNextP( Abc_Nam_t * p, int i ) { return Vec_IntEntryP(p->vInt2Next, i); }
62 
63 ////////////////////////////////////////////////////////////////////////
64 /// FUNCTION DEFINITIONS ///
65 ////////////////////////////////////////////////////////////////////////
66 
67 /**Function*************************************************************
68 
69  Synopsis [Creates manager.]
70 
71  Description []
72 
73  SideEffects []
74 
75  SeeAlso []
76 
77 ***********************************************************************/
78 Abc_Nam_t * Abc_NamStart( int nObjs, int nAveSize )
79 {
80  Abc_Nam_t * p;
81  if ( nObjs == 0 )
82  nObjs = 16;
83  p = ABC_CALLOC( Abc_Nam_t, 1 );
84  p->nStore = ((nObjs * (nAveSize + 1) + 16) / 4) * 4;
85  p->pStore = ABC_ALLOC( char, p->nStore );
86  p->nBins = Abc_PrimeCudd( nObjs );
87  p->pBins = ABC_CALLOC( int, p->nBins );
88  // 0th object is unused
89  p->vInt2Handle = Vec_IntAlloc( nObjs ); Vec_IntPush( p->vInt2Handle, -1 );
90  p->vInt2Next = Vec_IntAlloc( nObjs ); Vec_IntPush( p->vInt2Next, -1 );
91  p->iHandle = 4;
92  memset( p->pStore, 0, 4 );
93 //Abc_Print( 1, "Starting nam with %d bins.\n", p->nBins );
94  // start reference counting
95  p->nRefs = 1;
96  return p;
97 }
98 
99 /**Function*************************************************************
100 
101  Synopsis [Deletes manager.]
102 
103  Description []
104 
105  SideEffects []
106 
107  SeeAlso []
108 
109 ***********************************************************************/
110 void Abc_NamStop( Abc_Nam_t * p )
111 {
112 //Abc_Print( 1, "Starting nam with %d bins.\n", p->nBins );
113  Vec_IntFree( p->vInt2Handle );
114  Vec_IntFree( p->vInt2Next );
115  ABC_FREE( p->pStore );
116  ABC_FREE( p->pBins );
117  ABC_FREE( p );
118 }
119 
120 /**Function*************************************************************
121 
122  Synopsis [Prints manager.]
123 
124  Description []
125 
126  SideEffects []
127 
128  SeeAlso []
129 
130 ***********************************************************************/
131 void Abc_NamPrint( Abc_Nam_t * p )
132 {
133  int h, i;
134  Vec_IntForEachEntryStart( p->vInt2Handle, h, i, 1 )
135  Abc_Print( 1, "%d=\n%s\n", i, Abc_NamHandleToStr(p, h) );
136 // Abc_Print( 1, "\n" );
137 }
138 
139 /**Function*************************************************************
140 
141  Synopsis [References the manager.]
142 
143  Description []
144 
145  SideEffects []
146 
147  SeeAlso []
148 
149 ***********************************************************************/
150 Abc_Nam_t * Abc_NamRef( Abc_Nam_t * p )
151 {
152  p->nRefs++;
153  return p;
154 }
155 
156 /**Function*************************************************************
157 
158  Synopsis [Dereferences the manager.]
159 
160  Description []
161 
162  SideEffects []
163 
164  SeeAlso []
165 
166 ***********************************************************************/
167 void Abc_NamDeref( Abc_Nam_t * p )
168 {
169  if ( p == NULL )
170  return;
171  if ( --p->nRefs == 0 )
172  Abc_NamStop( p );
173 }
174 
175 /**Function*************************************************************
176 
177  Synopsis [Returns the number of used entries.]
178 
179  Description []
180 
181  SideEffects []
182 
183  SeeAlso []
184 
185 ***********************************************************************/
186 int Abc_NamObjNumMax( Abc_Nam_t * p )
187 {
188  return Vec_IntSize(p->vInt2Handle);
189 }
190 
191 /**Function*************************************************************
192 
193  Synopsis [Reports memory usage of the manager.]
194 
195  Description []
196 
197  SideEffects []
198 
199  SeeAlso []
200 
201 ***********************************************************************/
202 int Abc_NamMemUsed( Abc_Nam_t * p )
203 {
204  if ( p == NULL )
205  return 0;
206  return sizeof(Abc_Nam_t) + p->iHandle + sizeof(int) * p->nBins +
207  sizeof(int) * (p->vInt2Handle->nSize + p->vInt2Next->nSize);
208 }
209 
210 /**Function*************************************************************
211 
212  Synopsis [Reports memory usage of the manager.]
213 
214  Description []
215 
216  SideEffects []
217 
218  SeeAlso []
219 
220 ***********************************************************************/
221 int Abc_NamMemAlloc( Abc_Nam_t * p )
222 {
223  if ( p == NULL )
224  return 0;
225  return sizeof(Abc_Nam_t) + p->nStore + sizeof(int) * p->nBins +
226  sizeof(int) * (p->vInt2Handle->nCap + p->vInt2Next->nCap);
227 }
228 
229 /**Function*************************************************************
230 
231  Synopsis [Computes hash value of the C-string.]
232 
233  Description []
234 
235  SideEffects []
236 
237  SeeAlso []
238 
239 ***********************************************************************/
240 int Abc_NamStrHash( const char * pStr, const char * pLim, int nTableSize )
241 {
242  static int s_FPrimes[128] = {
243  1009, 1049, 1093, 1151, 1201, 1249, 1297, 1361, 1427, 1459,
244  1499, 1559, 1607, 1657, 1709, 1759, 1823, 1877, 1933, 1997,
245  2039, 2089, 2141, 2213, 2269, 2311, 2371, 2411, 2467, 2543,
246  2609, 2663, 2699, 2741, 2797, 2851, 2909, 2969, 3037, 3089,
247  3169, 3221, 3299, 3331, 3389, 3461, 3517, 3557, 3613, 3671,
248  3719, 3779, 3847, 3907, 3943, 4013, 4073, 4129, 4201, 4243,
249  4289, 4363, 4441, 4493, 4549, 4621, 4663, 4729, 4793, 4871,
250  4933, 4973, 5021, 5087, 5153, 5227, 5281, 5351, 5417, 5471,
251  5519, 5573, 5651, 5693, 5749, 5821, 5861, 5923, 6011, 6073,
252  6131, 6199, 6257, 6301, 6353, 6397, 6481, 6563, 6619, 6689,
253  6737, 6803, 6863, 6917, 6977, 7027, 7109, 7187, 7237, 7309,
254  7393, 7477, 7523, 7561, 7607, 7681, 7727, 7817, 7877, 7933,
255  8011, 8039, 8059, 8081, 8093, 8111, 8123, 8147
256  };
257  unsigned i, uHash;
258  if ( pLim )
259  {
260  for ( uHash = 0, i = 0; pStr+i < pLim; i++ )
261  if ( i & 1 )
262  uHash *= pStr[i] * s_FPrimes[i & 0x7F];
263  else
264  uHash ^= pStr[i] * s_FPrimes[i & 0x7F];
265  }
266  else
267  {
268  for ( uHash = 0, i = 0; pStr[i]; i++ )
269  if ( i & 1 )
270  uHash *= pStr[i] * s_FPrimes[i & 0x7F];
271  else
272  uHash ^= pStr[i] * s_FPrimes[i & 0x7F];
273  }
274  return uHash % nTableSize;
275 }
276 
277 /**Function*************************************************************
278 
279  Synopsis [Returns place where this string is, or should be.]
280 
281  Description []
282 
283  SideEffects []
284 
285  SeeAlso []
286 
287 ***********************************************************************/
288 static inline int Abc_NamStrcmp( char * pStr, char * pLim, char * pThis )
289 {
290  if ( pLim )
291  {
292  while ( pStr < pLim )
293  if ( *pStr++ != *pThis++ )
294  return 1;
295  return *pThis != '\0';
296  }
297  else
298  {
299  while ( *pStr )
300  if ( *pStr++ != *pThis++ )
301  return 1;
302  return *pThis != '\0';
303  }
304 }
305 static inline int * Abc_NamStrHashFind( Abc_Nam_t * p, const char * pStr, const char * pLim )
306 {
307  char * pThis;
308  int * pPlace = (int *)(p->pBins + Abc_NamStrHash( pStr, pLim, p->nBins ));
309  assert( *pStr );
310  for ( pThis = (*pPlace)? Abc_NamIntToStr(p, *pPlace) : NULL;
311  pThis; pPlace = Abc_NamIntToNextP(p, *pPlace),
312  pThis = (*pPlace)? Abc_NamIntToStr(p, *pPlace) : NULL )
313  if ( !Abc_NamStrcmp( (char *)pStr, (char *)pLim, pThis ) )
314  break;
315  return pPlace;
316 }
317 
318 /**Function*************************************************************
319 
320  Synopsis [Resizes the hash table.]
321 
322  Description []
323 
324  SideEffects []
325 
326  SeeAlso []
327 
328 ***********************************************************************/
329 void Abc_NamStrHashResize( Abc_Nam_t * p )
330 {
331  Vec_Int_t * vInt2HandleOld;
332  char * pThis;
333  int * piPlace, * pBinsOld, iHandleOld, i;//, clk = Abc_Clock();
334  assert( p->pBins != NULL );
335 // Abc_Print( 1, "Resizing names manager hash table from %6d to %6d. ", p->nBins, Abc_PrimeCudd( 3 * p->nBins ) );
336  // replace the table
337  pBinsOld = p->pBins;
338  p->nBins = Abc_PrimeCudd( 3 * p->nBins );
339  p->pBins = ABC_CALLOC( int, p->nBins );
340  // replace the handles array
341  vInt2HandleOld = p->vInt2Handle;
342  p->vInt2Handle = Vec_IntAlloc( 2 * Vec_IntSize(vInt2HandleOld) );
343  Vec_IntPush( p->vInt2Handle, -1 );
344  Vec_IntClear( p->vInt2Next ); Vec_IntPush( p->vInt2Next, -1 );
345  // rehash the entries from the old table
346  Vec_IntForEachEntryStart( vInt2HandleOld, iHandleOld, i, 1 )
347  {
348  pThis = Abc_NamHandleToStr( p, iHandleOld );
349  piPlace = Abc_NamStrHashFind( p, pThis, NULL );
350  assert( *piPlace == 0 );
351  *piPlace = Vec_IntSize( p->vInt2Handle );
352  assert( Vec_IntSize( p->vInt2Handle ) == i );
353  Vec_IntPush( p->vInt2Handle, iHandleOld );
354  Vec_IntPush( p->vInt2Next, 0 );
355  }
356  Vec_IntFree( vInt2HandleOld );
357  ABC_FREE( pBinsOld );
358 // Abc_PrintTime( 1, "Time", Abc_Clock() - clk );
359 }
360 
361 /**Function*************************************************************
362 
363  Synopsis [Returns the index of the string in the table.]
364 
365  Description []
366 
367  SideEffects []
368 
369  SeeAlso []
370 
371 ***********************************************************************/
372 int Abc_NamStrFind( Abc_Nam_t * p, char * pStr )
373 {
374  return *Abc_NamStrHashFind( p, pStr, NULL );
375 }
376 int Abc_NamStrFindLim( Abc_Nam_t * p, char * pStr, char * pLim )
377 {
378  return *Abc_NamStrHashFind( p, pStr, pLim );
379 }
380 
381 /**Function*************************************************************
382 
383  Synopsis [Finds or adds the given name to storage.]
384 
385  Description []
386 
387  SideEffects []
388 
389  SeeAlso []
390 
391 ***********************************************************************/
392 int Abc_NamStrFindOrAdd( Abc_Nam_t * p, char * pStr, int * pfFound )
393 {
394  int i, iHandleNew;
395  int *piPlace;
396  if ( !(pStr[0] != '\\' || pStr[strlen(pStr)-1] == ' ') )
397  {
398  for ( i = strlen(pStr) - 1; i >= 0; i-- )
399  if ( *pStr == ' ' )
400  break;
401  assert( i < (int)strlen(pStr) );
402  }
403  piPlace = Abc_NamStrHashFind( p, pStr, NULL );
404  if ( *piPlace )
405  {
406  if ( pfFound )
407  *pfFound = 1;
408  return *piPlace;
409  }
410  if ( pfFound )
411  *pfFound = 0;
412  iHandleNew = p->iHandle + strlen(pStr) + 1;
413  while ( p->nStore < iHandleNew )
414  {
415  p->nStore *= 3;
416  p->nStore /= 2;
417  p->pStore = ABC_REALLOC( char, p->pStore, p->nStore );
418  }
419  assert( p->nStore >= iHandleNew );
420  // create new handle
421  *piPlace = Vec_IntSize( p->vInt2Handle );
422  strcpy( Abc_NamHandleToStr( p, p->iHandle ), pStr );
423  Vec_IntPush( p->vInt2Handle, p->iHandle );
424  Vec_IntPush( p->vInt2Next, 0 );
425  p->iHandle = iHandleNew;
426  // extend the hash table
427  if ( Vec_IntSize(p->vInt2Handle) > 2 * p->nBins )
428  Abc_NamStrHashResize( p );
429  return Vec_IntSize(p->vInt2Handle) - 1;
430 }
431 int Abc_NamStrFindOrAddLim( Abc_Nam_t * p, char * pStr, char * pLim, int * pfFound )
432 {
433  int iHandleNew;
434  int *piPlace;
435  char * pStore;
436  assert( pStr < pLim );
437  piPlace = Abc_NamStrHashFind( p, pStr, pLim );
438  if ( *piPlace )
439  {
440  if ( pfFound )
441  *pfFound = 1;
442  return *piPlace;
443  }
444  if ( pfFound )
445  *pfFound = 0;
446  iHandleNew = p->iHandle + (pLim - pStr) + 1;
447  while ( p->nStore < iHandleNew )
448  {
449  p->nStore *= 3;
450  p->nStore /= 2;
451  p->pStore = ABC_REALLOC( char, p->pStore, p->nStore );
452  }
453  assert( p->nStore >= iHandleNew );
454  // create new handle
455  *piPlace = Vec_IntSize( p->vInt2Handle );
456  pStore = Abc_NamHandleToStr( p, p->iHandle );
457  strncpy( pStore, pStr, pLim - pStr );
458  pStore[pLim - pStr] = 0;
459  Vec_IntPush( p->vInt2Handle, p->iHandle );
460  Vec_IntPush( p->vInt2Next, 0 );
461  p->iHandle = iHandleNew;
462  // extend the hash table
463  if ( Vec_IntSize(p->vInt2Handle) > 2 * p->nBins )
464  Abc_NamStrHashResize( p );
465  return Vec_IntSize(p->vInt2Handle) - 1;
466 }
467 
468 /**Function*************************************************************
469 
470  Synopsis [Returns name from name ID.]
471 
472  Description []
473 
474  SideEffects []
475 
476  SeeAlso []
477 
478 ***********************************************************************/
479 char * Abc_NamStr( Abc_Nam_t * p, int NameId )
480 {
481  return NameId? Abc_NamIntToStr(p, NameId) : NULL;
482 }
483 
484 /**Function*************************************************************
485 
486  Synopsis [For each ID of the first manager, gives ID of the second one.]
487 
488  Description []
489 
490  SideEffects []
491 
492  SeeAlso []
493 
494 ***********************************************************************/
495 Vec_Int_t * Abc_NamComputeIdMap( Abc_Nam_t * p1, Abc_Nam_t * p2 )
496 {
497  Vec_Int_t * vMap;
498  char * pThis;
499  int * piPlace, iHandle1, i;
500  if ( p1 == p2 )
501  return Vec_IntStartNatural( Abc_NamObjNumMax(p1) );
502  vMap = Vec_IntStart( Abc_NamObjNumMax(p1) );
503  Vec_IntForEachEntryStart( p1->vInt2Handle, iHandle1, i, 1 )
504  {
505  pThis = Abc_NamHandleToStr( p1, iHandle1 );
506  piPlace = Abc_NamStrHashFind( p2, pThis, NULL );
507  Vec_IntWriteEntry( vMap, i, *piPlace );
508 // Abc_Print( 1, "%d->%d ", i, *piPlace );
509  }
510  return vMap;
511 }
512 
513 /**Function*************************************************************
514 
515  Synopsis [Returns the number of common names in the array.]
516 
517  Description [The array contains name IDs in the first manager.
518  The procedure returns the number of entries that correspond to names
519  in the first manager that appear in the second manager.]
520 
521  SideEffects []
522 
523  SeeAlso []
524 
525 ***********************************************************************/
526 int Abc_NamReportCommon( Vec_Int_t * vNameIds1, Abc_Nam_t * p1, Abc_Nam_t * p2 )
527 {
528  int i, Entry, Counter = 0;
529  Vec_IntForEachEntry( vNameIds1, Entry, i )
530  {
531  assert( Entry > 0 && Entry < Abc_NamObjNumMax(p1) );
532  Counter += (Abc_NamStrFind(p2, Abc_NamStr(p1, Entry)) > 0);
533 // if ( Abc_NamStrFind(p2, Abc_NamStr(p1, Entry)) == 0 )
534 // Abc_Print( 1, "unique name <%s>\n", Abc_NamStr(p1, Entry) );
535  }
536  return Counter;
537 }
538 
539 /**Function*************************************************************
540 
541  Synopsis [Returns the name that appears in p1 does not appear in p2.]
542 
543  Description []
544 
545  SideEffects []
546 
547  SeeAlso []
548 
549 ***********************************************************************/
550 char * Abc_NamReportUnique( Vec_Int_t * vNameIds1, Abc_Nam_t * p1, Abc_Nam_t * p2 )
551 {
552  int i, Entry;
553  Vec_IntForEachEntry( vNameIds1, Entry, i )
554  {
555  assert( Entry > 0 && Entry < Abc_NamObjNumMax(p1) );
556  if ( Abc_NamStrFind(p2, Abc_NamStr(p1, Entry)) == 0 )
557  return Abc_NamStr(p1, Entry);
558  }
559  return NULL;
560 }
561 
562 ////////////////////////////////////////////////////////////////////////
563 /// END OF FILE ///
564 ////////////////////////////////////////////////////////////////////////
565 
566 
567 ABC_NAMESPACE_IMPL_END
568 
memset
char * memset()
Abc_NamStrHashResize
void Abc_NamStrHashResize(Abc_Nam_t *p)
Definition: utilNam.c:329
Abc_PrimeCudd
static int Abc_PrimeCudd(unsigned int p)
Definition: abc_global.h:383
Abc_NamStop
void Abc_NamStop(Abc_Nam_t *p)
Definition: utilNam.c:110
Abc_NamStrHashFind
static int * Abc_NamStrHashFind(Abc_Nam_t *p, const char *pStr, const char *pLim)
Definition: utilNam.c:305
p
static Llb_Mgr_t * p
Definition: llb3Image.c:950
Vec_Int_t
typedefABC_NAMESPACE_IMPL_START struct Vec_Int_t_ Vec_Int_t
DECLARATIONS ///.
Definition: bblif.c:37
ABC_REALLOC
#define ABC_REALLOC(type, obj, num)
Definition: abc_global.h:233
strncpy
char * strncpy()
Abc_NamRef
Abc_Nam_t * Abc_NamRef(Abc_Nam_t *p)
Definition: utilNam.c:150
Abc_NamObjNumMax
int Abc_NamObjNumMax(Abc_Nam_t *p)
Definition: utilNam.c:186
Abc_NamIntToStr
static char * Abc_NamIntToStr(Abc_Nam_t *p, int i)
Definition: utilNam.c:59
Abc_Nam_t_::iHandle
int iHandle
Definition: utilNam.c:45
Abc_NamPrint
void Abc_NamPrint(Abc_Nam_t *p)
Definition: utilNam.c:131
Abc_Nam_t_::pStore
char * pStore
Definition: utilNam.c:46
ABC_ALLOC
#define ABC_ALLOC(type, num)
Definition: abc_global.h:229
Abc_Nam_t_::nBins
int nBins
Definition: utilNam.c:52
Abc_NamStrFindOrAdd
int Abc_NamStrFindOrAdd(Abc_Nam_t *p, char *pStr, int *pfFound)
Definition: utilNam.c:392
Vec_IntStartNatural
static Vec_Int_t * Vec_IntStartNatural(int nSize)
Definition: bblif.c:192
Abc_NamIntToHandle
static int Abc_NamIntToHandle(Abc_Nam_t *p, int i)
Definition: utilNam.c:58
Abc_NamStart
Abc_Nam_t * Abc_NamStart(int nObjs, int nAveSize)
FUNCTION DEFINITIONS ///.
Definition: utilNam.c:78
Abc_Nam_t_::vInt2Handle
Vec_Int_t * vInt2Handle
Definition: utilNam.c:48
Abc_NamStrFindOrAddLim
int Abc_NamStrFindOrAddLim(Abc_Nam_t *p, char *pStr, char *pLim, int *pfFound)
Definition: utilNam.c:431
Vec_IntWriteEntry
static void Vec_IntWriteEntry(Vec_Int_t *p, int i, int Entry)
Definition: bblif.c:285
Vec_IntStart
static Vec_Int_t * Vec_IntStart(int nSize)
Definition: bblif.c:172
Abc_NamIntToNext
static int Abc_NamIntToNext(Abc_Nam_t *p, int i)
Definition: utilNam.c:60
Abc_NamStrHash
int Abc_NamStrHash(const char *pStr, const char *pLim, int nTableSize)
Definition: utilNam.c:240
Vec_IntAlloc
static Vec_Int_t * Vec_IntAlloc(int nCap)
FUNCTION DEFINITIONS ///.
Definition: bblif.c:149
Abc_NamMemUsed
int Abc_NamMemUsed(Abc_Nam_t *p)
Definition: utilNam.c:202
Abc_NamComputeIdMap
Vec_Int_t * Abc_NamComputeIdMap(Abc_Nam_t *p1, Abc_Nam_t *p2)
Definition: utilNam.c:495
Vec_IntEntry
static int Vec_IntEntry(Vec_Int_t *p, int i)
Definition: bblif.c:268
Abc_Nam_t_::nStore
int nStore
Definition: utilNam.c:44
ABC_NAMESPACE_IMPL_END
#define ABC_NAMESPACE_IMPL_END
Definition: abc_global.h:108
Vec_IntPush
static void Vec_IntPush(Vec_Int_t *p, int Entry)
Definition: bblif.c:468
Abc_NamMemAlloc
int Abc_NamMemAlloc(Abc_Nam_t *p)
Definition: utilNam.c:221
Counter
static int Counter
Definition: extraBddMisc.c:1877
Abc_Nam_t_
DECLARATIONS ///.
Definition: utilNam.c:41
Vec_IntForEachEntryStart
#define Vec_IntForEachEntryStart(vVec, Entry, i, Start)
Definition: vecInt.h:56
Abc_Print
static void Abc_Print(int level, const char *format,...)
Definition: abc_global.h:313
Abc_NamStrFind
int Abc_NamStrFind(Abc_Nam_t *p, char *pStr)
Definition: utilNam.c:372
strcpy
char * strcpy()
Abc_NamStr
char * Abc_NamStr(Abc_Nam_t *p, int NameId)
Definition: utilNam.c:479
Abc_NamHandleToStr
static char * Abc_NamHandleToStr(Abc_Nam_t *p, int h)
Definition: utilNam.c:57
ABC_NAMESPACE_IMPL_START
#define ABC_NAMESPACE_IMPL_START
Definition: abc_global.h:107
abc_global.h
Vec_IntSize
static int Vec_IntSize(Vec_Int_t *p)
Definition: bblif.c:252
Abc_NamIntToNextP
static int * Abc_NamIntToNextP(Abc_Nam_t *p, int i)
Definition: utilNam.c:61
Abc_Nam_t_::nRefs
int nRefs
Definition: utilNam.c:54
ABC_FREE
#define ABC_FREE(obj)
Definition: abc_global.h:232
ABC_CALLOC
#define ABC_CALLOC(type, num)
Definition: abc_global.h:230
Abc_Nam_t
typedefABC_NAMESPACE_HEADER_START struct Abc_Nam_t_ Abc_Nam_t
INCLUDES ///.
Definition: utilNam.h:39
assert
#define assert(ex)
Definition: util_old.h:213
Vec_IntEntryP
static int * Vec_IntEntryP(Vec_Int_t *p, int i)
Definition: vecInt.h:417
strlen
int strlen()
Abc_NamStrFindLim
int Abc_NamStrFindLim(Abc_Nam_t *p, char *pStr, char *pLim)
Definition: utilNam.c:376
Abc_NamReportCommon
int Abc_NamReportCommon(Vec_Int_t *vNameIds1, Abc_Nam_t *p1, Abc_Nam_t *p2)
Definition: utilNam.c:526
Vec_IntFree
static void Vec_IntFree(Vec_Int_t *p)
Definition: bblif.c:235
Vec_IntClear
static void Vec_IntClear(Vec_Int_t *p)
Definition: bblif.c:452
Abc_NamDeref
void Abc_NamDeref(Abc_Nam_t *p)
Definition: utilNam.c:167
Abc_Nam_t_::vInt2Next
Vec_Int_t * vInt2Next
Definition: utilNam.c:49
Vec_IntForEachEntry
#define Vec_IntForEachEntry(vVec, Entry, i)
MACRO DEFINITIONS ///.
Definition: vecInt.h:54
Abc_Nam_t_::pBins
int * pBins
Definition: utilNam.c:51
Abc_NamReportUnique
char * Abc_NamReportUnique(Vec_Int_t *vNameIds1, Abc_Nam_t *p1, Abc_Nam_t *p2)
Definition: utilNam.c:550
Abc_NamStrcmp
static int Abc_NamStrcmp(char *pStr, char *pLim, char *pThis)
Definition: utilNam.c:288