bblif.c File Reference

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include "misc/util/abc_global.h"
#include "bblif.h"

Go to the source code of this file.

Data Structures
struct	Vec_Int_t_
struct	Vec_Str_t_
struct	Bbl_Obj_t_
struct	Bbl_Fnc_t_
struct	Bbl_Ent_t_
struct	Bbl_Man_t_

Macros
#define	Bbl_ManForEachObj_int(p, pObj, h)   for ( h = 0; (h < p->nSize) && (pObj = Bbl_VecObj(p,h)); h += Bbl_ObjSize(pObj) )
#define	Bbl_ManForEachFnc_int(p, pObj, h)   for ( h = 0; (h < p->nSize) && (pObj = Bbl_VecFnc(p,h)); h += Bbl_FncSize(pObj) )
#define	Bbl_ObjForEachFanin_int(pObj, pFanin, i)   for ( i = 0; (i < (int)pObj->nFanins) && (pFanin = Bbl_ObjFanin(pObj,i)); i++ )
#define	BBLIF_ALLOC(type, num)   ((type *) malloc(sizeof(type) * (num)))
#define	BBLIF_CALLOC(type, num)   ((type *) calloc((num), sizeof(type)))
#define	BBLIF_FALLOC(type, num)   ((type *) memset(malloc(sizeof(type) * (num)), 0xff, sizeof(type) * (num)))
#define	BBLIF_FREE(obj)   ((obj) ? (free((char *) (obj)), (obj) = 0) : 0)
#define	BBLIF_REALLOC(type, obj, num)

Typedefs
typedef typedefABC_NAMESPACE_IMPL_START struct Vec_Int_t_	Vec_Int_t
	DECLARATIONS ///. More...
typedef struct Vec_Str_t_	Vec_Str_t
typedef struct Bbl_Fnc_t_	Bbl_Fnc_t
typedef struct Bbl_Ent_t_	Bbl_Ent_t

Functions
static int	Bbl_ObjIsCi (Bbl_Obj_t *pObj)
static int	Bbl_ObjIsCo (Bbl_Obj_t *pObj)
static int	Bbl_ObjIsNode (Bbl_Obj_t *pObj)
static int	Bbl_ObjFaninNum (Bbl_Obj_t *pObj)
static Bbl_Obj_t *	Bbl_ObjFanin (Bbl_Obj_t *pObj, int i)
static int	Bbl_ObjSize (Bbl_Obj_t *pObj)
static int	Bbl_FncSize (Bbl_Fnc_t *pFnc)
static Bbl_Obj_t *	Bbl_VecObj (Vec_Str_t *p, int h)
static Bbl_Fnc_t *	Bbl_VecFnc (Vec_Str_t *p, int h)
static Bbl_Ent_t *	Bbl_VecEnt (Vec_Str_t *p, int h)
static char *	Bbl_ManSop (Bbl_Man_t *p, int h)
static Bbl_Obj_t *	Bbl_ManObj (Bbl_Man_t *p, int Id)
static Vec_Int_t *	Vec_IntAlloc (int nCap)
	FUNCTION DEFINITIONS ///. More...
static Vec_Int_t *	Vec_IntStart (int nSize)
static Vec_Int_t *	Vec_IntStartNatural (int nSize)
static Vec_Int_t *	Vec_IntAllocArray (int *pArray, int nSize)
static void	Vec_IntFree (Vec_Int_t *p)
static int	Vec_IntSize (Vec_Int_t *p)
static int	Vec_IntEntry (Vec_Int_t *p, int i)
static void	Vec_IntWriteEntry (Vec_Int_t *p, int i, int Entry)
static void	Vec_IntAddToEntry (Vec_Int_t *p, int i, int Addition)
static int	Vec_IntEntryLast (Vec_Int_t *p)
static void	Vec_IntGrow (Vec_Int_t *p, int nCapMin)
static void	Vec_IntFill (Vec_Int_t *p, int nSize, int Fill)
static void	Vec_IntFillExtra (Vec_Int_t *p, int nSize, int Fill)
static int	Vec_IntGetEntry (Vec_Int_t *p, int i)
static void	Vec_IntSetEntry (Vec_Int_t *p, int i, int Entry)
static void	Vec_IntShrink (Vec_Int_t *p, int nSizeNew)
static void	Vec_IntClear (Vec_Int_t *p)
static void	Vec_IntPush (Vec_Int_t *p, int Entry)
static Vec_Str_t *	Vec_StrAlloc (int nCap)
static Vec_Str_t *	Vec_StrAllocArray (char *pArray, int nSize)
char *	Vec_StrFetch (Vec_Str_t *p, int nBytes)
void	Vec_StrWrite (FILE *pFile, Vec_Str_t *p)
Vec_Str_t *	Vec_StrRead (char **ppStr)
static int	Vec_StrSize (Vec_Str_t *p)
static void	Vec_StrFree (Vec_Str_t *p)
int	Bbl_ManFileSize (char *pFileName)
char *	Bbl_ManFileRead (char *pFileName)
void	Bbl_ManDumpBinaryBlif (Bbl_Man_t *p, char *pFileName)
Bbl_Man_t *	Bbl_ManReadBinaryBlif (char *pFileName)
void	Bbl_ManPrintStats (Bbl_Man_t *p)
void	Bbl_ManStop (Bbl_Man_t *p)
Bbl_Man_t *	Bbl_ManStart (char *pName)
	MACRO DEFINITIONS ///. More...
void	Bbl_ManSortCubes (char **pCubes, int nCubes, int nVars)
char *	Bbl_ManSortSop (char *pSop, int nVars)
int	Bbl_ManCreateEntry (Bbl_Man_t *p, int iFunc, int iNext)
int	Bbl_ManSopCheckUnique (Bbl_Man_t *p, char *pSop, int nVars, int nCubes, int iFunc)
int	Bbl_ManSaveSop (Bbl_Man_t *p, char *pSop, int nVars)
void	Bbl_ManCreateObject (Bbl_Man_t *p, Bbl_Type_t Type, int ObjId, int nFanins, char *pSop)
void	Bbl_ManAddFanin (Bbl_Man_t *p, int ObjId, int FaninId)
int	Bbl_ManCheck (Bbl_Man_t *p)
int	Bbl_ObjIsInput (Bbl_Obj_t *p)
int	Bbl_ObjIsOutput (Bbl_Obj_t *p)
int	Bbl_ObjIsLut (Bbl_Obj_t *p)
int	Bbl_ObjId (Bbl_Obj_t *p)
int	Bbl_ObjIdOriginal (Bbl_Man_t *pMan, Bbl_Obj_t *p)
int	Bbl_ObjFaninNumber (Bbl_Obj_t *p)
char *	Bbl_ObjSop (Bbl_Man_t *pMan, Bbl_Obj_t *p)
int	Bbl_ObjIsMarked (Bbl_Obj_t *p)
void	Bbl_ObjMark (Bbl_Obj_t *p)
int	Bbl_ObjFncHandle (Bbl_Obj_t *p)
char *	Bbl_ManName (Bbl_Man_t *p)
int	Bbl_ManFncSize (Bbl_Man_t *p)
Bbl_Obj_t *	Bbl_ManObjFirst (Bbl_Man_t *p)
Bbl_Obj_t *	Bbl_ManObjNext (Bbl_Man_t *p, Bbl_Obj_t *pObj)
Bbl_Obj_t *	Bbl_ObjFaninFirst (Bbl_Obj_t *p)
Bbl_Obj_t *	Bbl_ObjFaninNext (Bbl_Obj_t *p, Bbl_Obj_t *pPrev)
void	Bbl_ManDumpBlif (Bbl_Man_t *p, char *pFileName)
char *	Bbl_ManTruthToSop (unsigned *pTruth, int nVars)
static void	Bbl_ManSopToTruthElem (int nVars, unsigned **pVars)
unsigned *	Bbl_ManSopToTruth (char *pSop, int nVars)
void	Bbl_ManTestTruth (char *pSop, int nVars)
void	Bbl_ManSimpleDemo ()

