abc/src/misc/util/abc_global.h - third_party/vtr-verilog-to-routing - Git at Google

 /**CFile****************************************************************

   FileName    [abc_global.h]

   SystemName  [ABC: Logic synthesis and verification system.]

   PackageName [Global declarations.]

   Synopsis    [Global declarations.]

   Author      [Alan Mishchenko]

   Affiliation [UC Berkeley]

   Date        [Ver. 1.0. Started - Jan 30, 2009.]

   Revision    [$Id: abc_global.h,v 1.00 2009/01/30 00:00:00 alanmi Exp $]

 ***********************************************************************/

 #ifndef ABC__misc__util__abc_global_h
 #define ABC__misc__util__abc_global_h

 ////////////////////////////////////////////////////////////////////////
 ///                          INCLUDES                                ///
 ////////////////////////////////////////////////////////////////////////

 #ifdef _WIN32
 #ifndef __MINGW32__
 #define inline __inline // compatible with MS VS 6.0
 #pragma warning(disable : 4152) // warning C4152: nonstandard extension, function/data pointer conversion in expression
 #pragma warning(disable : 4200) // warning C4200: nonstandard extension used : zero-sized array in struct/union
 #pragma warning(disable : 4244) // warning C4244: '+=' : conversion from 'int ' to 'unsigned short ', possible loss of data
 #pragma warning(disable : 4514) // warning C4514: 'Vec_StrPop' : unreferenced inline function has been removed
 #pragma warning(disable : 4710) // warning C4710: function 'Vec_PtrGrow' not inlined
 //#pragma warning( disable : 4273 )
 #endif
 #endif

 #ifdef WIN32
   #ifdef WIN32_NO_DLL
     #define ABC_DLLEXPORT
     #define ABC_DLLIMPORT
   #else
     #define ABC_DLLEXPORT __declspec(dllexport)
     #define ABC_DLLIMPORT __declspec(dllimport)
   #endif
 #else  /* defined(WIN32) */
 #define ABC_DLLIMPORT
 #endif /* defined(WIN32) */

 #ifndef ABC_DLL
 #define ABC_DLL ABC_DLLIMPORT
 #endif

 #if !defined(___unused)
 #if defined(__GNUC__)
 #define ___unused __attribute__ ((__unused__))
 #else
 #define ___unused
 #endif
 #endif

 /*
 #ifdef __cplusplus
 #error "C++ code"
 #else
 #error "C code"
 #endif
 */

 #include <time.h>
 #include <stdarg.h>
 #include <stdlib.h>
 #include <assert.h>
 #include <stdio.h>
 #include <string.h>

 // catch memory leaks in Visual Studio
 #ifdef WIN32
   #ifdef _DEBUG
     #define _CRTDBG_MAP_ALLOC
     #include <crtdbg.h>
   #endif
 #endif

 #include "abc_namespaces.h"

 ////////////////////////////////////////////////////////////////////////
 ///                         PARAMETERS                               ///
 ////////////////////////////////////////////////////////////////////////

 ABC_NAMESPACE_HEADER_START

 ////////////////////////////////////////////////////////////////////////
 ///                         BASIC TYPES                              ///
 ////////////////////////////////////////////////////////////////////////

 #ifdef ABC_USE_STDINT_H
 // If there is stdint.h, assume this is a reasonably-modern platform that
 // would also have stddef.h and limits.h
 #include <limits.h>
 #include <stddef.h>
 #include <stdint.h>

 #if UINTPTR_MAX == 0xFFFFFFFFFFFFFFFF
 #define SIZEOF_VOID_P 8
 #ifdef _WIN32
 #define NT64
 #else
 #define LIN64
 #endif
 #elif UINTPTR_MAX == 0xFFFFFFFF
 #define SIZEOF_VOID_P 4
 #ifdef _WIN32
 #define NT
 #else
 #define LIN
 #endif
 #else
    #error unsupported platform
 #endif

 #if ULONG_MAX == 0xFFFFFFFFFFFFFFFF
 #define SIZEOF_LONG 8
 #elif ULONG_MAX == 0xFFFFFFFF
 #define SIZEOF_LONG 4
 #else
    #error unsupported platform
 #endif

 #if UINT_MAX == 0xFFFFFFFFFFFFFFFF
 #define SIZEOF_INT 8
 #elif UINT_MAX == 0xFFFFFFFF
 #define SIZEOF_INT 4
 #else
    #error unsupported platform
 #endif

 #endif

 /**
  * Pointer difference type; replacement for ptrdiff_t.
  * This is a signed integral type that is the same size as a pointer.
  * NOTE: This type may be different sizes on different platforms.
  */
 #if       defined(__ccdoc__)
 typedef platform_dependent_type ABC_PTRDIFF_T;
 #elif     defined(ABC_USE_STDINT_H)
 typedef ptrdiff_t ABC_PTRDIFF_T;
 #elif     defined(LIN64)
 typedef long ABC_PTRDIFF_T;
 #elif     defined(NT64)
 typedef long long ABC_PTRDIFF_T;
 #elif     defined(NT) || defined(LIN) || defined(WIN32)
 typedef int ABC_PTRDIFF_T;
 #else
    #error unknown platform
 #endif /* defined(PLATFORM) */

 /**
  * Unsigned integral type that can contain a pointer.
  * This is an unsigned integral type that is the same size as a pointer.
  * NOTE: This type may be different sizes on different platforms.
  */
 #if       defined(__ccdoc__)
 typedef platform_dependent_type ABC_PTRUINT_T;
 #elif     defined(ABC_USE_STDINT_H)
 typedef uintptr_t ABC_PTRUINT_T;
 #elif     defined(LIN64)
 typedef unsigned long ABC_PTRUINT_T;
 #elif     defined(NT64)
 typedef unsigned long long ABC_PTRUINT_T;
 #elif     defined(NT) || defined(LIN) || defined(WIN32)
 typedef unsigned int ABC_PTRUINT_T;
 #else
    #error unknown platform
 #endif /* defined(PLATFORM) */

 /**
  * Signed integral type that can contain a pointer.
  * This is a signed integral type that is the same size as a pointer.
  * NOTE: This type may be different sizes on different platforms.
  */
 #if       defined(__ccdoc__)
 typedef platform_dependent_type ABC_PTRINT_T;
 #elif     defined(ABC_USE_STDINT_H)
 typedef intptr_t ABC_PTRINT_T;
 #elif     defined(LIN64)
 typedef long ABC_PTRINT_T;
 #elif     defined(NT64)
 typedef long long ABC_PTRINT_T;
 #elif     defined(NT) || defined(LIN) || defined(WIN32)
 typedef int ABC_PTRINT_T;
 #else
    #error unknown platform
 #endif /* defined(PLATFORM) */

 /**
  * 64-bit signed integral type.
  */
 #if       defined(__ccdoc__)
 typedef platform_dependent_type ABC_INT64_T;
 #elif     defined(ABC_USE_STDINT_H)
 typedef int64_t ABC_INT64_T;
 #elif     defined(LIN64)
 typedef long ABC_INT64_T;
 #elif     defined(NT64) || defined(LIN)
 typedef long long ABC_INT64_T;
 #elif     defined(WIN32) || defined(NT)
 typedef signed __int64 ABC_INT64_T;
 #else
    #error unknown platform
 #endif /* defined(PLATFORM) */

 /**
  * 64-bit unsigned integral type.
  */
 #if       defined(__ccdoc__)
 typedef platform_dependent_type ABC_UINT64_T;
 #elif     defined(ABC_USE_STDINT_H)
 typedef uint64_t ABC_UINT64_T;
 #elif     defined(LIN64)
 typedef unsigned long ABC_UINT64_T;
 #elif     defined(NT64) || defined(LIN)
 typedef unsigned long long ABC_UINT64_T;
 #elif     defined(WIN32) || defined(NT)
 typedef unsigned __int64 ABC_UINT64_T;
 #else
    #error unknown platform
 #endif /* defined(PLATFORM) */

 #ifdef LIN
   #define ABC_CONST(number) number ## ULL
 #else // LIN64 and windows
   #define ABC_CONST(number) number
 #endif

 typedef ABC_UINT64_T word;
 typedef ABC_INT64_T iword;

 ////////////////////////////////////////////////////////////////////////
 ///                      MACRO DEFINITIONS                           ///
 ////////////////////////////////////////////////////////////////////////

 #define ABC_INFINITY    (1000000000)

 #define ABC_SWAP(Type, a, b)  { Type t = a; a = b; b = t; }

 #define ABC_PRT(a,t)    (Abc_Print(1, "%s =", (a)), Abc_Print(1, "%9.2f sec\n", 1.0*(t)/(CLOCKS_PER_SEC)))
 #define ABC_PRTr(a,t)   (Abc_Print(1, "%s =", (a)), Abc_Print(1, "%9.2f sec\r", 1.0*(t)/(CLOCKS_PER_SEC)))
 #define ABC_PRTn(a,t)   (Abc_Print(1, "%s =", (a)), Abc_Print(1, "%9.2f sec  ", 1.0*(t)/(CLOCKS_PER_SEC)))
 #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))
 #define ABC_PRM(a,f)    (Abc_Print(1, "%s =", (a)), Abc_Print(1, "%10.3f MB\n",    1.0*(f)/(1<<20)))
 #define ABC_PRMr(a,f)   (Abc_Print(1, "%s =", (a)), Abc_Print(1, "%10.3f MB\r",    1.0*(f)/(1<<20)))
 #define ABC_PRMn(a,f)   (Abc_Print(1, "%s =", (a)), Abc_Print(1, "%10.3f MB  ",    1.0*(f)/(1<<20)))
 #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) ) )

 #define ABC_ALLOC(type, num)     ((type *) malloc(sizeof(type) * (num)))
 #define ABC_CALLOC(type, num)    ((type *) calloc((num), sizeof(type)))
 #define ABC_FALLOC(type, num)    ((type *) memset(malloc(sizeof(type) * (num)), 0xff, sizeof(type) * (num)))
 #define ABC_FREE(obj)            ((obj) ? (free((char *) (obj)), (obj) = 0) : 0)
 #define ABC_REALLOC(type, obj, num) \
         ((obj) ? ((type *) realloc((char *)(obj), sizeof(type) * (num))) : \
          ((type *) malloc(sizeof(type) * (num))))

 static inline int      Abc_AbsInt( int a        )             { return a < 0 ? -a : a; }
 static inline int      Abc_MaxInt( int a, int b )             { return a > b ?  a : b; }
 static inline int      Abc_MinInt( int a, int b )             { return a < b ?  a : b; }
 static inline word     Abc_MaxWord( word a, word b )          { return a > b ?  a : b; }
 static inline word     Abc_MinWord( word a, word b )          { return a < b ?  a : b; }
 static inline float    Abc_AbsFloat( float a          )       { return a < 0 ? -a : a; }
 static inline float    Abc_MaxFloat( float a, float b )       { return a > b ?  a : b; }
 static inline float    Abc_MinFloat( float a, float b )       { return a < b ?  a : b; }
 static inline double   Abc_AbsDouble( double a           )    { return a < 0 ? -a : a; }
 static inline double   Abc_MaxDouble( double a, double b )    { return a > b ?  a : b; }
 static inline double   Abc_MinDouble( double a, double b )    { return a < b ?  a : b; }

 static inline int      Abc_Float2Int( float Val )             { union { int x; float y; } v; v.y = Val; return v.x;         }
 static inline float    Abc_Int2Float( int Num )               { union { int x; float y; } v; v.x = Num; return v.y;         }
 static inline word     Abc_Dbl2Word( double Dbl )             { union { word x; double y; } v; v.y = Dbl; return v.x;       }
 static inline double   Abc_Word2Dbl( word Num )               { union { word x; double y; } v; v.x = Num; return v.y;       }
 static inline int      Abc_Base2Log( unsigned n )             { int r; if ( n < 2 ) return n; for ( r = 0, n--; n; n >>= 1, r++ ) {}; return r; }
 static inline int      Abc_Base10Log( unsigned n )            { int r; if ( n < 2 ) return n; for ( r = 0, n--; n; n /= 10, r++ ) {}; return r; }
 static inline int      Abc_Base16Log( unsigned n )            { int r; if ( n < 2 ) return n; for ( r = 0, n--; n; n /= 16, r++ ) {}; return r; }
 static inline char *   Abc_UtilStrsav( char * s )             { return s ? strcpy(ABC_ALLOC(char, strlen(s)+1), s) : NULL;  }
 static inline int      Abc_BitWordNum( int nBits )            { return (nBits>>5) + ((nBits&31) > 0);                       }
 static inline int      Abc_Bit6WordNum( int nBits )           { return (nBits>>6) + ((nBits&63) > 0);                       }
 static inline int      Abc_TruthWordNum( int nVars )          { return nVars <= 5 ? 1 : (1 << (nVars - 5));                 }
 static inline int      Abc_Truth6WordNum( int nVars )         { return nVars <= 6 ? 1 : (1 << (nVars - 6));                 }
 static inline int      Abc_InfoHasBit( unsigned * p, int i )  { return (p[(i)>>5] & (1<<((i) & 31))) > 0;                   }
 static inline void     Abc_InfoSetBit( unsigned * p, int i )  { p[(i)>>5] |= (1<<((i) & 31));                               }
 static inline void     Abc_InfoXorBit( unsigned * p, int i )  { p[(i)>>5] ^= (1<<((i) & 31));                               }
 static inline unsigned Abc_InfoMask( int nVar )               { return (~(unsigned)0) >> (32-nVar);                         }

 static inline int      Abc_Var2Lit( int Var, int c )          { assert(Var >= 0 && !(c >> 1)); return Var + Var + c;        }
 static inline int      Abc_Lit2Var( int Lit )                 { assert(Lit >= 0); return Lit >> 1;                          }
 static inline int      Abc_LitIsCompl( int Lit )              { assert(Lit >= 0); return Lit & 1;                           }
 static inline int      Abc_LitNot( int Lit )                  { assert(Lit >= 0); return Lit ^ 1;                           }
 static inline int      Abc_LitNotCond( int Lit, int c )       { assert(Lit >= 0); return Lit ^ (int)(c > 0);                }
 static inline int      Abc_LitRegular( int Lit )              { assert(Lit >= 0); return Lit & ~01;                         }
 static inline int      Abc_Lit2LitV( int * pMap, int Lit )    { assert(Lit >= 0); return Abc_Var2Lit( pMap[Abc_Lit2Var(Lit)], Abc_LitIsCompl(Lit) );      }
 static inline int      Abc_Lit2LitL( int * pMap, int Lit )    { assert(Lit >= 0); return Abc_LitNotCond( pMap[Abc_Lit2Var(Lit)], Abc_LitIsCompl(Lit) );   }

 static inline int      Abc_Ptr2Int( void * p )                { return (int)(ABC_PTRINT_T)p;      }
 static inline void *   Abc_Int2Ptr( int i )                   { return (void *)(ABC_PTRINT_T)i;   }
 static inline word     Abc_Ptr2Wrd( void * p )                { return (word)(ABC_PTRUINT_T)p;    }
 static inline void *   Abc_Wrd2Ptr( word i )                  { return (void *)(ABC_PTRUINT_T)i;  }

 static inline int      Abc_Var2Lit2( int Var, int Att )       { assert(!(Att >> 2)); return (Var << 2) + Att; }
 static inline int      Abc_Lit2Var2( int Lit )                { assert(Lit >= 0);    return Lit >> 2;         }
 static inline int      Abc_Lit2Att2( int Lit )                { assert(Lit >= 0);    return Lit & 3;          }
 static inline int      Abc_Var2Lit3( int Var, int Att )       { assert(!(Att >> 3)); return (Var << 3) + Att; }
 static inline int      Abc_Lit2Var3( int Lit )                { assert(Lit >= 0);    return Lit >> 3;         }
 static inline int      Abc_Lit2Att3( int Lit )                { assert(Lit >= 0);    return Lit & 7;          }
 static inline int      Abc_Var2Lit4( int Var, int Att )       { assert(!(Att >> 4)); return (Var << 4) + Att; }
 static inline int      Abc_Lit2Var4( int Lit )                { assert(Lit >= 0);    return Lit >> 4;         }
 static inline int      Abc_Lit2Att4( int Lit )                { assert(Lit >= 0);    return Lit & 15;         }

 // time counting
 typedef ABC_INT64_T abctime;
 static inline abctime Abc_Clock()
 {
 #if (defined(LIN) || defined(LIN64)) && !(__APPLE__ & __MACH__) && !defined(__MINGW32__)
     struct timespec ts;
     if ( clock_gettime(CLOCK_THREAD_CPUTIME_ID, &ts) < 0 )
         return (abctime)-1;
     abctime res = ((abctime) ts.tv_sec) * CLOCKS_PER_SEC;
     res += (((abctime) ts.tv_nsec) * CLOCKS_PER_SEC) / 1000000000;
     return res;
 #else
     return (abctime) clock();
 #endif
 }

 // bridge communication
 #define BRIDGE_NETLIST           106
 #define BRIDGE_ABS_NETLIST       107
 extern int Gia_ManToBridgeText( FILE * pFile, int Size, unsigned char * pBuffer );
 extern int Gia_ManToBridgeAbsNetlist( FILE * pFile, void * p, int pkg_type );

 // string printing
 extern char * vnsprintf(const char* format, va_list args);
 extern char * nsprintf(const char* format, ...);


 // misc printing procedures
 enum Abc_VerbLevel
 {
     ABC_PROMPT   = -2,
     ABC_ERROR    = -1,
     ABC_WARNING  =  0,
     ABC_STANDARD =  1,
     ABC_VERBOSE  =  2
 };
 static inline void Abc_Print( int level, const char * format, ... )
 {
     extern ABC_DLL int Abc_FrameIsBridgeMode();
     va_list args;

     if ( ! Abc_FrameIsBridgeMode() ){
         if ( level == ABC_ERROR )
             printf( "Error: " );
         else if ( level == ABC_WARNING )
             printf( "Warning: " );
     }else{
         if ( level == ABC_ERROR )
             Gia_ManToBridgeText( stdout, (int)strlen("Error: "), (unsigned char*)"Error: " );
         else if ( level == ABC_WARNING )
             Gia_ManToBridgeText( stdout, (int)strlen("Warning: "), (unsigned char*)"Warning: " );
     }

     va_start( args, format );
     if ( Abc_FrameIsBridgeMode() )
     {
         char * tmp = vnsprintf( format, args );
         Gia_ManToBridgeText( stdout, (int)strlen(tmp), (unsigned char*)tmp );
         free( tmp );
     }
     else
         vprintf( format, args );
     va_end( args );
 }

 static inline void Abc_PrintInt( int i )
 {
     double v3 = (double)i/1000;
     double v6 = (double)i/1000000;

     Abc_Print( 1,  "  " );

     if ( i > -1000 && i < 1000 )
         Abc_Print( 1, " %4d", i );

     else if ( v3 > -9.995 && v3 < 9.995 )
         Abc_Print( 1, "%4.2fk", v3 );
     else if ( v3 > -99.95 && v3 < 99.95 )
         Abc_Print( 1, "%4.1fk", v3 );
     else if ( v3 > -999.5 && v3 < 999.5 )
         Abc_Print( 1, "%4.0fk", v3 );

     else if ( v6 > -9.995 && v6 < 9.995 )
         Abc_Print( 1, "%4.2fm", v6 );
     else if ( v6 > -99.95 && v6 < 99.95 )
         Abc_Print( 1, "%4.1fm", v6 );
     else if ( v6 > -999.5 && v6 < 999.5 )
         Abc_Print( 1, "%4.0fm", v6 );
 }

 static inline void Abc_PrintTime( int level, const char * pStr, abctime time )
 {
     ABC_PRT( pStr, time );
 }

 static inline void Abc_PrintTimeP( int level, const char * pStr, abctime time, abctime Time )
 {
     ABC_PRTP( pStr, time, Time );
 }

 static inline void Abc_PrintMemoryP( int level, const char * pStr, int mem, int Mem )
 {
     ABC_PRMP( pStr, mem, Mem );
 }

 // Returns the next prime >= p
 static inline int Abc_PrimeCudd( unsigned int p )
 {
     int i,pn;
     p--;
     do {
         p++;
         if (p&1)
         {
             pn = 1;
             i = 3;
             while ((unsigned) (i * i) <= p)
             {
                 if (p % i == 0) {
                     pn = 0;
                     break;
                 }
                 i += 2;
             }
         }
         else
             pn = 0;
     } while (!pn);
     return(p);

 } // end of Cudd_Prime


 // sorting
 extern void   Abc_MergeSort( int * pInput, int nSize );
 extern int *  Abc_MergeSortCost( int * pCosts, int nSize );
 extern void   Abc_QuickSort1( word * pData, int nSize, int fDecrease );
 extern void   Abc_QuickSort2( word * pData, int nSize, int fDecrease );
 extern void   Abc_QuickSort3( word * pData, int nSize, int fDecrease );
 extern void   Abc_QuickSortCostData( int * pCosts, int nSize, int fDecrease, word * pData, int * pResult );
 extern int *  Abc_QuickSortCost( int * pCosts, int nSize, int fDecrease );


 ABC_NAMESPACE_HEADER_END

 #endif

 ////////////////////////////////////////////////////////////////////////
 ///                       END OF FILE                                ///
 ////////////////////////////////////////////////////////////////////////
	/CFile**************************************************************

	FileName [abc_global.h]

	SystemName [ABC: Logic synthesis and verification system.]

	PackageName [Global declarations.]

	Synopsis [Global declarations.]

	Author [Alan Mishchenko]

	Affiliation [UC Berkeley]

	Date [Ver. 1.0. Started - Jan 30, 2009.]

	Revision [$Id: abc_global.h,v 1.00 2009/01/30 00:00:00 alanmi Exp $]

	***********************************************************************/

	#ifndef ABC__misc__util__abc_global_h
	#define ABC__misc__util__abc_global_h

	////////////////////////////////////////////////////////////////////////
	/// INCLUDES ///
	////////////////////////////////////////////////////////////////////////

	#ifdef _WIN32
	#ifndef __MINGW32__
	#define inline __inline // compatible with MS VS 6.0
	#pragma warning(disable : 4152) // warning C4152: nonstandard extension, function/data pointer conversion in expression
	#pragma warning(disable : 4200) // warning C4200: nonstandard extension used : zero-sized array in struct/union
	#pragma warning(disable : 4244) // warning C4244: '+=' : conversion from 'int ' to 'unsigned short ', possible loss of data
	#pragma warning(disable : 4514) // warning C4514: 'Vec_StrPop' : unreferenced inline function has been removed
	#pragma warning(disable : 4710) // warning C4710: function 'Vec_PtrGrow' not inlined
	//#pragma warning( disable : 4273 )
	#endif
	#endif

	#ifdef WIN32
	#ifdef WIN32_NO_DLL
	#define ABC_DLLEXPORT
	#define ABC_DLLIMPORT
	#else
	#define ABC_DLLEXPORT __declspec(dllexport)
	#define ABC_DLLIMPORT __declspec(dllimport)
	#endif
	#else /* defined(WIN32) */
	#define ABC_DLLIMPORT
	#endif /* defined(WIN32) */

	#ifndef ABC_DLL
	#define ABC_DLL ABC_DLLIMPORT
	#endif

	#if !defined(___unused)
	#if defined(__GNUC__)
	#define ___unused __attribute__ ((__unused__))
	#else
	#define ___unused
	#endif
	#endif

	/*
	#ifdef __cplusplus
	#error "C++ code"
	#else
	#error "C code"
	#endif
	*/

	#include <time.h>
	#include <stdarg.h>
	#include <stdlib.h>
	#include <assert.h>
	#include <stdio.h>
	#include <string.h>

	// catch memory leaks in Visual Studio
	#ifdef WIN32
	#ifdef _DEBUG
	#define _CRTDBG_MAP_ALLOC
	#include <crtdbg.h>
	#endif
	#endif

	#include "abc_namespaces.h"

	////////////////////////////////////////////////////////////////////////
	/// PARAMETERS ///
	////////////////////////////////////////////////////////////////////////

	ABC_NAMESPACE_HEADER_START

	////////////////////////////////////////////////////////////////////////
	/// BASIC TYPES ///
	////////////////////////////////////////////////////////////////////////

	#ifdef ABC_USE_STDINT_H
	// If there is stdint.h, assume this is a reasonably-modern platform that
	// would also have stddef.h and limits.h
	#include <limits.h>
	#include <stddef.h>
	#include <stdint.h>

	#if UINTPTR_MAX == 0xFFFFFFFFFFFFFFFF
	#define SIZEOF_VOID_P 8
	#ifdef _WIN32
	#define NT64
	#else
	#define LIN64
	#endif
	#elif UINTPTR_MAX == 0xFFFFFFFF
	#define SIZEOF_VOID_P 4
	#ifdef _WIN32
	#define NT
	#else
	#define LIN
	#endif
	#else
	#error unsupported platform
	#endif

	#if ULONG_MAX == 0xFFFFFFFFFFFFFFFF
	#define SIZEOF_LONG 8
	#elif ULONG_MAX == 0xFFFFFFFF
	#define SIZEOF_LONG 4
	#else
	#error unsupported platform
	#endif

	#if UINT_MAX == 0xFFFFFFFFFFFFFFFF
	#define SIZEOF_INT 8
	#elif UINT_MAX == 0xFFFFFFFF
	#define SIZEOF_INT 4
	#else
	#error unsupported platform
	#endif

	#endif

	/**
	* Pointer difference type; replacement for ptrdiff_t.
	* This is a signed integral type that is the same size as a pointer.
	* NOTE: This type may be different sizes on different platforms.
	*/
	#if defined(__ccdoc__)
	typedef platform_dependent_type ABC_PTRDIFF_T;
	#elif defined(ABC_USE_STDINT_H)
	typedef ptrdiff_t ABC_PTRDIFF_T;
	#elif defined(LIN64)
	typedef long ABC_PTRDIFF_T;
	#elif defined(NT64)
	typedef long long ABC_PTRDIFF_T;
	#elif defined(NT) \|\| defined(LIN) \|\| defined(WIN32)
	typedef int ABC_PTRDIFF_T;
	#else
	#error unknown platform
	#endif /* defined(PLATFORM) */

	/**
	* Unsigned integral type that can contain a pointer.
	* This is an unsigned integral type that is the same size as a pointer.
	* NOTE: This type may be different sizes on different platforms.
	*/
	#if defined(__ccdoc__)
	typedef platform_dependent_type ABC_PTRUINT_T;
	#elif defined(ABC_USE_STDINT_H)
	typedef uintptr_t ABC_PTRUINT_T;
	#elif defined(LIN64)
	typedef unsigned long ABC_PTRUINT_T;
	#elif defined(NT64)
	typedef unsigned long long ABC_PTRUINT_T;
	#elif defined(NT) \|\| defined(LIN) \|\| defined(WIN32)
	typedef unsigned int ABC_PTRUINT_T;
	#else
	#error unknown platform
	#endif /* defined(PLATFORM) */

	/**
	* Signed integral type that can contain a pointer.
	* This is a signed integral type that is the same size as a pointer.
	* NOTE: This type may be different sizes on different platforms.
	*/
	#if defined(__ccdoc__)
	typedef platform_dependent_type ABC_PTRINT_T;
	#elif defined(ABC_USE_STDINT_H)
	typedef intptr_t ABC_PTRINT_T;
	#elif defined(LIN64)
	typedef long ABC_PTRINT_T;
	#elif defined(NT64)
	typedef long long ABC_PTRINT_T;
	#elif defined(NT) \|\| defined(LIN) \|\| defined(WIN32)
	typedef int ABC_PTRINT_T;
	#else
	#error unknown platform
	#endif /* defined(PLATFORM) */

	/**
	* 64-bit signed integral type.
	*/
	#if defined(__ccdoc__)
	typedef platform_dependent_type ABC_INT64_T;
	#elif defined(ABC_USE_STDINT_H)
	typedef int64_t ABC_INT64_T;
	#elif defined(LIN64)
	typedef long ABC_INT64_T;
	#elif defined(NT64) \|\| defined(LIN)
	typedef long long ABC_INT64_T;
	#elif defined(WIN32) \|\| defined(NT)
	typedef signed __int64 ABC_INT64_T;
	#else
	#error unknown platform
	#endif /* defined(PLATFORM) */

	/**
	* 64-bit unsigned integral type.
	*/
	#if defined(__ccdoc__)
	typedef platform_dependent_type ABC_UINT64_T;
	#elif defined(ABC_USE_STDINT_H)
	typedef uint64_t ABC_UINT64_T;
	#elif defined(LIN64)
	typedef unsigned long ABC_UINT64_T;
	#elif defined(NT64) \|\| defined(LIN)
	typedef unsigned long long ABC_UINT64_T;
	#elif defined(WIN32) \|\| defined(NT)
	typedef unsigned __int64 ABC_UINT64_T;
	#else
	#error unknown platform
	#endif /* defined(PLATFORM) */

	#ifdef LIN
	#define ABC_CONST(number) number ## ULL
	#else // LIN64 and windows
	#define ABC_CONST(number) number
	#endif

	typedef ABC_UINT64_T word;
	typedef ABC_INT64_T iword;

	////////////////////////////////////////////////////////////////////////
	/// MACRO DEFINITIONS ///
	////////////////////////////////////////////////////////////////////////

	#define ABC_INFINITY (1000000000)

	#define ABC_SWAP(Type, a, b) { Type t = a; a = b; b = t; }

	#define ABC_PRT(a,t) (Abc_Print(1, "%s =", (a)), Abc_Print(1, "%9.2f sec\n", 1.0*(t)/(CLOCKS_PER_SEC)))
	#define ABC_PRTr(a,t) (Abc_Print(1, "%s =", (a)), Abc_Print(1, "%9.2f sec\r", 1.0*(t)/(CLOCKS_PER_SEC)))
	#define ABC_PRTn(a,t) (Abc_Print(1, "%s =", (a)), Abc_Print(1, "%9.2f sec ", 1.0*(t)/(CLOCKS_PER_SEC)))
	#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))
	#define ABC_PRM(a,f) (Abc_Print(1, "%s =", (a)), Abc_Print(1, "%10.3f MB\n", 1.0*(f)/(1<<20)))
	#define ABC_PRMr(a,f) (Abc_Print(1, "%s =", (a)), Abc_Print(1, "%10.3f MB\r", 1.0*(f)/(1<<20)))
	#define ABC_PRMn(a,f) (Abc_Print(1, "%s =", (a)), Abc_Print(1, "%10.3f MB ", 1.0*(f)/(1<<20)))
	#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) ) )

	#define ABC_ALLOC(type, num) ((type ) malloc(sizeof(type) (num)))
	#define ABC_CALLOC(type, num) ((type *) calloc((num), sizeof(type)))
	#define ABC_FALLOC(type, num) ((type ) memset(malloc(sizeof(type) (num)), 0xff, sizeof(type) * (num)))
	#define ABC_FREE(obj) ((obj) ? (free((char *) (obj)), (obj) = 0) : 0)
	#define ABC_REALLOC(type, obj, num) \
	((obj) ? ((type ) realloc((char )(obj), sizeof(type) * (num))) : \
	((type ) malloc(sizeof(type) (num))))

	static inline int Abc_AbsInt( int a ) { return a < 0 ? -a : a; }
	static inline int Abc_MaxInt( int a, int b ) { return a > b ? a : b; }
	static inline int Abc_MinInt( int a, int b ) { return a < b ? a : b; }
	static inline word Abc_MaxWord( word a, word b ) { return a > b ? a : b; }
	static inline word Abc_MinWord( word a, word b ) { return a < b ? a : b; }
	static inline float Abc_AbsFloat( float a ) { return a < 0 ? -a : a; }
	static inline float Abc_MaxFloat( float a, float b ) { return a > b ? a : b; }
	static inline float Abc_MinFloat( float a, float b ) { return a < b ? a : b; }
	static inline double Abc_AbsDouble( double a ) { return a < 0 ? -a : a; }
	static inline double Abc_MaxDouble( double a, double b ) { return a > b ? a : b; }
	static inline double Abc_MinDouble( double a, double b ) { return a < b ? a : b; }

	static inline int Abc_Float2Int( float Val ) { union { int x; float y; } v; v.y = Val; return v.x; }
	static inline float Abc_Int2Float( int Num ) { union { int x; float y; } v; v.x = Num; return v.y; }
	static inline word Abc_Dbl2Word( double Dbl ) { union { word x; double y; } v; v.y = Dbl; return v.x; }
	static inline double Abc_Word2Dbl( word Num ) { union { word x; double y; } v; v.x = Num; return v.y; }
	static inline int Abc_Base2Log( unsigned n ) { int r; if ( n < 2 ) return n; for ( r = 0, n--; n; n >>= 1, r++ ) {}; return r; }
	static inline int Abc_Base10Log( unsigned n ) { int r; if ( n < 2 ) return n; for ( r = 0, n--; n; n /= 10, r++ ) {}; return r; }
	static inline int Abc_Base16Log( unsigned n ) { int r; if ( n < 2 ) return n; for ( r = 0, n--; n; n /= 16, r++ ) {}; return r; }
	static inline char * Abc_UtilStrsav( char * s ) { return s ? strcpy(ABC_ALLOC(char, strlen(s)+1), s) : NULL; }
	static inline int Abc_BitWordNum( int nBits ) { return (nBits>>5) + ((nBits&31) > 0); }
	static inline int Abc_Bit6WordNum( int nBits ) { return (nBits>>6) + ((nBits&63) > 0); }
	static inline int Abc_TruthWordNum( int nVars ) { return nVars <= 5 ? 1 : (1 << (nVars - 5)); }
	static inline int Abc_Truth6WordNum( int nVars ) { return nVars <= 6 ? 1 : (1 << (nVars - 6)); }
	static inline int Abc_InfoHasBit( unsigned * p, int i ) { return (p[(i)>>5] & (1<<((i) & 31))) > 0; }
	static inline void Abc_InfoSetBit( unsigned * p, int i ) { p[(i)>>5] \|= (1<<((i) & 31)); }
	static inline void Abc_InfoXorBit( unsigned * p, int i ) { p[(i)>>5] ^= (1<<((i) & 31)); }
	static inline unsigned Abc_InfoMask( int nVar ) { return (~(unsigned)0) >> (32-nVar); }

	static inline int Abc_Var2Lit( int Var, int c ) { assert(Var >= 0 && !(c >> 1)); return Var + Var + c; }
	static inline int Abc_Lit2Var( int Lit ) { assert(Lit >= 0); return Lit >> 1; }
	static inline int Abc_LitIsCompl( int Lit ) { assert(Lit >= 0); return Lit & 1; }
	static inline int Abc_LitNot( int Lit ) { assert(Lit >= 0); return Lit ^ 1; }
	static inline int Abc_LitNotCond( int Lit, int c ) { assert(Lit >= 0); return Lit ^ (int)(c > 0); }
	static inline int Abc_LitRegular( int Lit ) { assert(Lit >= 0); return Lit & ~01; }
	static inline int Abc_Lit2LitV( int * pMap, int Lit ) { assert(Lit >= 0); return Abc_Var2Lit( pMap[Abc_Lit2Var(Lit)], Abc_LitIsCompl(Lit) ); }
	static inline int Abc_Lit2LitL( int * pMap, int Lit ) { assert(Lit >= 0); return Abc_LitNotCond( pMap[Abc_Lit2Var(Lit)], Abc_LitIsCompl(Lit) ); }

	static inline int Abc_Ptr2Int( void * p ) { return (int)(ABC_PTRINT_T)p; }
	static inline void * Abc_Int2Ptr( int i ) { return (void *)(ABC_PTRINT_T)i; }
	static inline word Abc_Ptr2Wrd( void * p ) { return (word)(ABC_PTRUINT_T)p; }
	static inline void * Abc_Wrd2Ptr( word i ) { return (void *)(ABC_PTRUINT_T)i; }

	static inline int Abc_Var2Lit2( int Var, int Att ) { assert(!(Att >> 2)); return (Var << 2) + Att; }
	static inline int Abc_Lit2Var2( int Lit ) { assert(Lit >= 0); return Lit >> 2; }
	static inline int Abc_Lit2Att2( int Lit ) { assert(Lit >= 0); return Lit & 3; }
	static inline int Abc_Var2Lit3( int Var, int Att ) { assert(!(Att >> 3)); return (Var << 3) + Att; }
	static inline int Abc_Lit2Var3( int Lit ) { assert(Lit >= 0); return Lit >> 3; }
	static inline int Abc_Lit2Att3( int Lit ) { assert(Lit >= 0); return Lit & 7; }
	static inline int Abc_Var2Lit4( int Var, int Att ) { assert(!(Att >> 4)); return (Var << 4) + Att; }
	static inline int Abc_Lit2Var4( int Lit ) { assert(Lit >= 0); return Lit >> 4; }
	static inline int Abc_Lit2Att4( int Lit ) { assert(Lit >= 0); return Lit & 15; }

	// time counting
	typedef ABC_INT64_T abctime;
	static inline abctime Abc_Clock()
	{
	#if (defined(LIN) \|\| defined(LIN64)) && !(__APPLE__ & __MACH__) && !defined(__MINGW32__)
	struct timespec ts;
	if ( clock_gettime(CLOCK_THREAD_CPUTIME_ID, &ts) < 0 )
	return (abctime)-1;
	abctime res = ((abctime) ts.tv_sec) * CLOCKS_PER_SEC;
	res += (((abctime) ts.tv_nsec) * CLOCKS_PER_SEC) / 1000000000;
	return res;
	#else
	return (abctime) clock();
	#endif
	}

	// bridge communication
	#define BRIDGE_NETLIST 106
	#define BRIDGE_ABS_NETLIST 107
	extern int Gia_ManToBridgeText( FILE * pFile, int Size, unsigned char * pBuffer );
	extern int Gia_ManToBridgeAbsNetlist( FILE * pFile, void * p, int pkg_type );

	// string printing
	extern char * vnsprintf(const char* format, va_list args);
	extern char * nsprintf(const char* format, ...);


	// misc printing procedures
	enum Abc_VerbLevel
	{
	ABC_PROMPT = -2,
	ABC_ERROR = -1,
	ABC_WARNING = 0,
	ABC_STANDARD = 1,
	ABC_VERBOSE = 2
	};
	static inline void Abc_Print( int level, const char * format, ... )
	{
	extern ABC_DLL int Abc_FrameIsBridgeMode();
	va_list args;

	if ( ! Abc_FrameIsBridgeMode() ){
	if ( level == ABC_ERROR )
	printf( "Error: " );
	else if ( level == ABC_WARNING )
	printf( "Warning: " );
	}else{
	if ( level == ABC_ERROR )
	Gia_ManToBridgeText( stdout, (int)strlen("Error: "), (unsigned char*)"Error: " );
	else if ( level == ABC_WARNING )
	Gia_ManToBridgeText( stdout, (int)strlen("Warning: "), (unsigned char*)"Warning: " );
	}

	va_start( args, format );
	if ( Abc_FrameIsBridgeMode() )
	{
	char * tmp = vnsprintf( format, args );
	Gia_ManToBridgeText( stdout, (int)strlen(tmp), (unsigned char*)tmp );
	free( tmp );
	}
	else
	vprintf( format, args );
	va_end( args );
	}

	static inline void Abc_PrintInt( int i )
	{
	double v3 = (double)i/1000;
	double v6 = (double)i/1000000;

	Abc_Print( 1, " " );

	if ( i > -1000 && i < 1000 )
	Abc_Print( 1, " %4d", i );

	else if ( v3 > -9.995 && v3 < 9.995 )
	Abc_Print( 1, "%4.2fk", v3 );
	else if ( v3 > -99.95 && v3 < 99.95 )
	Abc_Print( 1, "%4.1fk", v3 );
	else if ( v3 > -999.5 && v3 < 999.5 )
	Abc_Print( 1, "%4.0fk", v3 );

	else if ( v6 > -9.995 && v6 < 9.995 )
	Abc_Print( 1, "%4.2fm", v6 );
	else if ( v6 > -99.95 && v6 < 99.95 )
	Abc_Print( 1, "%4.1fm", v6 );
	else if ( v6 > -999.5 && v6 < 999.5 )
	Abc_Print( 1, "%4.0fm", v6 );
	}

	static inline void Abc_PrintTime( int level, const char * pStr, abctime time )
	{
	ABC_PRT( pStr, time );
	}

	static inline void Abc_PrintTimeP( int level, const char * pStr, abctime time, abctime Time )
	{
	ABC_PRTP( pStr, time, Time );
	}

	static inline void Abc_PrintMemoryP( int level, const char * pStr, int mem, int Mem )
	{
	ABC_PRMP( pStr, mem, Mem );
	}

	// Returns the next prime >= p
	static inline int Abc_PrimeCudd( unsigned int p )
	{
	int i,pn;
	p--;
	do {
	p++;
	if (p&1)
	{
	pn = 1;
	i = 3;
	while ((unsigned) (i * i) <= p)
	{
	if (p % i == 0) {
	pn = 0;
	break;
	}
	i += 2;
	}
	}
	else
	pn = 0;
	} while (!pn);
	return(p);

	} // end of Cudd_Prime


	// sorting
	extern void Abc_MergeSort( int * pInput, int nSize );
	extern int * Abc_MergeSortCost( int * pCosts, int nSize );
	extern void Abc_QuickSort1( word * pData, int nSize, int fDecrease );
	extern void Abc_QuickSort2( word * pData, int nSize, int fDecrease );
	extern void Abc_QuickSort3( word * pData, int nSize, int fDecrease );
	extern void Abc_QuickSortCostData( int * pCosts, int nSize, int fDecrease, word * pData, int * pResult );
	extern int * Abc_QuickSortCost( int * pCosts, int nSize, int fDecrease );


	ABC_NAMESPACE_HEADER_END

	#endif

	////////////////////////////////////////////////////////////////////////
	/// END OF FILE ///
	////////////////////////////////////////////////////////////////////////