abc-master
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
abc_global.h
Go to the documentation of this file.
1 /**CFile****************************************************************
2 
3  FileName [abc_global.h]
4 
5  SystemName [ABC: Logic synthesis and verification system.]
6 
7  PackageName [Global declarations.]
8 
9  Synopsis [Global declarations.]
10 
11  Author [Alan Mishchenko]
12 
13  Affiliation [UC Berkeley]
14 
15  Date [Ver. 1.0. Started - Jan 30, 2009.]
16 
17  Revision [$Id: abc_global.h,v 1.00 2009/01/30 00:00:00 alanmi Exp $]
18 
19 ***********************************************************************/
20 
21 #ifndef ABC__misc__util__abc_global_h
22 #define ABC__misc__util__abc_global_h
23 
24 ////////////////////////////////////////////////////////////////////////
25 /// INCLUDES ///
26 ////////////////////////////////////////////////////////////////////////
27 
28 #ifdef _WIN32
29 #ifndef __MINGW32__
30 #define inline __inline // compatible with MS VS 6.0
31 #pragma warning(disable : 4152) // warning C4152: nonstandard extension, function/data pointer conversion in expression
32 #pragma warning(disable : 4200) // warning C4200: nonstandard extension used : zero-sized array in struct/union
33 #pragma warning(disable : 4244) // warning C4244: '+=' : conversion from 'int ' to 'unsigned short ', possible loss of data
34 #pragma warning(disable : 4514) // warning C4514: 'Vec_StrPop' : unreferenced inline function has been removed
35 #pragma warning(disable : 4710) // warning C4710: function 'Vec_PtrGrow' not inlined
36 //#pragma warning( disable : 4273 )
37 #endif
38 #endif
39 
40 #ifdef WIN32
41  #ifdef WIN32_NO_DLL
42  #define ABC_DLLEXPORT
43  #define ABC_DLLIMPORT
44  #else
45  #define ABC_DLLEXPORT __declspec(dllexport)
46  #define ABC_DLLIMPORT __declspec(dllimport)
47  #endif
48 #else /* defined(WIN32) */
49 #define ABC_DLLIMPORT
50 #endif /* defined(WIN32) */
51 
52 #ifndef ABC_DLL
53 #define ABC_DLL ABC_DLLIMPORT
54 #endif
55 
56 // catch memory leaks in Visual Studio
57 #ifdef WIN32
58  #ifdef _DEBUG
59  #define _CRTDBG_MAP_ALLOC
60  #include <crtdbg.h>
61  #endif
62 #endif
63 
64 #if !defined(___unused)
65 #if defined(__GNUC__)
66 #define ___unused __attribute__ ((__unused__))
67 #else
68 #define ___unused
69 #endif
70 #endif
71 
72 /*
73 #ifdef __cplusplus
74 #error "C++ code"
75 #else
76 #error "C code"
77 #endif
78 */
79 
80 #include <time.h>
81 #include <stdarg.h>
82 #include <stdlib.h>
83 
84 ////////////////////////////////////////////////////////////////////////
85 /// NAMESPACES ///
86 ////////////////////////////////////////////////////////////////////////
87 
88 //#define ABC_NAMESPACE xxx
89 
90 #ifdef __cplusplus
91 # ifdef ABC_NAMESPACE
92 # define ABC_NAMESPACE_HEADER_START namespace ABC_NAMESPACE {
93 # define ABC_NAMESPACE_HEADER_END }
94 # define ABC_NAMESPACE_IMPL_START namespace ABC_NAMESPACE {
95 # define ABC_NAMESPACE_IMPL_END }
96 # define ABC_NAMESPACE_PREFIX ABC_NAMESPACE::
97 # else
98 # define ABC_NAMESPACE_HEADER_START extern "C" {
99 # define ABC_NAMESPACE_HEADER_END }
100 # define ABC_NAMESPACE_IMPL_START
101 # define ABC_NAMESPACE_IMPL_END
102 # define ABC_NAMESPACE_PREFIX
103 # endif // #ifdef ABC_NAMESPACE
104 #else
105 # define ABC_NAMESPACE_HEADER_START
106 # define ABC_NAMESPACE_HEADER_END
107 # define ABC_NAMESPACE_IMPL_START
108 # define ABC_NAMESPACE_IMPL_END
109 # define ABC_NAMESPACE_PREFIX
110 #endif // #ifdef __cplusplus
111 
112 ////////////////////////////////////////////////////////////////////////
113 /// PARAMETERS ///
114 ////////////////////////////////////////////////////////////////////////
115 
116 ABC_NAMESPACE_HEADER_START
117 
118 ////////////////////////////////////////////////////////////////////////
119 /// BASIC TYPES ///
120 ////////////////////////////////////////////////////////////////////////
121 
122 /**
123  * Pointer difference type; replacement for ptrdiff_t.
124  * This is a signed integral type that is the same size as a pointer.
125  * NOTE: This type may be different sizes on different platforms.
126  */
127 #if defined(__ccdoc__)
128 typedef platform_dependent_type ABC_PTRDIFF_T;
129 #elif defined(LIN64)
130 typedef long ABC_PTRDIFF_T;
131 #elif defined(NT64)
132 typedef long long ABC_PTRDIFF_T;
133 #elif defined(NT) || defined(LIN) || defined(WIN32)
134 typedef int ABC_PTRDIFF_T;
135 #else
136  #error unknown platform
137 #endif /* defined(PLATFORM) */
138 
139 /**
140  * Unsigned integral type that can contain a pointer.
141  * This is an unsigned integral type that is the same size as a pointer.
142  * NOTE: This type may be different sizes on different platforms.
143  */
144 #if defined(__ccdoc__)
145 typedef platform_dependent_type ABC_PTRUINT_T;
146 #elif defined(LIN64)
147 typedef unsigned long ABC_PTRUINT_T;
148 #elif defined(NT64)
149 typedef unsigned long long ABC_PTRUINT_T;
150 #elif defined(NT) || defined(LIN) || defined(WIN32)
151 typedef unsigned int ABC_PTRUINT_T;
152 #else
153  #error unknown platform
154 #endif /* defined(PLATFORM) */
155 
156 /**
157  * Signed integral type that can contain a pointer.
158  * This is a signed integral type that is the same size as a pointer.
159  * NOTE: This type may be different sizes on different platforms.
160  */
161 #if defined(__ccdoc__)
162 typedef platform_dependent_type ABC_PTRINT_T;
163 #elif defined(LIN64)
164 typedef long ABC_PTRINT_T;
165 #elif defined(NT64)
166 typedef long long ABC_PTRINT_T;
167 #elif defined(NT) || defined(LIN) || defined(WIN32)
168 typedef int ABC_PTRINT_T;
169 #else
170  #error unknown platform
171 #endif /* defined(PLATFORM) */
172 
173 /**
174  * 64-bit signed integral type.
175  */
176 #if defined(__ccdoc__)
177 typedef platform_dependent_type ABC_INT64_T;
178 #elif defined(LIN64)
179 typedef long ABC_INT64_T;
180 #elif defined(NT64) || defined(LIN)
181 typedef long long ABC_INT64_T;
182 #elif defined(WIN32) || defined(NT)
183 typedef signed __int64 ABC_INT64_T;
184 #else
185  #error unknown platform
186 #endif /* defined(PLATFORM) */
187 
188 /**
189  * 64-bit unsigned integral type.
190  */
191 #if defined(__ccdoc__)
192 typedef platform_dependent_type ABC_UINT64_T;
193 #elif defined(LIN64)
194 typedef unsigned long ABC_UINT64_T;
195 #elif defined(NT64) || defined(LIN)
196 typedef unsigned long long ABC_UINT64_T;
197 #elif defined(WIN32) || defined(NT)
198 typedef unsigned __int64 ABC_UINT64_T;
199 #else
200  #error unknown platform
201 #endif /* defined(PLATFORM) */
202 
203 #ifdef LIN
204  #define ABC_CONST(number) number ## ULL
205 #else // LIN64 and windows
206  #define ABC_CONST(number) number
207 #endif
208 
209 typedef ABC_UINT64_T word;
210 typedef ABC_INT64_T iword;
211 
212 ////////////////////////////////////////////////////////////////////////
213 /// MACRO DEFINITIONS ///
214 ////////////////////////////////////////////////////////////////////////
215 
216 #define ABC_INFINITY (100000000)
217 
218 #define ABC_SWAP(Type, a, b) { Type t = a; a = b; b = t; }
219 
220 #define ABC_PRT(a,t) (Abc_Print(1, "%s =", (a)), Abc_Print(1, "%9.2f sec\n", 1.0*(t)/(CLOCKS_PER_SEC)))
221 #define ABC_PRTr(a,t) (Abc_Print(1, "%s =", (a)), Abc_Print(1, "%9.2f sec\r", 1.0*(t)/(CLOCKS_PER_SEC)))
222 #define ABC_PRTn(a,t) (Abc_Print(1, "%s =", (a)), Abc_Print(1, "%9.2f sec ", 1.0*(t)/(CLOCKS_PER_SEC)))
223 #define ABC_PRTP(a,t,T) (Abc_Print(1, "%s =", (a)), Abc_Print(1, "%9.2f sec (%6.2f %%)\n", 1.0*(t)/(CLOCKS_PER_SEC), (T)? 100.0*(t)/(T) : 0.0))
224 #define ABC_PRM(a,f) (Abc_Print(1, "%s =", (a)), Abc_Print(1, "%10.3f MB\n", 1.0*(f)/(1<<20)))
225 #define ABC_PRMr(a,f) (Abc_Print(1, "%s =", (a)), Abc_Print(1, "%10.3f MB\r", 1.0*(f)/(1<<20)))
226 #define ABC_PRMn(a,f) (Abc_Print(1, "%s =", (a)), Abc_Print(1, "%10.3f MB ", 1.0*(f)/(1<<20)))
227 #define ABC_PRMP(a,f,F) (Abc_Print(1, "%s =", (a)), Abc_Print(1, "%10.3f MB (%6.2f %%)\n", (1.0*(f)/(1<<20)), ((F)? 100.0*(f)/(F) : 0.0) ) )
228 
229 #define ABC_ALLOC(type, num) ((type *) malloc(sizeof(type) * (num)))
230 #define ABC_CALLOC(type, num) ((type *) calloc((num), sizeof(type)))
231 #define ABC_FALLOC(type, num) ((type *) memset(malloc(sizeof(type) * (num)), 0xff, sizeof(type) * (num)))
232 #define ABC_FREE(obj) ((obj) ? (free((char *) (obj)), (obj) = 0) : 0)
233 #define ABC_REALLOC(type, obj, num) \
234  ((obj) ? ((type *) realloc((char *)(obj), sizeof(type) * (num))) : \
235  ((type *) malloc(sizeof(type) * (num))))
236 
237 static inline int Abc_AbsInt( int a ) { return a < 0 ? -a : a; }
238 static inline int Abc_MaxInt( int a, int b ) { return a > b ? a : b; }
239 static inline int Abc_MinInt( int a, int b ) { return a < b ? a : b; }
240 static inline word Abc_MaxWord( word a, word b ) { return a > b ? a : b; }
241 static inline word Abc_MinWord( word a, word b ) { return a < b ? a : b; }
242 static inline float Abc_AbsFloat( float a ) { return a < 0 ? -a : a; }
243 static inline float Abc_MaxFloat( float a, float b ) { return a > b ? a : b; }
244 static inline float Abc_MinFloat( float a, float b ) { return a < b ? a : b; }
245 static inline double Abc_AbsDouble( double a ) { return a < 0 ? -a : a; }
246 static inline double Abc_MaxDouble( double a, double b ) { return a > b ? a : b; }
247 static inline double Abc_MinDouble( double a, double b ) { return a < b ? a : b; }
248 
249 static inline int Abc_Float2Int( float Val ) { union { int x; float y; } v; v.y = Val; return v.x; }
250 static inline float Abc_Int2Float( int Num ) { union { int x; float y; } v; v.x = Num; return v.y; }
251 static inline int Abc_Base2Log( unsigned n ) { int r; if ( n < 2 ) return n; for ( r = 0, n--; n; n >>= 1, r++ ) {}; return r; }
252 static inline int Abc_Base10Log( unsigned n ) { int r; if ( n < 2 ) return n; for ( r = 0, n--; n; n /= 10, r++ ) {}; return r; }
253 static inline int Abc_Base16Log( unsigned n ) { int r; if ( n < 2 ) return n; for ( r = 0, n--; n; n /= 16, r++ ) {}; return r; }
254 static inline char * Abc_UtilStrsav( char * s ) { return s ? strcpy(ABC_ALLOC(char, strlen(s)+1), s) : NULL; }
255 static inline int Abc_BitWordNum( int nBits ) { return (nBits>>5) + ((nBits&31) > 0); }
256 static inline int Abc_TruthWordNum( int nVars ) { return nVars <= 5 ? 1 : (1 << (nVars - 5)); }
257 static inline int Abc_Truth6WordNum( int nVars ) { return nVars <= 6 ? 1 : (1 << (nVars - 6)); }
258 static inline int Abc_InfoHasBit( unsigned * p, int i ) { return (p[(i)>>5] & (1<<((i) & 31))) > 0; }
259 static inline void Abc_InfoSetBit( unsigned * p, int i ) { p[(i)>>5] |= (1<<((i) & 31)); }
260 static inline void Abc_InfoXorBit( unsigned * p, int i ) { p[(i)>>5] ^= (1<<((i) & 31)); }
261 static inline unsigned Abc_InfoMask( int nVar ) { return (~(unsigned)0) >> (32-nVar); }
262 
263 static inline int Abc_Var2Lit( int Var, int fCompl ) { return Var + Var + fCompl; }
264 static inline int Abc_Lit2Var( int Lit ) { return Lit >> 1; }
265 static inline int Abc_LitIsCompl( int Lit ) { return Lit & 1; }
266 static inline int Abc_LitNot( int Lit ) { return Lit ^ 1; }
267 static inline int Abc_LitNotCond( int Lit, int c ) { return Lit ^ (int)(c > 0); }
268 static inline int Abc_LitRegular( int Lit ) { return Lit & ~01; }
269 static inline int Abc_Lit2LitV( int * pMap, int Lit ) { return Abc_Var2Lit( pMap[Abc_Lit2Var(Lit)], Abc_LitIsCompl(Lit) ); }
270 static inline int Abc_Lit2LitL( int * pMap, int Lit ) { return Abc_LitNotCond( pMap[Abc_Lit2Var(Lit)], Abc_LitIsCompl(Lit) ); }
271 
272 static inline int Abc_Ptr2Int( void * p ) { return (int)(ABC_PTRINT_T)p; }
273 static inline void * Abc_Int2Ptr( int i ) { return (void *)(ABC_PTRINT_T)i; }
274 static inline word Abc_Ptr2Wrd( void * p ) { return (word)(ABC_PTRUINT_T)p; }
275 static inline void * Abc_Wrd2Ptr( word i ) { return (void *)(ABC_PTRUINT_T)i; }
276 
277 // time counting
278 typedef ABC_INT64_T abctime;
279 static inline abctime Abc_Clock()
280 {
281 #if (defined(LIN) || defined(LIN64)) && !(__APPLE__ & __MACH__) && !defined(__MINGW32__)
282  struct timespec ts;
283  if ( clock_gettime(CLOCK_THREAD_CPUTIME_ID, &ts) < 0 )
284  return (abctime)-1;
285  abctime res = ((abctime) ts.tv_sec) * CLOCKS_PER_SEC;
286  res += (((abctime) ts.tv_nsec) * CLOCKS_PER_SEC) / 1000000000;
287  return res;
288 #else
289  return (abctime) clock();
290 #endif
291 }
292 
293 // bridge communication
294 #define BRIDGE_NETLIST 106
295 #define BRIDGE_ABS_NETLIST 107
296 extern int Gia_ManToBridgeText( FILE * pFile, int Size, unsigned char * pBuffer );
297 extern int Gia_ManToBridgeAbsNetlist( FILE * pFile, void * p, int pkg_type );
298 
299 // string printing
300 extern char * vnsprintf(const char* format, va_list args);
301 extern char * nsprintf(const char* format, ...);
302 
303 
304 // misc printing procedures
305 enum Abc_VerbLevel
306 {
307  ABC_PROMPT = -2,
308  ABC_ERROR = -1,
309  ABC_WARNING = 0,
310  ABC_STANDARD = 1,
311  ABC_VERBOSE = 2
312 };
313 static inline void Abc_Print( int level, const char * format, ... )
314 {
315  extern ABC_DLL int Abc_FrameIsBridgeMode();
316  va_list args;
317 
318  if ( ! Abc_FrameIsBridgeMode() ){
319  if ( level == ABC_ERROR )
320  printf( "Error: " );
321  else if ( level == ABC_WARNING )
322  printf( "Warning: " );
323  }else{
324  if ( level == ABC_ERROR )
325  Gia_ManToBridgeText( stdout, strlen("Error: "), (unsigned char*)"Error: " );
326  else if ( level == ABC_WARNING )
327  Gia_ManToBridgeText( stdout, strlen("Warning: "), (unsigned char*)"Warning: " );
328  }
329 
330  va_start( args, format );
331  if ( Abc_FrameIsBridgeMode() )
332  {
333  char * tmp = vnsprintf( format, args );
334  Gia_ManToBridgeText( stdout, strlen(tmp), (unsigned char*)tmp );
335  free( tmp );
336  }
337  else
338  vprintf( format, args );
339  va_end( args );
340 }
341 
342 static inline void Abc_PrintInt( int i )
343 {
344  double v3 = (double)i/1000;
345  double v6 = (double)i/1000000;
346 
347  Abc_Print( 1, " " );
348 
349  if ( i > -1000 && i < 1000 )
350  Abc_Print( 1, " %4d", i );
351 
352  else if ( v3 > -9.995 && v3 < 9.995 )
353  Abc_Print( 1, "%4.2fk", v3 );
354  else if ( v3 > -99.95 && v3 < 99.95 )
355  Abc_Print( 1, "%4.1fk", v3 );
356  else if ( v3 > -999.5 && v3 < 999.5 )
357  Abc_Print( 1, "%4.0fk", v3 );
358 
359  else if ( v6 > -9.995 && v6 < 9.995 )
360  Abc_Print( 1, "%4.2fm", v6 );
361  else if ( v6 > -99.95 && v6 < 99.95 )
362  Abc_Print( 1, "%4.1fm", v6 );
363  else if ( v6 > -999.5 && v6 < 999.5 )
364  Abc_Print( 1, "%4.0fm", v6 );
365 }
366 
367 static inline void Abc_PrintTime( int level, const char * pStr, abctime time )
368 {
369  ABC_PRT( pStr, time );
370 }
371 
372 static inline void Abc_PrintTimeP( int level, const char * pStr, abctime time, abctime Time )
373 {
374  ABC_PRTP( pStr, time, Time );
375 }
376 
377 static inline void Abc_PrintMemoryP( int level, const char * pStr, int mem, int Mem )
378 {
379  ABC_PRMP( pStr, mem, Mem );
380 }
381 
382 // Returns the next prime >= p
383 static inline int Abc_PrimeCudd( unsigned int p )
384 {
385  int i,pn;
386  p--;
387  do {
388  p++;
389  if (p&1)
390  {
391  pn = 1;
392  i = 3;
393  while ((unsigned) (i * i) <= p)
394  {
395  if (p % i == 0) {
396  pn = 0;
397  break;
398  }
399  i += 2;
400  }
401  }
402  else
403  pn = 0;
404  } while (!pn);
405  return(p);
406 
407 } // end of Cudd_Prime
408 
409 
410 // sorting
411 extern void Abc_MergeSort( int * pInput, int nSize );
412 extern int * Abc_MergeSortCost( int * pCosts, int nSize );
413 extern void Abc_QuickSort1( word * pData, int nSize, int fDecrease );
414 extern void Abc_QuickSort2( word * pData, int nSize, int fDecrease );
415 extern void Abc_QuickSort3( word * pData, int nSize, int fDecrease );
416 extern void Abc_QuickSortCostData( int * pCosts, int nSize, int fDecrease, word * pData, int * pResult );
417 extern int * Abc_QuickSortCost( int * pCosts, int nSize, int fDecrease );
418 
419 
420 ABC_NAMESPACE_HEADER_END
421 
422 #endif
423 
424 ////////////////////////////////////////////////////////////////////////
425 /// END OF FILE ///
426 ////////////////////////////////////////////////////////////////////////
word
ABC_UINT64_T word
Definition: abc_global.h:209
Abc_InfoMask
static unsigned Abc_InfoMask(int nVar)
Definition: abc_global.h:261
Abc_QuickSortCost
int * Abc_QuickSortCost(int *pCosts, int nSize, int fDecrease)
Definition: utilSort.c:719
Abc_FrameIsBridgeMode
ABC_DLL int Abc_FrameIsBridgeMode()
Definition: mainFrame.c:94
Abc_PrimeCudd
static int Abc_PrimeCudd(unsigned int p)
Definition: abc_global.h:383
free
VOID_HACK free()
Abc_Lit2LitV
static int Abc_Lit2LitV(int *pMap, int Lit)
Definition: abc_global.h:269
Abc_Ptr2Int
static int Abc_Ptr2Int(void *p)
Definition: abc_global.h:272
Abc_MinFloat
static float Abc_MinFloat(float a, float b)
Definition: abc_global.h:244
Abc_Base16Log
static int Abc_Base16Log(unsigned n)
Definition: abc_global.h:253
Gia_ManToBridgeText
int Gia_ManToBridgeText(FILE *pFile, int Size, unsigned char *pBuffer)
Definition: utilBridge.c:168
Abc_AbsFloat
static float Abc_AbsFloat(float a)
Definition: abc_global.h:242
p
static Llb_Mgr_t * p
Definition: llb3Image.c:950
Abc_MinWord
static word Abc_MinWord(word a, word b)
Definition: abc_global.h:241
Abc_UtilStrsav
static char * Abc_UtilStrsav(char *s)
Definition: abc_global.h:254
Abc_AbsInt
static int Abc_AbsInt(int a)
Definition: abc_global.h:237
Abc_InfoHasBit
static int Abc_InfoHasBit(unsigned *p, int i)
Definition: abc_global.h:258
Abc_Lit2LitL
static int Abc_Lit2LitL(int *pMap, int Lit)
Definition: abc_global.h:270
Abc_Truth6WordNum
static int Abc_Truth6WordNum(int nVars)
Definition: abc_global.h:257
Abc_InfoXorBit
static void Abc_InfoXorBit(unsigned *p, int i)
Definition: abc_global.h:260
Abc_Var2Lit
static int Abc_Var2Lit(int Var, int fCompl)
Definition: abc_global.h:263
Abc_VerbLevel
Abc_VerbLevel
Definition: abc_global.h:305
Abc_QuickSortCostData
void Abc_QuickSortCostData(int *pCosts, int nSize, int fDecrease, word *pData, int *pResult)
Definition: utilSort.c:710
ABC_ALLOC
#define ABC_ALLOC(type, num)
Definition: abc_global.h:229
ABC_STANDARD
Definition: abc_global.h:310
Abc_AbsDouble
static double Abc_AbsDouble(double a)
Definition: abc_global.h:245
Abc_TruthWordNum
static int Abc_TruthWordNum(int nVars)
Definition: abc_global.h:256
Abc_PrintMemoryP
static void Abc_PrintMemoryP(int level, const char *pStr, int mem, int Mem)
Definition: abc_global.h:377
Abc_Clock
static abctime Abc_Clock()
Definition: abc_global.h:279
Abc_MaxInt
static int Abc_MaxInt(int a, int b)
Definition: abc_global.h:238
Abc_PrintTimeP
static void Abc_PrintTimeP(int level, const char *pStr, abctime time, abctime Time)
Definition: abc_global.h:372
Abc_MaxFloat
static float Abc_MaxFloat(float a, float b)
Definition: abc_global.h:243
Abc_LitNotCond
static int Abc_LitNotCond(int Lit, int c)
Definition: abc_global.h:267
ABC_DLL
#define ABC_DLL
Definition: abc_global.h:53
ABC_PRTP
#define ABC_PRTP(a, t, T)
Definition: abc_global.h:223
Abc_MaxDouble
static double Abc_MaxDouble(double a, double b)
Definition: abc_global.h:246
Abc_PrintTime
static void Abc_PrintTime(int level, const char *pStr, abctime time)
Definition: abc_global.h:367
Abc_MergeSortCost
int * Abc_MergeSortCost(int *pCosts, int nSize)
Definition: utilSort.c:238
Abc_MinInt
static int Abc_MinInt(int a, int b)
Definition: abc_global.h:239
Abc_MergeSort
void Abc_MergeSort(int *pInput, int nSize)
Definition: utilSort.c:129
Abc_LitIsCompl
static int Abc_LitIsCompl(int Lit)
Definition: abc_global.h:265
Abc_Float2Int
static int Abc_Float2Int(float Val)
Definition: abc_global.h:249
ABC_ERROR
Definition: abc_global.h:308
vnsprintf
char * vnsprintf(const char *format, va_list args)
Definition: utilFile.c:168
word
unsigned __int64 word
DECLARATIONS ///.
Definition: kitPerm.c:36
Abc_Base10Log
static int Abc_Base10Log(unsigned n)
Definition: abc_global.h:252
Abc_QuickSort1
void Abc_QuickSort1(word *pData, int nSize, int fDecrease)
Definition: utilSort.c:477
ABC_NAMESPACE_HEADER_START
#define ABC_NAMESPACE_HEADER_START
NAMESPACES ///.
Definition: abc_global.h:105
Abc_QuickSort3
void Abc_QuickSort3(word *pData, int nSize, int fDecrease)
Definition: utilSort.c:680
Abc_QuickSort2
void Abc_QuickSort2(word *pData, int nSize, int fDecrease)
Definition: utilSort.c:662
Abc_Print
static void Abc_Print(int level, const char *format,...)
Definition: abc_global.h:313
iword
ABC_INT64_T iword
Definition: abc_global.h:210
ABC_NAMESPACE_HEADER_END
#define ABC_NAMESPACE_HEADER_END
Definition: abc_global.h:106
strcpy
char * strcpy()
ABC_VERBOSE
Definition: abc_global.h:311
Abc_Wrd2Ptr
static void * Abc_Wrd2Ptr(word i)
Definition: abc_global.h:275
Abc_InfoSetBit
static void Abc_InfoSetBit(unsigned *p, int i)
Definition: abc_global.h:259
Abc_LitNot
static int Abc_LitNot(int Lit)
Definition: abc_global.h:266
ABC_PRMP
#define ABC_PRMP(a, f, F)
Definition: abc_global.h:227
ABC_PRT
#define ABC_PRT(a, t)
Definition: abc_global.h:220
Abc_Base2Log
static int Abc_Base2Log(unsigned n)
Definition: abc_global.h:251
ABC_PROMPT
Definition: abc_global.h:307
Gia_ManToBridgeAbsNetlist
int Gia_ManToBridgeAbsNetlist(FILE *pFile, void *p, int pkg_type)
Definition: utilBridge.c:189
Abc_Lit2Var
static int Abc_Lit2Var(int Lit)
Definition: abc_global.h:264
Minisat::Var
int Var
Definition: SolverTypes.h:42
Abc_Int2Float
static float Abc_Int2Float(int Num)
Definition: abc_global.h:250
Abc_MinDouble
static double Abc_MinDouble(double a, double b)
Definition: abc_global.h:247
Abc_BitWordNum
static int Abc_BitWordNum(int nBits)
Definition: abc_global.h:255
Abc_LitRegular
static int Abc_LitRegular(int Lit)
Definition: abc_global.h:268
strlen
int strlen()
Abc_Int2Ptr
static void * Abc_Int2Ptr(int i)
Definition: abc_global.h:273
Abc_Ptr2Wrd
static word Abc_Ptr2Wrd(void *p)
Definition: abc_global.h:274
abctime
ABC_INT64_T abctime
Definition: abc_global.h:278
ABC_WARNING
Definition: abc_global.h:309
Abc_PrintInt
static void Abc_PrintInt(int i)
Definition: abc_global.h:342
nsprintf
char * nsprintf(const char *format,...)
Definition: utilFile.c:205
Abc_MaxWord
static word Abc_MaxWord(word a, word b)
Definition: abc_global.h:240