Macro Definition Documentation

#define Bbl_ManForEachFnc_int	(		p,
			pObj,
			h
	)		for ( h = 0; (h < p->nSize) && (pObj = Bbl_VecFnc(p,h)); h += Bbl_FncSize(pObj) )

Definition at line 121 of file bblif.c.

#define Bbl_ManForEachObj_int	(		p,
			pObj,
			h
	)		for ( h = 0; (h < p->nSize) && (pObj = Bbl_VecObj(p,h)); h += Bbl_ObjSize(pObj) )

Definition at line 119 of file bblif.c.

#define Bbl_ObjForEachFanin_int	(		pObj,
			pFanin,
			i
	)		for ( i = 0; (i < (int)pObj->nFanins) && (pFanin = Bbl_ObjFanin(pObj,i)); i++ )

Definition at line 123 of file bblif.c.

#define BBLIF_ALLOC	(		type,
			num
	)		((type *) malloc(sizeof(type) * (num)))

Definition at line 126 of file bblif.c.

#define BBLIF_CALLOC	(		type,
			num
	)		((type *) calloc((num), sizeof(type)))

Definition at line 127 of file bblif.c.

#define BBLIF_FALLOC	(		type,
			num
	)		((type *) memset(malloc(sizeof(type) * (num)), 0xff, sizeof(type) * (num)))

Definition at line 128 of file bblif.c.

#define BBLIF_FREE

(

obj

)

((obj) ? (free((char *) (obj)), (obj) = 0) : 0)

Definition at line 129 of file bblif.c.

#define BBLIF_REALLOC	(		type,
			obj,
			num
	)

Value:

((obj) ? ((type *) realloc((char *)(obj), sizeof(type) * (num))) : \
         ((type *) malloc(sizeof(type) * (num))))

Definition at line 130 of file bblif.c.

Typedef Documentation

typedef struct Bbl_Ent_t_ Bbl_Ent_t

Definition at line 76 of file bblif.c.

typedef struct Bbl_Fnc_t_ Bbl_Fnc_t

Definition at line 68 of file bblif.c.

typedef typedefABC_NAMESPACE_IMPL_START struct Vec_Int_t_ Vec_Int_t

DECLARATIONS ///.

CFile****************************************************************

FileName [bblif.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Binary BLIF representation for logic networks.]

Synopsis [Main implementation module.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - February 28, 2009.]

Revision [

Id:

bblif.c,v 1.00 2009/02/28 00:00:00 alanmi Exp

]

Definition at line 37 of file bblif.c.

typedef struct Vec_Str_t_ Vec_Str_t

Definition at line 46 of file bblif.c.

Function Documentation

static int Bbl_FncSize ( Bbl_Fnc_t *  pFnc )

inlinestatic

Definition at line 110 of file bblif.c.

{ return sizeof(Bbl_Fnc_t) + sizeof(int) * pFnc->nWords;   } 

void Bbl_ManAddFanin	(	Bbl_Man_t *	p,
		int	ObjId,
		int	FaninId
	)

Fnction*************************************************************

Synopsis [Creates fanin/fanout relationship between two objects.]

Description []

SideEffects []

SeeAlso []

Definition at line 1023 of file bblif.c.

{
    Bbl_Obj_t * pObj, * pFanin;
    int iFanin;
    pObj   = Bbl_ManObj( p, ObjId );
    if ( Bbl_ObjIsCi(pObj) )
    {
        printf( "Bbl_ManAddFanin(): Cannot add fanin of the combinational input (Id = %d).\n", ObjId );
        return;
    }
    pFanin = Bbl_ManObj( p, FaninId );
    if ( Bbl_ObjIsCo(pFanin) )
    {
        printf( "Bbl_ManAddFanin(): Cannot add fanout of the combinational output (Id = %d).\n", FaninId );
        return;
    }
    iFanin = Vec_IntEntry( p->vFaninNums, ObjId );
    if ( iFanin >= (int)pObj->nFanins )
    {
        printf( "Bbl_ManAddFanin(): Trying to add more fanins to object (Id = %d) than declared (%d).\n", ObjId, pObj->nFanins );
        return;
    }
    assert( iFanin < (int)pObj->nFanins );
    Vec_IntWriteEntry( p->vFaninNums, ObjId, iFanin+1 );
    pObj->pFanins[iFanin] = (char *)pObj - (char *)pFanin;
}

int Bbl_ManCheck

(

Bbl_Man_t *

p

)

Fnction*************************************************************

Synopsis [Returns 1 if the manager was created correctly.]

Description []

SideEffects []

SeeAlso []

Definition at line 1062 of file bblif.c.

{
    Bbl_Obj_t * pObj;
    int h, RetValue = 1;
    Bbl_ManForEachObj_int( p->pObjs, pObj, h )
    {
        if ( Bbl_ObjIsNode(pObj) && pObj->Fnc == -1 )
            RetValue = 0, printf( "Bbl_ManCheck(): Node %d does not have function specified.\n", pObj->Id );
        if ( Bbl_ObjIsCi(pObj) && pObj->Fnc != -1 )
            RetValue = 0, printf( "Bbl_ManCheck(): CI with %d has function specified.\n", pObj->Id );
        if ( Bbl_ObjIsCo(pObj) && pObj->Fnc != -1 )
            RetValue = 0, printf( "Bbl_ManCheck(): CO with %d has function specified.\n", pObj->Id );
        if ( Vec_IntEntry(p->vFaninNums, pObj->Id) != (int)pObj->nFanins )
            RetValue = 0, printf( "Bbl_ManCheck(): Object %d has less fanins (%d) than declared (%d).\n", 
                pObj->Id, Vec_IntEntry(p->vFaninNums, pObj->Id), pObj->nFanins );
    }
    return RetValue;
}

int Bbl_ManCreateEntry	(	Bbl_Man_t *	p,
		int	iFunc,
		int	iNext
	)

Fnction*************************************************************

Synopsis [Saves one entry.]

Description []

SideEffects []

SeeAlso []

Definition at line 901 of file bblif.c.

{
    Bbl_Ent_t * pEnt;
    pEnt = (Bbl_Ent_t *)Vec_StrFetch( p->pEnts, 2 * sizeof(int) );
    pEnt->iFunc = iFunc;
    pEnt->iNext = iNext;
    return (char *)pEnt - p->pEnts->pArray;
}

void Bbl_ManCreateObject	(	Bbl_Man_t *	p,
		Bbl_Type_t	Type,
		int	ObjId,
		int	nFanins,
		char *	pSop
	)

Fnction*************************************************************

Synopsis [Adds one object.]

Description []

SideEffects []

SeeAlso []

Definition at line 988 of file bblif.c.

{
    Bbl_Obj_t * pObj;
    if ( Type == BBL_OBJ_CI && nFanins != 0 )
    {
        printf( "Attempting to create a combinational input with %d fanins (should be 0).\n", nFanins );
        return;
    }
    if ( Type == BBL_OBJ_CO && nFanins != 1 )
    {
        printf( "Attempting to create a combinational output with %d fanins (should be 1).\n", nFanins );
        return;
    }
    pObj = (Bbl_Obj_t *)Vec_StrFetch( p->pObjs, sizeof(Bbl_Obj_t) + nFanins * sizeof(int) );
    memset( pObj, 0, sizeof(Bbl_Obj_t) );
    Vec_IntSetEntry( p->vId2Obj, ObjId, (char *)pObj - p->pObjs->pArray );
    Vec_IntSetEntry( p->vFaninNums, ObjId, 0 );
    pObj->fCi = (Type == BBL_OBJ_CI);
    pObj->fCo = (Type == BBL_OBJ_CO);
    pObj->Id  = ObjId;
    pObj->Fnc = pSop? Bbl_ManSaveSop(p, pSop, nFanins) : -1;
    pObj->nFanins = nFanins;
}

void Bbl_ManDumpBinaryBlif	(	Bbl_Man_t *	p,
		char *	pFileName
	)

Fnction*************************************************************

Synopsis [Writes data into file.]

Description []

SideEffects []

SeeAlso []

Definition at line 691 of file bblif.c.

{
    FILE * pFile;
    pFile = fopen( pFileName, "wb" );
    Vec_StrWrite( pFile, p->pName );
    Vec_StrWrite( pFile, p->pObjs );
    Vec_StrWrite( pFile, p->pFncs );
    fclose( pFile );
}

void Bbl_ManDumpBlif	(	Bbl_Man_t *	p,
		char *	pFileName
	)

Fnction*************************************************************

Synopsis [Drives text BLIF file for debugging.]

Description []

SideEffects []

SeeAlso []

Definition at line 1218 of file bblif.c.

{
    FILE * pFile;
    Bbl_Obj_t * pObj, * pFanin;
    pFile = fopen( pFileName, "w" );
    fprintf( pFile, "# Test file written by Bbl_ManDumpBlif() in ABC.\n" );
    fprintf( pFile, ".model %s\n", Bbl_ManName(p) );
    // write objects
    Bbl_ManForEachObj( p, pObj )
    {
        if ( Bbl_ObjIsInput(pObj) )
            fprintf( pFile, ".inputs %d\n", Bbl_ObjId(pObj) );
        else if ( Bbl_ObjIsOutput(pObj) )
            fprintf( pFile, ".outputs %d\n", Bbl_ObjId(pObj) );
        else if ( Bbl_ObjIsLut(pObj) )
        {
            fprintf( pFile, ".names" );
            Bbl_ObjForEachFanin( pObj, pFanin )
                fprintf( pFile, " %d", Bbl_ObjId(pFanin) );
            fprintf( pFile, " %d\n", Bbl_ObjId(pObj) );
            fprintf( pFile, "%s", Bbl_ObjSop(p, pObj) );
        }
        else assert( 0 );
    }
    // write output drivers
    Bbl_ManForEachObj( p, pObj )
    {
        if ( !Bbl_ObjIsOutput(pObj) )
            continue;
        fprintf( pFile, ".names" );
        Bbl_ObjForEachFanin( pObj, pFanin )
            fprintf( pFile, " %d", Bbl_ObjId(pFanin) );
        fprintf( pFile, " %d\n", Bbl_ObjId(pObj) );
        fprintf( pFile, "1 1\n" );
    }
    fprintf( pFile, ".end\n" );
    fclose( pFile );
}

char* Bbl_ManFileRead

(

char *

pFileName

)

Fnction*************************************************************

Synopsis [Read data from file.]

Description []

SideEffects []

SeeAlso []

Definition at line 664 of file bblif.c.

{
    FILE * pFile;
    char * pContents;
    int nFileSize;
    int RetValue;
    nFileSize = Bbl_ManFileSize( pFileName );
    pFile = fopen( pFileName, "rb" );
    pContents = BBLIF_ALLOC( char, nFileSize );
    RetValue = fread( pContents, nFileSize, 1, pFile );
    fclose( pFile );
    return pContents;
}

int Bbl_ManFileSize

(

char *

pFileName

)

Fnction*************************************************************

Synopsis [Returns the file size.]

Description [The file should be closed.]

SideEffects []

SeeAlso []

Definition at line 637 of file bblif.c.

{
    FILE * pFile;
    int nFileSize;
    pFile = fopen( pFileName, "r" );
    if ( pFile == NULL )
    {
        printf( "Bbl_ManFileSize(): The file is unavailable (absent or open).\n" );
        return 0;
    }
    fseek( pFile, 0, SEEK_END );  
    nFileSize = ftell( pFile ); 
    fclose( pFile );
    return nFileSize;
}

int Bbl_ManFncSize

(

Bbl_Man_t *

p

)

Fnction*************************************************************

Synopsis [Returns the maximum handle of the SOP.]

Description []

SideEffects []

SeeAlso []

Definition at line 1131 of file bblif.c.

{
    return p->pFncs->nSize;
}

char* Bbl_ManName

(

Bbl_Man_t *

p

)

Fnction*************************************************************

Synopsis [Returns the name of the design.]

Description []

SideEffects []

SeeAlso []

Definition at line 1115 of file bblif.c.

{
    return p->pName->pArray;
}

static Bbl_Obj_t* Bbl_ManObj ( Bbl_Man_t *  p, int  Id  )

inlinestatic

Definition at line 117 of file bblif.c.

{ return Bbl_VecObj(p->pObjs, p->vId2Obj->pArray[Id]);     } 

Bbl_Obj_t* Bbl_ManObjFirst

(

Bbl_Man_t *

p

)

Fnction*************************************************************

Synopsis [Returns the first object.]

Description []

SideEffects []

SeeAlso []

Definition at line 1147 of file bblif.c.

{
    return Bbl_VecObj( p->pObjs, 0 );
}

Bbl_Obj_t* Bbl_ManObjNext	(	Bbl_Man_t *	p,
		Bbl_Obj_t *	pObj
	)

Fnction*************************************************************

Synopsis [Returns the next object.]

Description []

SideEffects []

SeeAlso []

Definition at line 1163 of file bblif.c.

{
    char * pNext = (char *)pObj + Bbl_ObjSize(pObj);
    char * pEdge = p->pObjs->pArray + p->pObjs->nSize;
    return (Bbl_Obj_t *)(pNext < pEdge ? pNext : NULL);
}

void Bbl_ManPrintStats

(

Bbl_Man_t *

p

)

Fnction*************************************************************

Synopsis [Prints stats of the manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 749 of file bblif.c.

{
    Bbl_Obj_t * pObj;
    Bbl_Fnc_t * pFnc;
    int h, nFuncs = 0, nNodes = 0, nObjs = 0;
    Bbl_ManForEachObj_int( p->pObjs, pObj, h )
        nObjs++, nNodes += Bbl_ObjIsNode(pObj);
    Bbl_ManForEachFnc_int( p->pFncs, pFnc, h )
        nFuncs++;
    printf( "Total objects = %7d.  Total nodes = %7d. Unique functions = %7d.\n", nObjs, nNodes, nFuncs );
    printf( "Name manager = %5.2f MB\n", 1.0*Vec_StrSize(p->pName)/(1 << 20) );
    printf( "Objs manager = %5.2f MB\n", 1.0*Vec_StrSize(p->pObjs)/(1 << 20) );
    printf( "Fncs manager = %5.2f MB\n", 1.0*Vec_StrSize(p->pFncs)/(1 << 20) );
}

Bbl_Man_t* Bbl_ManReadBinaryBlif

(

char *

pFileName

)

Fnction*************************************************************

Synopsis [Creates manager after reading.]

Description []

SideEffects []

SeeAlso []

Definition at line 712 of file bblif.c.

{
    Bbl_Man_t * p;
    Bbl_Obj_t * pObj;
    char * pBuffer;
    int h;
    p = BBLIF_ALLOC( Bbl_Man_t, 1 );
    memset( p, 0, sizeof(Bbl_Man_t) );
    p->nFileSize = Bbl_ManFileSize( pFileName );
    p->pFileData = Bbl_ManFileRead( pFileName );
    // extract three managers
    pBuffer = p->pFileData;
    p->pName = Vec_StrRead( &pBuffer );
    p->pObjs = Vec_StrRead( &pBuffer );
    p->pFncs = Vec_StrRead( &pBuffer );
    assert( pBuffer - p->pFileData == p->nFileSize );
    // remember original IDs in the objects
    p->vObj2Id = Vec_IntAlloc( 1000 );
    Bbl_ManForEachObj_int( p->pObjs, pObj, h )
    {
        Vec_IntPush( p->vObj2Id, pObj->Id );
        pObj->Id = Vec_IntSize(p->vObj2Id) - 1; 
    }
    return p;
}

int Bbl_ManSaveSop	(	Bbl_Man_t *	p,
		char *	pSop,
		int	nVars
	)

Fnction*************************************************************

Synopsis [Saves one SOP.]

Description []

SideEffects []

SeeAlso []

Definition at line 954 of file bblif.c.

{
    Bbl_Fnc_t * pFnc;
    char * pSopNew;
    int iFunc, Length = strlen(pSop) + 1;
    int nWords = Length / 4 + (Length % 4 > 0);
    // reorder cubes to semi-canicize SOPs
    pSopNew = Bbl_ManSortSop( pSop, nVars );
    // get the candidate location
    iFunc = Bbl_ManSopCheckUnique( p, pSopNew, nVars, Length / (nVars + 3), Vec_StrSize(p->pFncs) );
//    iFunc = Vec_StrSize(p->pFncs);
    if ( iFunc == Vec_StrSize(p->pFncs) )
    { // store this SOP
        pFnc = (Bbl_Fnc_t *)Vec_StrFetch( p->pFncs, sizeof(Bbl_Fnc_t) + nWords * sizeof(int) );
        pFnc->pWords[nWords-1] = 0;
        pFnc->nWords = nWords;
        strcpy( (char *)pFnc->pWords, pSopNew );
        assert( iFunc == (char *)pFnc - p->pFncs->pArray );
    }
    BBLIF_FREE( pSopNew );
    return iFunc;
}

void Bbl_ManSimpleDemo

(

)

Fnction*************************************************************

Synopsis [This demo shows using the internal to construct a half-adder.]

Description [We construct the logic network for the half-adder represnted using the BLIF file below]

SideEffects []

SeeAlso []

Definition at line 1446 of file bblif.c.

{
/*
    # There are contents of a BLIF file representing a half-adder:
    .model hadder
    .inputs a     // ID = 1
    .inputs b     // ID = 2
    .inputs cin   // ID = 3
    .outputs s    // ID = 4
    .outputs cout // ID = 5
    .names a b cin s_driver   // ID = 6
    100 1
    010 1
    001 1
    111 1
    .names a b cin cout_driver // ID = 7
    -11 1
    1-1 1
    11- 1
    .names s_driver s
    1 1
    .names cout_driver cout
    1 1
    .end
*/
    Bbl_Man_t * p;
    // start the data manager
    p = Bbl_ManStart( "hadder" );
    // create CIs
    Bbl_ManCreateObject( p, BBL_OBJ_CI, 1, 0, NULL ); // a
    Bbl_ManCreateObject( p, BBL_OBJ_CI, 2, 0, NULL ); // b
    Bbl_ManCreateObject( p, BBL_OBJ_CI, 3, 0, NULL ); // cin
    // create COs
    Bbl_ManCreateObject( p, BBL_OBJ_CO, 4, 1, NULL ); // s
    Bbl_ManCreateObject( p, BBL_OBJ_CO, 5, 1, NULL ); // cout
    // create internal nodes
    Bbl_ManCreateObject( p, BBL_OBJ_NODE, 6, 3, "100 1\n010 1\n001 1\n111 1\n" ); // s_driver
    Bbl_ManCreateObject( p, BBL_OBJ_NODE, 7, 3, "-11 1\n1-1 1\n11- 1\n" );        // cout_driver
    // add fanins of node 6
    Bbl_ManAddFanin( p, 6, 1 ); // s_driver <- a
    Bbl_ManAddFanin( p, 6, 2 ); // s_driver <- b
    Bbl_ManAddFanin( p, 6, 3 ); // s_driver <- cin
    // add fanins of node 7
    Bbl_ManAddFanin( p, 7, 1 ); // cout_driver <- a
    Bbl_ManAddFanin( p, 7, 2 ); // cout_driver <- b
    Bbl_ManAddFanin( p, 7, 3 ); // cout_driver <- cin
    // add fanins of COs
    Bbl_ManAddFanin( p, 4, 6 ); // s <- s_driver
    Bbl_ManAddFanin( p, 5, 7 ); // cout <- cout_driver
    // sanity check
    Bbl_ManCheck( p );
    // write BLIF file as a sanity check
    Bbl_ManDumpBlif( p, "hadder.blif" );
    // write binary BLIF file
    Bbl_ManDumpBinaryBlif( p, "hadder.bblif" );
    // remove the manager
    Bbl_ManStop( p );


//    Bbl_ManTestTruth( "100 1\n010 1\n001 1\n111 1\n", 3 );
//    Bbl_ManTestTruth( "-11 0\n1-1 0\n11- 0\n", 3 );
//    Bbl_ManTestTruth( "--- 1\n", 3 );
}

static char* Bbl_ManSop ( Bbl_Man_t *  p, int  h  )

inlinestatic

Definition at line 116 of file bblif.c.

{ return (char *)Bbl_VecFnc(p->pFncs, h)->pWords;          } 

int Bbl_ManSopCheckUnique	(	Bbl_Man_t *	p,
		char *	pSop,
		int	nVars,
		int	nCubes,
		int	iFunc
	)

Function*************************************************************

Synopsis [Sorts the cubes in the SOP to uniqify them to some extent.]

Description []

SideEffects []

SeeAlso []

Definition at line 921 of file bblif.c.

{
    Bbl_Fnc_t * pFnc;
    Bbl_Ent_t * pEnt;
    int h, Length = strlen(pSop) + 1;
    int nWords = (Length / 4 + (Length % 4 > 0));
    if ( nVars > 16 )   nVars = 16;
    if ( nCubes > 16 )  nCubes = 16;
//    if ( nVars == 16 && nCubes == 16 )
//        return iFunc;
    for ( h = p->SopMap[nVars][nCubes]; h; h = pEnt->iNext )
    {
        pEnt = Bbl_VecEnt( p->pEnts, h );
        pFnc = Bbl_VecFnc( p->pFncs, pEnt->iFunc );
        assert( nVars == 16 || nCubes == 16 || pFnc->nWords == nWords );
        if ( pFnc->nWords == nWords && memcmp( pFnc->pWords, pSop, Length ) == 0 )
            return pEnt->iFunc;
    }
    p->SopMap[nVars][nCubes] = Bbl_ManCreateEntry( p, iFunc, p->SopMap[nVars][nCubes] );
    return iFunc;
}

unsigned* Bbl_ManSopToTruth	(	char *	pSop,
		int	nVars
	)

Fnction*************************************************************

Synopsis [Converting SOP into a truth table.]

Description [The SOP is represented as a C-string, as documented in file "bblif.h". The truth table is returned as a bit-string composed of 2^nVars bits. For functions of less than 6 variables, the full machine word is returned. (The truth table looks as if the function had 5 variables.) The use of this procedure should be limited to Boolean functions with no more than 16 inputs.]

SideEffects []

SeeAlso []

Definition at line 1362 of file bblif.c.

{
    unsigned * pTruth, * pCube, * pVars[16];
    int nWords = nVars <= 5 ? 1 : (1 << (nVars - 5));
    int v, c, w, nCubes, fCompl = 0;
    if ( pSop == NULL )
        return NULL;
    if ( strlen(pSop) % (nVars + 3) != 0 )
    {
        printf( "Bbl_ManSopToTruth(): SOP is represented incorrectly.\n" );
        return NULL;
    }
    // create storage for TTs of the result, elementary variables and the temp cube
    pTruth   = BBLIF_ALLOC( unsigned, nWords );   
    pVars[0] = BBLIF_ALLOC( unsigned, nWords * (nVars+1) );   
    for ( v = 1; v < nVars; v++ )
        pVars[v] = pVars[v-1] + nWords;
    pCube = pVars[v-1] + nWords;
    Bbl_ManSopToTruthElem( nVars, pVars );
    // iterate through the cubes
    memset( pTruth, 0, sizeof(unsigned) * nWords );
    nCubes =  strlen(pSop) / (nVars + 3);
    for ( c = 0; c < nCubes; c++ )
    {
        fCompl = (pSop[nVars+1] == '0');
        memset( pCube, 0xff, sizeof(unsigned) * nWords );
        // iterate through the literals of the cube
        for ( v = 0; v < nVars; v++ )
            if ( pSop[v] == '1' )
                for ( w = 0; w < nWords; w++ )
                    pCube[w] &= pVars[v][w];
            else if ( pSop[v] == '0' )
                for ( w = 0; w < nWords; w++ )
                    pCube[w] &= ~pVars[v][w];
        // add cube to storage
        for ( w = 0; w < nWords; w++ )
            pTruth[w] |= pCube[w];
        // go to the next cube
        pSop += (nVars + 3);
    }
    BBLIF_FREE( pVars[0] );
    if ( fCompl )
        for ( w = 0; w < nWords; w++ )
            pTruth[w] = ~pTruth[w];
    return pTruth;
}

static void Bbl_ManSopToTruthElem ( int  nVars, unsigned **  pVars  )

inlinestatic

Function*************************************************************

Synopsis [Allocates the array of truth tables for the given number of vars.]

Description []

SideEffects []

SeeAlso []

Definition at line 1323 of file bblif.c.

{
    unsigned Masks[5] = { 0xAAAAAAAA, 0xCCCCCCCC, 0xF0F0F0F0, 0xFF00FF00, 0xFFFF0000 };
    int i, k, nWords;
    nWords = (nVars <= 5 ? 1 : (1 << (nVars - 5)));
    for ( i = 0; i < nVars; i++ )
    {
        if ( i < 5 )
        {
            for ( k = 0; k < nWords; k++ )
                pVars[i][k] = Masks[i];
        }
        else
        {
            for ( k = 0; k < nWords; k++ )
                if ( k & (1 << (i-5)) )
                    pVars[i][k] = ~(unsigned)0;
                else
                    pVars[i][k] = 0;
        }
    }
}

void Bbl_ManSortCubes	(	char **	pCubes,
		int	nCubes,
		int	nVars
	)

Function*************************************************************

Synopsis [Performs selection sort on the array of cubes.]

Description []

SideEffects []

SeeAlso []

Definition at line 839 of file bblif.c.

{
    char * pTemp;
    int i, j, best_i;
    for ( i = 0; i < nCubes-1; i++ )
    {
        best_i = i;
        for (j = i+1; j < nCubes; j++)
            if ( memcmp( pCubes[j], pCubes[best_i], nVars ) < 0 )
                best_i = j;
        pTemp = pCubes[i]; pCubes[i] = pCubes[best_i]; pCubes[best_i] = pTemp;
    }
}

char* Bbl_ManSortSop	(	char *	pSop,
		int	nVars
	)

Function*************************************************************

Synopsis [Sorts the cubes in the SOP to uniqify them to some extent.]

Description []

SideEffects []

SeeAlso []

Definition at line 864 of file bblif.c.

{
    char ** pCubes, * pSopNew;
    int c, Length, nCubes;
    Length = strlen(pSop);
    assert( Length % (nVars + 3) == 0 );
    nCubes = Length / (nVars + 3);
    if ( nCubes < 2 )
    {
        pSopNew = BBLIF_ALLOC( char, Length + 1 );
        memcpy( pSopNew, pSop, Length + 1 );
        return pSopNew;
    }
    pCubes = BBLIF_ALLOC( char *, nCubes );
    for ( c = 0; c < nCubes; c++ )
        pCubes[c] = pSop + c * (nVars + 3);
    if ( nCubes < 300 )
        Bbl_ManSortCubes( pCubes, nCubes, nVars );
    pSopNew = BBLIF_ALLOC( char, Length + 1 );
    for ( c = 0; c < nCubes; c++ )
        memcpy( pSopNew + c * (nVars + 3), pCubes[c], nVars + 3 );
    BBLIF_FREE( pCubes );
    pSopNew[nCubes * (nVars + 3)] = 0;
    return pSopNew;
}

Bbl_Man_t* Bbl_ManStart

(

char *

pName

)

MACRO DEFINITIONS ///.

Fnction*************************************************************

Synopsis [Creates manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 806 of file bblif.c.

{
    Bbl_Man_t * p;
    int nLength;
    p = BBLIF_ALLOC( Bbl_Man_t, 1 );
    memset( p, 0, sizeof(Bbl_Man_t) );
    nLength = pName? 4 * ((strlen(pName) + 1) / 4 + 1) : 0;
    p->pName  = Vec_StrAlloc( nLength );
    p->pName->nSize = p->pName->nCap;
    if ( pName )
        strcpy( p->pName->pArray, pName );
    p->pObjs = Vec_StrAlloc( 1 << 16 );
    p->pFncs = Vec_StrAlloc( 1 << 16 );
    p->pEnts = Vec_StrAlloc( 1 << 16 ); p->pEnts->nSize = 1;
    p->vId2Obj = Vec_IntStart( 1 << 10 );
    p->vFaninNums = Vec_IntStart( 1 << 10 );
    return p;
}

void Bbl_ManStop

(

Bbl_Man_t *

p

)

Fnction*************************************************************

Synopsis [Deletes the manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 775 of file bblif.c.

{
    if ( p->vId2Obj )    Vec_IntFree( p->vId2Obj );
    if ( p->vObj2Id )    Vec_IntFree( p->vObj2Id );
    if ( p->vFaninNums ) Vec_IntFree( p->vFaninNums );
    if ( p->pFileData )
    {
        BBLIF_FREE( p->pFileData );
        p->pName->pArray = NULL;
        p->pObjs->pArray = NULL;
        p->pFncs->pArray = NULL;
    }
    if ( p->pEnts )
    Vec_StrFree( p->pEnts );
    Vec_StrFree( p->pName );
    Vec_StrFree( p->pObjs );
    Vec_StrFree( p->pFncs );
    BBLIF_FREE( p );
}

void Bbl_ManTestTruth	(	char *	pSop,
		int	nVars
	)

Fnction*************************************************************

Synopsis [Checks the truth table computation.]

Description [We construct the logic network for the half-adder represnted using the BLIF file below]

SideEffects []

SeeAlso []

Definition at line 1422 of file bblif.c.

{
    unsigned * pTruth;
    char * pSopNew;
    pTruth = Bbl_ManSopToTruth( pSop, nVars );
    pSopNew = Bbl_ManTruthToSop( pTruth, nVars );
    printf( "Old SOP:\n%s\n", pSop );
    printf( "New SOP:\n%s\n", pSopNew );
    BBLIF_FREE( pSopNew );
    BBLIF_FREE( pTruth );
}

char* Bbl_ManTruthToSop	(	unsigned *	pTruth,
		int	nVars
	)

Fnction*************************************************************

Synopsis [Converting truth table into an SOP.]

Description [The truth table is given as a bit-string pTruth composed of 2^nVars bits. The result is an SOP derived by collecting minterms appearing in the truth table. The SOP is represented as a C-string, as documented in file "bblif.h". It is recommended to limit the use of this procedure to Boolean functions up to 6 inputs.]

SideEffects []

SeeAlso []

Definition at line 1273 of file bblif.c.

{
    char * pResult, * pTemp;
    int nMints, nOnes, b, v;
    assert( nVars >= 0 && nVars <= 16 );
    nMints = (1 << nVars);
    // count the number of ones
    nOnes = 0;
    for ( b = 0; b < nMints; b++ )
        nOnes += ((pTruth[b>>5] >> (b&31)) & 1);
    // handle constants
    if ( nOnes == 0 || nOnes == nMints )
    {
        pResult = pTemp = BBLIF_ALLOC( char, nVars + 4 );        
        for ( v = 0; v < nVars; v++ )
            *pTemp++ = '-';
        *pTemp++ = ' ';
        *pTemp++ = nOnes? '1' : '0';
        *pTemp++ = '\n';
        *pTemp++ = 0;
        assert( pTemp - pResult == nVars + 4 );
        return pResult;
    }
    pResult = pTemp = BBLIF_ALLOC( char, nOnes * (nVars + 3) + 1 );        
    for ( b = 0; b < nMints; b++ )
    {
        if ( ((pTruth[b>>5] >> (b&31)) & 1) == 0 )
            continue;
        for ( v = 0; v < nVars; v++ )
            *pTemp++ = ((b >> v) & 1)? '1' : '0';
        *pTemp++ = ' ';
        *pTemp++ = '1';
        *pTemp++ = '\n';
    }
    *pTemp++ = 0;
    assert( pTemp - pResult == nOnes * (nVars + 3) + 1 );
    return pResult;
}

static Bbl_Obj_t* Bbl_ObjFanin ( Bbl_Obj_t *  pObj, int  i  )

inlinestatic

Definition at line 107 of file bblif.c.

{ return (Bbl_Obj_t *)(((char *)pObj) - pObj->pFanins[i]); } 

Bbl_Obj_t* Bbl_ObjFaninFirst

(

Bbl_Obj_t *

p

)

Fnction*************************************************************

Synopsis [Returns the first fanin.]

Description []

SideEffects []

SeeAlso []

Definition at line 1181 of file bblif.c.

{
    return Bbl_ObjFaninNum(p) ? Bbl_ObjFanin( p, 0 ) : NULL;
}

Bbl_Obj_t* Bbl_ObjFaninNext	(	Bbl_Obj_t *	p,
		Bbl_Obj_t *	pPrev
	)

Fnction*************************************************************

Synopsis [Returns the next fanin.]

Description []

SideEffects []

SeeAlso []

Definition at line 1197 of file bblif.c.

{
    Bbl_Obj_t * pFanin;
    int i;
    Bbl_ObjForEachFanin_int( p, pFanin, i )
        if ( pFanin == pPrev )
            break;
    return i < Bbl_ObjFaninNum(p) - 1 ? Bbl_ObjFanin( p, i+1 ) : NULL;
}

static int Bbl_ObjFaninNum ( Bbl_Obj_t *  pObj )

inlinestatic

Definition at line 106 of file bblif.c.

{ return pObj->nFanins;                                    } 

int Bbl_ObjFaninNumber

(

Bbl_Obj_t *

p

)

Definition at line 1098 of file bblif.c.

{ return Bbl_ObjFaninNum(p);                  }

int Bbl_ObjFncHandle

(

Bbl_Obj_t *

p

)

Definition at line 1102 of file bblif.c.

{ return p->Fnc;                              }

int Bbl_ObjId

(

Bbl_Obj_t *

p

)

Definition at line 1096 of file bblif.c.

{ return p->Id;                               }

int Bbl_ObjIdOriginal	(	Bbl_Man_t *	pMan,
		Bbl_Obj_t *	p
	)

Definition at line 1097 of file bblif.c.

{ assert(0); return Vec_IntEntry(pMan->vObj2Id, p->Id);  }

static int Bbl_ObjIsCi ( Bbl_Obj_t *  pObj )

inlinestatic

Definition at line 102 of file bblif.c.

{ return pObj->fCi;                                        } 

static int Bbl_ObjIsCo ( Bbl_Obj_t *  pObj )

inlinestatic

Definition at line 103 of file bblif.c.

{ return pObj->fCo;                                        } 

int Bbl_ObjIsInput

(

Bbl_Obj_t *

p

)

Fnction*************************************************************

Synopsis [Misc APIs.]

Description []

SideEffects []

SeeAlso []

Definition at line 1093 of file bblif.c.

{ return Bbl_ObjIsCi(p);                      }

int Bbl_ObjIsLut

(

Bbl_Obj_t *

p

)

Definition at line 1095 of file bblif.c.

{ return Bbl_ObjIsNode(p);                    }

int Bbl_ObjIsMarked

(

Bbl_Obj_t *

p

)

Definition at line 1100 of file bblif.c.

{ return p->fMark;                            }

static int Bbl_ObjIsNode ( Bbl_Obj_t *  pObj )

inlinestatic

Definition at line 104 of file bblif.c.

{ return!pObj->fCi && !pObj->fCo;                          } 

int Bbl_ObjIsOutput

(

Bbl_Obj_t *

p

)

Definition at line 1094 of file bblif.c.

{ return Bbl_ObjIsCo(p);                      }

void Bbl_ObjMark

(

Bbl_Obj_t *

p

)

Definition at line 1101 of file bblif.c.

{ p->fMark = 1;                               }

static int Bbl_ObjSize ( Bbl_Obj_t *  pObj )

inlinestatic

Definition at line 109 of file bblif.c.

{ return sizeof(Bbl_Obj_t) + sizeof(int) * pObj->nFanins;  } 

char* Bbl_ObjSop	(	Bbl_Man_t *	pMan,
		Bbl_Obj_t *	p
	)

Definition at line 1099 of file bblif.c.

{ return Bbl_ManSop(pMan, p->Fnc);            }

static Bbl_Ent_t* Bbl_VecEnt ( Vec_Str_t *  p, int  h  )

inlinestatic

Definition at line 114 of file bblif.c.

{ return (Bbl_Ent_t *)(p->pArray + h);                     } 

static Bbl_Fnc_t* Bbl_VecFnc ( Vec_Str_t *  p, int  h  )

inlinestatic

Definition at line 113 of file bblif.c.

{ return (Bbl_Fnc_t *)(p->pArray + h);                     } 

static Bbl_Obj_t* Bbl_VecObj ( Vec_Str_t *  p, int  h  )

inlinestatic

Definition at line 112 of file bblif.c.

{ return (Bbl_Obj_t *)(p->pArray + h);                     } 

static void Vec_IntAddToEntry ( Vec_Int_t *  p, int  i, int  Addition  )

inlinestatic

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 302 of file bblif.c.

{
    assert( i >= 0 && i < p->nSize );
    p->pArray[i] += Addition;
}

static Vec_Int_t* Vec_IntAlloc ( int  nCap )

inlinestatic

FUNCTION DEFINITIONS ///.

Function*************************************************************

Synopsis [Allocates a vector with the given capacity.]

Description []

SideEffects []

SeeAlso []

Definition at line 149 of file bblif.c.

{
    Vec_Int_t * p;
    p = BBLIF_ALLOC( Vec_Int_t, 1 );
    if ( nCap > 0 && nCap < 16 )
        nCap = 16;
    p->nSize  = 0;
    p->nCap   = nCap;
    p->pArray = p->nCap? BBLIF_ALLOC( int, p->nCap ) : NULL;
    return p;
}

static Vec_Int_t* Vec_IntAllocArray ( int *  pArray, int  nSize  )

inlinestatic

Function*************************************************************

Synopsis [Creates the vector from an integer array of the given size.]

Description []

SideEffects []

SeeAlso []

Definition at line 214 of file bblif.c.

{
    Vec_Int_t * p;
    p = BBLIF_ALLOC( Vec_Int_t, 1 );
    p->nSize  = nSize;
    p->nCap   = nSize;
    p->pArray = pArray;
    return p;
}

static void Vec_IntClear ( Vec_Int_t *  p )

inlinestatic

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 452 of file bblif.c.

{
    p->nSize = 0;
}

static int Vec_IntEntry ( Vec_Int_t *  p, int  i  )

inlinestatic

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 268 of file bblif.c.

{
    assert( i >= 0 && i < p->nSize );
    return p->pArray[i];
}

static int Vec_IntEntryLast ( Vec_Int_t *  p )

inlinestatic

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 319 of file bblif.c.

{
    assert( p->nSize > 0 );
    return p->pArray[p->nSize-1];
}

static void Vec_IntFill ( Vec_Int_t *  p, int  nSize, int  Fill  )

inlinestatic

Function*************************************************************

Synopsis [Fills the vector with given number of entries.]

Description []

SideEffects []

SeeAlso []

Definition at line 356 of file bblif.c.

{
    int i;
    Vec_IntGrow( p, nSize );
    for ( i = 0; i < nSize; i++ )
        p->pArray[i] = Fill;
    p->nSize = nSize;
}

static void Vec_IntFillExtra ( Vec_Int_t *  p, int  nSize, int  Fill  )

inlinestatic

Function*************************************************************

Synopsis [Fills the vector with given number of entries.]

Description []

SideEffects []

SeeAlso []

Definition at line 376 of file bblif.c.

{
    int i;
    if ( p->nSize >= nSize )
        return;
    if ( nSize > 2 * p->nCap )
        Vec_IntGrow( p, nSize );
    else if ( nSize > p->nCap )
        Vec_IntGrow( p, 2 * p->nCap );
    for ( i = p->nSize; i < nSize; i++ )
        p->pArray[i] = Fill;
    p->nSize = nSize;
}

static void Vec_IntFree ( Vec_Int_t *  p )

inlinestatic

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 235 of file bblif.c.

{
    BBLIF_FREE( p->pArray );
    BBLIF_FREE( p );
}

static int Vec_IntGetEntry ( Vec_Int_t *  p, int  i  )

inlinestatic

Function*************************************************************

Synopsis [Returns the entry even if the place not exist.]

Description []

SideEffects []

SeeAlso []

Definition at line 401 of file bblif.c.

{
    Vec_IntFillExtra( p, i + 1, 0 );
    return Vec_IntEntry( p, i );
}

static void Vec_IntGrow ( Vec_Int_t *  p, int  nCapMin  )

inlinestatic

Function*************************************************************

Synopsis [Resizes the vector to the given capacity.]

Description []

SideEffects []

SeeAlso []

Definition at line 336 of file bblif.c.

{
    if ( p->nCap >= nCapMin )
        return;
    p->pArray = BBLIF_REALLOC( int, p->pArray, nCapMin ); 
    assert( p->pArray );
    p->nCap   = nCapMin;
}

static void Vec_IntPush ( Vec_Int_t *  p, int  Entry  )

inlinestatic

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 468 of file bblif.c.

{
    if ( p->nSize == p->nCap )
    {
        if ( p->nCap < 16 )
            Vec_IntGrow( p, 16 );
        else
            Vec_IntGrow( p, 2 * p->nCap );
    }
    p->pArray[p->nSize++] = Entry;
}

static void Vec_IntSetEntry ( Vec_Int_t *  p, int  i, int  Entry  )

inlinestatic

Function*************************************************************

Synopsis [Inserts the entry even if the place does not exist.]

Description []

SideEffects []

SeeAlso []

Definition at line 418 of file bblif.c.

{
    Vec_IntFillExtra( p, i + 1, 0 );
    Vec_IntWriteEntry( p, i, Entry );
}

static void Vec_IntShrink ( Vec_Int_t *  p, int  nSizeNew  )

inlinestatic

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 435 of file bblif.c.

{
    assert( p->nSize >= nSizeNew );
    p->nSize = nSizeNew;
}

static int Vec_IntSize ( Vec_Int_t *  p )

inlinestatic

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 252 of file bblif.c.

{
    return p->nSize;
}

static Vec_Int_t* Vec_IntStart ( int  nSize )

inlinestatic

Function*************************************************************

Synopsis [Allocates a vector with the given size and cleans it.]

Description []

SideEffects []

SeeAlso []

Definition at line 172 of file bblif.c.

{
    Vec_Int_t * p;
    p = Vec_IntAlloc( nSize );
    p->nSize = nSize;
    memset( p->pArray, 0, sizeof(int) * nSize );
    return p;
}

static Vec_Int_t* Vec_IntStartNatural ( int  nSize )

inlinestatic

Function*************************************************************

Synopsis [Allocates a vector with the given size and cleans it.]

Description []

SideEffects []

SeeAlso []

Definition at line 192 of file bblif.c.

{
    Vec_Int_t * p;
    int i;
    p = Vec_IntAlloc( nSize );
    p->nSize = nSize;
    for ( i = 0; i < nSize; i++ )
        p->pArray[i] = i;
    return p;
}

static void Vec_IntWriteEntry ( Vec_Int_t *  p, int  i, int  Entry  )

inlinestatic

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 285 of file bblif.c.

{
    assert( i >= 0 && i < p->nSize );
    p->pArray[i] = Entry;
}

static Vec_Str_t* Vec_StrAlloc ( int  nCap )

inlinestatic

Function*************************************************************

Synopsis [Allocates a vector with the given capacity.]

Description []

SideEffects []

SeeAlso []

Definition at line 495 of file bblif.c.

{
    Vec_Str_t * p;
    p = BBLIF_ALLOC( Vec_Str_t, 1 );
    if ( nCap > 0 && nCap < 16 )
        nCap = 16;
    p->nSize  = 0;
    p->nCap   = nCap;
    p->pArray = p->nCap? BBLIF_ALLOC( char, p->nCap ) : NULL;
    return p;
}

static Vec_Str_t* Vec_StrAllocArray ( char *  pArray, int  nSize  )

inlinestatic

Function*************************************************************

Synopsis [Creates the vector from an array of the given size.]

Description []

SideEffects []

SeeAlso []

Definition at line 518 of file bblif.c.

{
    Vec_Str_t * p;
    p = BBLIF_ALLOC( Vec_Str_t, 1 );
    p->nSize  = nSize;
    p->nCap   = nSize;
    p->pArray = pArray;
    return p;
}

char* Vec_StrFetch	(	Vec_Str_t *	p,
		int	nBytes
	)

Fnction*************************************************************

Synopsis [Returns a piece of memory.]

Description []

SideEffects []

SeeAlso []

Definition at line 539 of file bblif.c.

{
    while ( p->nSize + nBytes > p->nCap )
    {
        p->pArray = BBLIF_REALLOC( char, p->pArray, 3 * p->nCap );
        p->nCap *= 3;
    }
    p->nSize += nBytes;
    return p->pArray + p->nSize - nBytes;
}

static void Vec_StrFree ( Vec_Str_t *  p )

inlinestatic

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 616 of file bblif.c.

{
    BBLIF_FREE( p->pArray );
    BBLIF_FREE( p );
}

Vec_Str_t* Vec_StrRead

(

char **

ppStr

)

Fnction*************************************************************

Synopsis [Write vector into file.]

Description []

SideEffects []

SeeAlso []

Definition at line 578 of file bblif.c.

{
    Vec_Str_t * p;
    char * pStr = *ppStr;
    p = Vec_StrAlloc( 0 );
    p->nSize = *(int *)pStr;
    p->pArray = pStr + sizeof(int);
    *ppStr = pStr + sizeof(int) + p->nSize * sizeof(char);
    return p;
}

static int Vec_StrSize ( Vec_Str_t *  p )

inlinestatic

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 600 of file bblif.c.

{
    return p->nSize;
}

void Vec_StrWrite	(	FILE *	pFile,
		Vec_Str_t *	p
	)

Fnction*************************************************************

Synopsis [Write vector into file.]

Description []

SideEffects []

SeeAlso []

Definition at line 561 of file bblif.c.

{
    fwrite( &p->nSize, sizeof(int), 1, pFile );
    fwrite( p->pArray, sizeof(char), p->nSize, pFile );
}