amapLiberty.c File Reference

#include "amapInt.h"

Go to the source code of this file.

Data Structures
struct	Amap_Pair_t_
struct	Amap_Item_t_
struct	Amap_Tree_t_

Macros
#define	ABC_MAX_LIB_STR_LEN   5000
	DECLARATIONS ///. More...
#define	Amap_ItemForEachChild(p, pItem, pChild)   for ( pChild = Amap_LibertyItem(p, pItem->Child); pChild; pChild = Amap_LibertyItem(p, pChild->Next) )

Typedefs
typedef struct Amap_Pair_t_	Amap_Pair_t
typedef struct Amap_Item_t_	Amap_Item_t
typedef struct Amap_Tree_t_	Amap_Tree_t

Enumerations
enum	Amap_LibertyType_t { AMAP_LIBERTY_NONE = 0, AMAP_LIBERTY_PROC, AMAP_LIBERTY_EQUA, AMAP_LIBERTY_LIST }

Functions
static Amap_Item_t *	Amap_LibertyRoot (Amap_Tree_t *p)
static Amap_Item_t *	Amap_LibertyItem (Amap_Tree_t *p, int v)
static int	Amap_LibertyCompare (Amap_Tree_t *p, Amap_Pair_t Pair, char *pStr)
static void	Amap_PrintWord (FILE *pFile, Amap_Tree_t *p, Amap_Pair_t Pair)
static void	Amap_PrintSpace (FILE *pFile, int nOffset)
static int	Amap_LibertyItemId (Amap_Tree_t *p, Amap_Item_t *pItem)
void	Amap_LibertyPrintLibertyItem (FILE *pFile, Amap_Tree_t *p, Amap_Item_t *pItem, int nOffset)
	FUNCTION DEFINITIONS ///. More...
int	Amap_LibertyPrintLiberty (Amap_Tree_t *p, char *pFileName)
char *	Amap_LibertyTimeStamp ()
int	Amap_LibertyCellIsFlop (Amap_Tree_t *p, Amap_Item_t *pCell)
Amap_Item_t *	Amap_LibertyPinFunction (Amap_Tree_t *p, Amap_Item_t *pPin)
Amap_Item_t *	Amap_LibertyCellOutput (Amap_Tree_t *p, Amap_Item_t *pCell)
Vec_Ptr_t *	Amap_LibertyCellOutputs (Amap_Tree_t *p, Amap_Item_t *pCell)
Amap_Item_t *	Amap_LibertyCellArea (Amap_Tree_t *p, Amap_Item_t *pCell)
int	Amap_LibertyCellCountOutputs (Amap_Tree_t *p, Amap_Item_t *pCell)
char *	Amap_LibertyGetString (Amap_Tree_t *p, Amap_Pair_t Pair)
char *	Amap_LibertyGetStringFormula (Amap_Tree_t *p, Amap_Pair_t Pair)
int	Amap_LibertyPrintGenlib (Amap_Tree_t *p, char *pFileName, int fVerbose)
Vec_Str_t *	Amap_LibertyPrintGenlibStr (Amap_Tree_t *p, int fVerbose)
int	Amap_LibertyFileSize (char *pFileName)
void	Amap_LibertyFixFileHead (char *pFileName)
int	Amap_LibertyCountItems (char *pBeg, char *pEnd)
void	Amap_LibertyWipeOutComments (char *pBeg, char *pEnd)
static int	Amap_LibertyCharIsSpace (char c)
static int	Amap_LibertySkipSpaces (Amap_Tree_t *p, char **ppPos, char *pEnd, int fStopAtNewLine)
static int	Amap_LibertySkipEntry (char **ppPos, char *pEnd)
static char *	Amap_LibertyFindMatch (char *pPos, char *pEnd)
static Amap_Pair_t	Amap_LibertyUpdateHead (Amap_Tree_t *p, Amap_Pair_t Head)
static Amap_Item_t *	Amap_LibertyNewItem (Amap_Tree_t *p, int Type)
int	Amap_LibertyBuildItem (Amap_Tree_t *p, char **ppPos, char *pEnd)
Amap_Tree_t *	Amap_LibertyStart (char *pFileName)
void	Amap_LibertyStop (Amap_Tree_t *p)
int	Amap_LibertyParse (char *pFileName, int fVerbose)
Vec_Str_t *	Amap_LibertyParseStr (char *pFileName, int fVerbose)

Macro Definition Documentation

#define ABC_MAX_LIB_STR_LEN   5000

DECLARATIONS ///.

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

FileHead [amapLiberty.c]

SystemHead [ABC: Logic synthesis and verification system.]

PackageHead [Technology mapper for standard cells.]

Synopsis [Liberty parser.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - June 20, 2005.]

Revision [

Id:

amapLiberty.c,v 1.00 2005/06/20 00:00:00 alanmi Exp

]

Definition at line 30 of file amapLiberty.c.

#define Amap_ItemForEachChild	(		p,
			pItem,
			pChild
	)		for ( pChild = Amap_LibertyItem(p, pItem->Child); pChild; pChild = Amap_LibertyItem(p, pChild->Next) )

Definition at line 79 of file amapLiberty.c.

Typedef Documentation

typedef struct Amap_Item_t_ Amap_Item_t

Definition at line 47 of file amapLiberty.c.

typedef struct Amap_Pair_t_ Amap_Pair_t

Definition at line 40 of file amapLiberty.c.

typedef struct Amap_Tree_t_ Amap_Tree_t

Definition at line 59 of file amapLiberty.c.

Enumeration Type Documentation

enum Amap_LibertyType_t

Enumerator
AMAP_LIBERTY_NONE
AMAP_LIBERTY_PROC
AMAP_LIBERTY_EQUA
AMAP_LIBERTY_LIST

Definition at line 33 of file amapLiberty.c.

             { 
    AMAP_LIBERTY_NONE = 0,        // 0:  unknown
    AMAP_LIBERTY_PROC,            // 1:  procedure :  key(head){body}
    AMAP_LIBERTY_EQUA,            // 2:  equation  :  key:head;
    AMAP_LIBERTY_LIST             // 3:  list      :  key(head) 
} Amap_LibertyType_t;

Function Documentation

int Amap_LibertyBuildItem	(	Amap_Tree_t *	p,
		char **	ppPos,
		char *	pEnd
	)

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

Synopsis [Returns free item.]

Description []

SideEffects []

SeeAlso []

Definition at line 845 of file amapLiberty.c.

{
    Amap_Item_t * pItem;
    Amap_Pair_t Key, Head, Body;
    char * pNext, * pStop;
    Key.End = 0;
    if ( Amap_LibertySkipSpaces( p, ppPos, pEnd, 0 ) )
        return -2;
    Key.Beg = *ppPos - p->pContents;
    if ( Amap_LibertySkipEntry( ppPos, pEnd ) )
        goto exit;
    Key.End = *ppPos - p->pContents;
    if ( Amap_LibertySkipSpaces( p, ppPos, pEnd, 0 ) )
        goto exit;
    pNext = *ppPos;
    if ( *pNext == ':' )
    {
        *ppPos = pNext + 1;
        if ( Amap_LibertySkipSpaces( p, ppPos, pEnd, 0 ) )
            goto exit;
        Head.Beg = *ppPos - p->pContents;
        if ( Amap_LibertySkipEntry( ppPos, pEnd ) )
            goto exit;
        Head.End = *ppPos - p->pContents;
        if ( Amap_LibertySkipSpaces( p, ppPos, pEnd, 1 ) )
            goto exit;
        pNext = *ppPos;
        if ( *pNext != ';' && *pNext != '\n' )
            goto exit;
        *ppPos = pNext + 1;
        // end of equation
        pItem = Amap_LibertyNewItem( p, AMAP_LIBERTY_EQUA );
        pItem->Key  = Key;
        pItem->Head = Amap_LibertyUpdateHead( p, Head );
        pItem->Next = Amap_LibertyBuildItem( p, ppPos, pEnd );
        if ( pItem->Next == -1 )
            goto exit;
        return Amap_LibertyItemId( p, pItem );
    }
    if ( *pNext == '(' )
    {
        pStop = Amap_LibertyFindMatch( pNext, pEnd );
        Head.Beg = pNext - p->pContents + 1;
        Head.End = pStop - p->pContents;
        *ppPos = pStop + 1;
        if ( Amap_LibertySkipSpaces( p, ppPos, pEnd, 0 ) )
        {
            // end of list
            pItem = Amap_LibertyNewItem( p, AMAP_LIBERTY_LIST );
            pItem->Key  = Key;
            pItem->Head = Amap_LibertyUpdateHead( p, Head );
            return Amap_LibertyItemId( p, pItem );
        }
        pNext = *ppPos;
        if ( *pNext == '{' ) // beginning of body
        {
            pStop = Amap_LibertyFindMatch( pNext, pEnd );
            Body.Beg = pNext - p->pContents + 1;
            Body.End = pStop - p->pContents;
            // end of body
            pItem = Amap_LibertyNewItem( p, AMAP_LIBERTY_PROC );
            pItem->Key  = Key;
            pItem->Head = Amap_LibertyUpdateHead( p, Head );
            pItem->Body = Body;
            *ppPos = pNext + 1;
            pItem->Child = Amap_LibertyBuildItem( p, ppPos, pStop );
            if ( pItem->Child == -1 )
                goto exit;
            *ppPos = pStop + 1;
            pItem->Next = Amap_LibertyBuildItem( p, ppPos, pEnd );
            if ( pItem->Next == -1 )
                goto exit;
            return Amap_LibertyItemId( p, pItem );
        }
        // end of list
        if ( *pNext == ';' )
            *ppPos = pNext + 1;
        pItem = Amap_LibertyNewItem( p, AMAP_LIBERTY_LIST );
        pItem->Key  = Key;
        pItem->Head = Amap_LibertyUpdateHead( p, Head );
        pItem->Next = Amap_LibertyBuildItem( p, ppPos, pEnd );
        if ( pItem->Next == -1 )
            goto exit;
        return Amap_LibertyItemId( p, pItem );
    }
exit:
    if ( p->pError == NULL )
    {
        p->pError = ABC_ALLOC( char, 1000 );
        sprintf( p->pError, "File \"%s\". Line %6d. Failed to parse entry \"%s\".\n", 
            p->pFileName, p->nLines, Amap_LibertyGetString(p, Key) );
    }
    return -1;
}

Amap_Item_t* Amap_LibertyCellArea	(	Amap_Tree_t *	p,
		Amap_Item_t *	pCell
	)

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

Synopsis [Returns cell's area.]

Description []

SideEffects []

SeeAlso []

Definition at line 279 of file amapLiberty.c.

{
    Amap_Item_t * pArea;
    Amap_ItemForEachChild( p, pCell, pArea )
    {
        if ( Amap_LibertyCompare(p, pArea->Key, "area") )
            continue;
        return pArea;
    }
    return NULL;
}

int Amap_LibertyCellCountOutputs	(	Amap_Tree_t *	p,
		Amap_Item_t *	pCell
	)

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

Synopsis [Count cell's output pins (pins with a logic function).]

Description []

SideEffects []

SeeAlso []

Definition at line 302 of file amapLiberty.c.

{
    Amap_Item_t * pPin;
    int Counter = 0;
    Amap_ItemForEachChild( p, pCell, pPin )
    {
        if ( Amap_LibertyCompare(p, pPin->Key, "pin") )
            continue;
        if ( Amap_LibertyPinFunction(p, pPin) )
            Counter++;
    }
    return Counter;
}

int Amap_LibertyCellIsFlop	(	Amap_Tree_t *	p,
		Amap_Item_t *	pCell
	)

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

Synopsis [Returns cell's function.]

Description []

SideEffects []

SeeAlso []

Definition at line 200 of file amapLiberty.c.

{
    Amap_Item_t * pAttr;
    Amap_ItemForEachChild( p, pCell, pAttr )
        if ( !Amap_LibertyCompare(p, pAttr->Key, "ff") ||
             !Amap_LibertyCompare(p, pAttr->Key, "latch") )
            return 1;
    return 0;
}

Amap_Item_t* Amap_LibertyCellOutput	(	Amap_Tree_t *	p,
		Amap_Item_t *	pCell
	)

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

Synopsis [Returns output pin(s).]

Description []

SideEffects []

SeeAlso []

Definition at line 241 of file amapLiberty.c.

{
    Amap_Item_t * pPin;
    Amap_ItemForEachChild( p, pCell, pPin )
    {
        if ( Amap_LibertyCompare(p, pPin->Key, "pin") )
            continue;
        if ( Amap_LibertyPinFunction(p, pPin) )
            return pPin;
    }
    return NULL;
}

Vec_Ptr_t* Amap_LibertyCellOutputs	(	Amap_Tree_t *	p,
		Amap_Item_t *	pCell
	)

Definition at line 253 of file amapLiberty.c.

{
    Amap_Item_t * pPin;
    Vec_Ptr_t * vOutPins;
    vOutPins = Vec_PtrAlloc( 2 );
    Amap_ItemForEachChild( p, pCell, pPin )
    {
        if ( Amap_LibertyCompare(p, pPin->Key, "pin") )
            continue;
        if ( Amap_LibertyPinFunction(p, pPin) )
            Vec_PtrPush( vOutPins, pPin );
    }
    return vOutPins;
}

static int Amap_LibertyCharIsSpace ( char  c )

inlinestatic

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

Synopsis [Returns 1 if the character is space.]

Description []

SideEffects []

SeeAlso []

Definition at line 664 of file amapLiberty.c.

{
    return c == ' ' || c == '\t' || c == '\r' || c == '\n' || c == '\\';
}

static int Amap_LibertyCompare ( Amap_Tree_t *  p, Amap_Pair_t  Pair, char *  pStr  )

inlinestatic

Definition at line 74 of file amapLiberty.c.

{ return strncmp( p->pContents+Pair.Beg, pStr, Pair.End-Pair.Beg ); }

int Amap_LibertyCountItems	(	char *	pBeg,
		char *	pEnd
	)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 620 of file amapLiberty.c.

{
    int Counter = 0;
    for ( ; pBeg < pEnd; pBeg++ )
        Counter += (*pBeg == '(' || *pBeg == ':');
    return Counter;
}

int Amap_LibertyFileSize

(

char *

pFileName

)

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

Synopsis [Returns the file size.]

Description [The file should be closed.]

SideEffects []

SeeAlso []

Definition at line 574 of file amapLiberty.c.

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

static char* Amap_LibertyFindMatch ( char *  pPos, char *  pEnd  )

inlinestatic

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

Synopsis [Find the matching closing symbol.]

Description []

SideEffects []

SeeAlso []

Definition at line 745 of file amapLiberty.c.

{
    int Counter = 0;
    assert( *pPos == '(' || *pPos == '{' );
    if ( *pPos == '(' )
    {
        for ( ; pPos < pEnd; pPos++ )
        {
            if ( *pPos == '(' )
                Counter++;
            if ( *pPos == ')' )
                Counter--;
            if ( Counter == 0 )
                break;
        }
    }
    else
    {
        for ( ; pPos < pEnd; pPos++ )
        {
            if ( *pPos == '{' )
                Counter++;
            if ( *pPos == '}' )
                Counter--;
            if ( Counter == 0 )
                break;
        }
    }
    assert( *pPos == ')' || *pPos == '}' );
    return pPos;
}

void Amap_LibertyFixFileHead

(

char *

pFileName

)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 601 of file amapLiberty.c.

{
    char * pHead;
    for ( pHead = pFileName; *pHead; pHead++ )
        if ( *pHead == '>' )
            *pHead = '\\';
}

char* Amap_LibertyGetString	(	Amap_Tree_t *	p,
		Amap_Pair_t	Pair
	)

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

Synopsis [Gets the name to write.]

Description []

SideEffects []

SeeAlso []

Definition at line 327 of file amapLiberty.c.

{ 
    static char Buffer[ABC_MAX_LIB_STR_LEN]; 
    assert( Pair.End-Pair.Beg < ABC_MAX_LIB_STR_LEN );
    strncpy( Buffer, p->pContents+Pair.Beg, Pair.End-Pair.Beg ); 
    Buffer[Pair.End-Pair.Beg] = 0;
    return Buffer;
}

char* Amap_LibertyGetStringFormula	(	Amap_Tree_t *	p,
		Amap_Pair_t	Pair
	)

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

Synopsis [Gets the name to write.]

Description []

SideEffects []

SeeAlso []

Definition at line 347 of file amapLiberty.c.

{ 
    static char Buffer[ABC_MAX_LIB_STR_LEN]; 
    assert( Pair.End-Pair.Beg-2 < ABC_MAX_LIB_STR_LEN );
    strncpy( Buffer, p->pContents+Pair.Beg+1, Pair.End-Pair.Beg-2 ); 
    Buffer[Pair.End-Pair.Beg-2] = 0;
    return Buffer;
}

static Amap_Item_t* Amap_LibertyItem ( Amap_Tree_t *  p, int  v  )

inlinestatic

Definition at line 73 of file amapLiberty.c.

{ assert( v < p->nItems ); return v < 0 ? NULL : p->pItems + v;     }

static int Amap_LibertyItemId ( Amap_Tree_t *  p, Amap_Item_t *  pItem  )

inlinestatic

Definition at line 77 of file amapLiberty.c.

{ return pItem - p->pItems;                                         }

static Amap_Item_t* Amap_LibertyNewItem ( Amap_Tree_t *  p, int  Type  )

inlinestatic

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

Synopsis [Returns free item.]

Description []

SideEffects []

SeeAlso []

Definition at line 825 of file amapLiberty.c.

{
    p->pItems[p->nItems].iLine = p->nLines;
    p->pItems[p->nItems].Type  = Type;
    p->pItems[p->nItems].Child = -1;
    p->pItems[p->nItems].Next  = -1;
    return p->pItems + p->nItems++;
}

int Amap_LibertyParse	(	char *	pFileName,
		int	fVerbose
	)

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

Synopsis [Parses the standard cell library in Liberty format.]

Description [Writes the resulting file in Genlib format.]

SideEffects []

SeeAlso []

Definition at line 1012 of file amapLiberty.c.

{
    Amap_Tree_t * p;
    char * pPos;
    abctime clk = Abc_Clock();
    int RetValue;
    p = Amap_LibertyStart( pFileName );
    if ( p == NULL )
        return 0;
    pPos = p->pContents;
    Amap_LibertyWipeOutComments( p->pContents, p->pContents+p->nContents );
    if ( Amap_LibertyBuildItem( p, &pPos, p->pContents + p->nContents ) == 0 )
    {
        if ( fVerbose )
        printf( "Parsing finished successfully.\n" );
//        Amap_LibertyPrintLiberty( p, "temp_.lib" );
        Amap_LibertyPrintGenlib( p, Extra_FileNameGenericAppend(pFileName, ".genlib"), fVerbose );
        RetValue = 1;
    }
    else
    {
        if ( p->pError )
            printf( "%s", p->pError );
        if ( fVerbose )
        printf( "Parsing failed.\n" );
        RetValue = 0;
    }
    if ( fVerbose )
    {
    printf( "Memory = %7.2f MB. ", 1.0*(p->nContents+p->nItermAlloc*sizeof(Amap_Item_t))/(1<<20) );
    ABC_PRT( "Time", Abc_Clock() - clk );
    }
    Amap_LibertyStop( p );
    return RetValue;
}

Vec_Str_t* Amap_LibertyParseStr	(	char *	pFileName,
		int	fVerbose
	)

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

Synopsis [Parses the standard cell library in Liberty format.]

Description [Writes the resulting file in Genlib format.]

SideEffects []

SeeAlso []

Definition at line 1059 of file amapLiberty.c.

{
    Amap_Tree_t * p;
    Vec_Str_t * vStr = NULL;
    char * pPos;
    abctime clk = Abc_Clock();
    int RetValue;
    p = Amap_LibertyStart( pFileName );
    if ( p == NULL )
        return 0;
    pPos = p->pContents;
    Amap_LibertyWipeOutComments( p->pContents, p->pContents+p->nContents );
    if ( Amap_LibertyBuildItem( p, &pPos, p->pContents + p->nContents ) == 0 )
    {
        if ( fVerbose )
        printf( "Parsing finished successfully.\n" );
//        Amap_LibertyPrintLiberty( p, "temp_.lib" );
        vStr = Amap_LibertyPrintGenlibStr( p, fVerbose );
        RetValue = 1;
    }
    else
    {
        if ( p->pError )
            printf( "%s", p->pError );
        if ( fVerbose )
        printf( "Parsing failed.\n" );
        RetValue = 0;
    }
    if ( fVerbose )
    {
    printf( "Memory = %7.2f MB. ", 1.0*(p->nContents+p->nItermAlloc*sizeof(Amap_Item_t))/(1<<20) );
    ABC_PRT( "Time", Abc_Clock() - clk );
    }
    Amap_LibertyStop( p );
    return vStr;
}

Amap_Item_t* Amap_LibertyPinFunction	(	Amap_Tree_t *	p,
		Amap_Item_t *	pPin
	)

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

Synopsis [Returns pin's function.]

Description []

SideEffects []

SeeAlso []

Definition at line 221 of file amapLiberty.c.

{
    Amap_Item_t * pFunc;
    Amap_ItemForEachChild( p, pPin, pFunc )
        if ( !Amap_LibertyCompare(p, pFunc->Key, "function") )
            return pFunc;
    return NULL;
}

int Amap_LibertyPrintGenlib	(	Amap_Tree_t *	p,
		char *	pFileName,
		int	fVerbose
	)

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

Synopsis [Prints parse tree in Genlib format.]

Description []

SideEffects []

SeeAlso []

Definition at line 367 of file amapLiberty.c.

{
    FILE * pFile;
    Vec_Ptr_t * vOutputs;
    Amap_Item_t * pCell, * pArea, * pFunc, * pPin, * pOutput;
    char * pForm;
    int i, Counter;
    if ( pFileName == NULL )
        pFile = stdout;
    else
    {
        pFile = fopen( pFileName, "w" );
        if ( pFile == NULL )
        {
            printf( "Amap_LibertyPrintGenlib(): The output file is unavailable (absent or open).\n" );
            return 0;
        }
    }
    fprintf( pFile, "# This Genlib file was generated by ABC on %s\n", Amap_LibertyTimeStamp() );
    fprintf( pFile, "# The standard cell library \"%s\" is from Liberty file \"%s\"\n", Amap_LibertyGetString(p, Amap_LibertyRoot(p)->Head), p->pFileName );
    fprintf( pFile, "# (To find out more about Genlib format, google for \"sis_paper.ps\")\n" );

    fprintf( pFile, "GATE  " );
    fprintf( pFile, "%16s  ", "_const0_" );
    fprintf( pFile, "%f  ",   0.0 );
    fprintf( pFile, "%s=",    "z" );
    fprintf( pFile, "%s;\n",  "CONST0" );

    fprintf( pFile, "GATE  " );
    fprintf( pFile, "%16s  ", "_const1_" );
    fprintf( pFile, "%f  ",   0.0 );
    fprintf( pFile, "%s=",    "z" );
    fprintf( pFile, "%s;\n",  "CONST1" );

    Amap_ItemForEachChild( p, Amap_LibertyRoot(p), pCell )
    {
/*
    if ( strcmp(Amap_LibertyGetString(p, pCell->Head), "HA1SVTX1") == 0 )
    {
        int s = 0;
    }
*/
        if ( Amap_LibertyCompare(p, pCell->Key, "cell") )
            continue;
        if ( Amap_LibertyCellIsFlop(p, pCell) )
        {
            if ( fVerbose )
                printf( "Amap_LibertyPrintGenlib() skipped sequential cell \"%s\".\n", Amap_LibertyGetString(p, pCell->Head) );
            continue;
        }
        Counter = Amap_LibertyCellCountOutputs( p, pCell );
        if ( Counter == 0 )
        {
            if ( fVerbose )
                printf( "Amap_LibertyPrintGenlib() skipped cell \"%s\" without logic function.\n", Amap_LibertyGetString(p, pCell->Head) );
            continue;
        }
/*
        if ( Counter > 1 )
        {
            if ( fVerbose )
                printf( "Amap_LibertyPrintGenlib() skipped multi-output cell \"%s\".\n", Amap_LibertyGetString(p, pCell->Head) );
            continue;
        }
*/
        pArea = Amap_LibertyCellArea( p, pCell );
        if ( pArea == NULL )
        {
            if ( fVerbose )
                printf( "Amap_LibertyPrintGenlib() skipped cell \"%s\" with unspecified area.\n", Amap_LibertyGetString(p, pCell->Head) );
            continue;
        }
//        pOutput = Amap_LibertyCellOutput( p, pCell );
        vOutputs = Amap_LibertyCellOutputs( p, pCell );
        Vec_PtrForEachEntry( Amap_Item_t *, vOutputs, pOutput, i )
        {
            pFunc   = Amap_LibertyPinFunction( p, pOutput );
            pForm   = Amap_LibertyGetStringFormula( p, pFunc->Head );
            if ( !strcmp(pForm, "0") || !strcmp(pForm, "1") )
            {
                if ( fVerbose )
                    printf( "Amap_LibertyPrintGenlib() skipped cell \"%s\" with constant formula \"%s\".\n", Amap_LibertyGetString(p, pCell->Head), pForm );
                continue;
            }
            fprintf( pFile, "GATE  " );
            fprintf( pFile, "%16s  ", Amap_LibertyGetString(p, pCell->Head) );
            fprintf( pFile, "%f  ",   atof(Amap_LibertyGetString(p, pArea->Head)) );
            fprintf( pFile, "%s=",    Amap_LibertyGetString(p, pOutput->Head) );
            fprintf( pFile, "%s;\n",  Amap_LibertyGetStringFormula(p, pFunc->Head) );
            Amap_ItemForEachChild( p, pCell, pPin )
                if ( Vec_PtrFind(vOutputs, pPin) == -1 && !Amap_LibertyCompare(p, pPin->Key, "pin") )
                    fprintf( pFile, "    PIN  %13s  UNKNOWN  1  999  1.00  0.00  1.00  0.00\n", Amap_LibertyGetString(p, pPin->Head) );
        }
        Vec_PtrFree( vOutputs );
    }
    if ( pFile != stdout )
        fclose( pFile );
    return 1;
}

Vec_Str_t* Amap_LibertyPrintGenlibStr	(	Amap_Tree_t *	p,
		int	fVerbose
	)

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

Synopsis [Prints parse tree in Genlib format.]

Description []

SideEffects []

SeeAlso []

Definition at line 478 of file amapLiberty.c.

{
    Vec_Str_t * vStr;
    char Buffer[100];
    Vec_Ptr_t * vOutputs;
    Amap_Item_t * pCell, * pArea, * pFunc, * pPin, * pOutput;
    int i, Counter;
    char * pForm;

    vStr = Vec_StrAlloc( 1000 );

    Vec_StrPrintStr( vStr, "GATE          _const0_  0.000000  z=CONST0;\n" );
    Vec_StrPrintStr( vStr, "GATE          _const1_  0.000000  z=CONST1;\n" );
    Amap_ItemForEachChild( p, Amap_LibertyRoot(p), pCell )
    {
        if ( Amap_LibertyCompare(p, pCell->Key, "cell") )
            continue;
        if ( Amap_LibertyCellIsFlop(p, pCell) )
        {
            if ( fVerbose )
                printf( "Amap_LibertyPrintGenlib() skipped sequential cell \"%s\".\n", Amap_LibertyGetString(p, pCell->Head) );
            continue;
        }
        Counter = Amap_LibertyCellCountOutputs( p, pCell );
        if ( Counter == 0 )
        {
            if ( fVerbose )
                printf( "Amap_LibertyPrintGenlib() skipped cell \"%s\" without logic function.\n", Amap_LibertyGetString(p, pCell->Head) );
            continue;
        }
        pArea = Amap_LibertyCellArea( p, pCell );
        if ( pArea == NULL )
        {
            if ( fVerbose )
                printf( "Amap_LibertyPrintGenlib() skipped cell \"%s\" with unspecified area.\n", Amap_LibertyGetString(p, pCell->Head) );
            continue;
        }
        vOutputs = Amap_LibertyCellOutputs( p, pCell );
        Vec_PtrForEachEntry( Amap_Item_t *, vOutputs, pOutput, i )
        {
            pFunc   = Amap_LibertyPinFunction( p, pOutput );
            pForm   = Amap_LibertyGetStringFormula( p, pFunc->Head );
            if ( !strcmp(pForm, "0") || !strcmp(pForm, "1") )
            {
                if ( fVerbose )
                    printf( "Amap_LibertyPrintGenlib() skipped cell \"%s\" with constant formula \"%s\".\n", Amap_LibertyGetString(p, pCell->Head), pForm );
                continue;
            }
/*
            fprintf( pFile, "GATE  " );
            fprintf( pFile, "%16s  ", Amap_LibertyGetString(p, pCell->Head) );
            fprintf( pFile, "%f  ",   atof(Amap_LibertyGetString(p, pArea->Head)) );
            fprintf( pFile, "%s=",    Amap_LibertyGetString(p, pOutput->Head) );
            fprintf( pFile, "%s;\n",  Amap_LibertyGetStringFormula(p, pFunc->Head) );
            Amap_ItemForEachChild( p, pCell, pPin )
                if ( Vec_PtrFind(vOutputs, pPin) == -1 && !Amap_LibertyCompare(p, pPin->Key, "pin") )
                    fprintf( pFile, "    PIN  %13s  UNKNOWN  1  999  1.00  0.00  1.00  0.00\n", Amap_LibertyGetString(p, pPin->Head) );
*/
            Vec_StrPrintStr( vStr, "GATE " );
            Vec_StrPrintStr( vStr, Amap_LibertyGetString(p, pCell->Head) );
            Vec_StrPrintStr( vStr, " " );
            sprintf( Buffer, "%f", atof(Amap_LibertyGetString(p, pArea->Head)) );
            Vec_StrPrintStr( vStr, Buffer );
            Vec_StrPrintStr( vStr, " " );
            Vec_StrPrintStr( vStr, Amap_LibertyGetString(p, pOutput->Head) );
            Vec_StrPrintStr( vStr, "=" );
            Vec_StrPrintStr( vStr, Amap_LibertyGetStringFormula(p, pFunc->Head) );
            Vec_StrPrintStr( vStr, ";\n" );
            Amap_ItemForEachChild( p, pCell, pPin )
                if ( Vec_PtrFind(vOutputs, pPin) == -1 && !Amap_LibertyCompare(p, pPin->Key, "pin") )
                {
                    Vec_StrPrintStr( vStr, "  PIN " );
                    Vec_StrPrintStr( vStr, Amap_LibertyGetString(p, pPin->Head) );
                    Vec_StrPrintStr( vStr, " UNKNOWN  1  999  1.00  0.00  1.00  0.00\n" );
                }
        }
        Vec_PtrFree( vOutputs );
    }
    Vec_StrPrintStr( vStr, "\n.end\n" );
    Vec_StrPush( vStr, '\0' );
//    printf( "%s", Vec_StrArray(vStr) );
    return vStr;
}

int Amap_LibertyPrintLiberty	(	Amap_Tree_t *	p,
		char *	pFileName
	)

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

Synopsis [Prints parse tree in Liberty format.]

Description []

SideEffects []

SeeAlso []

Definition at line 143 of file amapLiberty.c.

{
    FILE * pFile;
    if ( pFileName == NULL )
        pFile = stdout;
    else
    {
        pFile = fopen( pFileName, "w" );
        if ( pFile == NULL )
        {
            printf( "Amap_LibertyPrintLiberty(): The output file is unavailable (absent or open).\n" );
            return 0;
        }
    }
    Amap_LibertyPrintLibertyItem( pFile, p, Amap_LibertyRoot(p), 0 );
    if ( pFile != stdout )
        fclose( pFile );
    return 1;
}

void Amap_LibertyPrintLibertyItem	(	FILE *	pFile,
		Amap_Tree_t *	p,
		Amap_Item_t *	pItem,
		int	nOffset
	)

FUNCTION DEFINITIONS ///.

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

Synopsis [Prints parse tree in Liberty format.]

Description []

SideEffects []

SeeAlso []

Definition at line 97 of file amapLiberty.c.

{
    if ( pItem->Type == AMAP_LIBERTY_PROC )
    {
        Amap_PrintSpace( pFile, nOffset );
        Amap_PrintWord( pFile, p, pItem->Key );
        fprintf( pFile, "(" );
        Amap_PrintWord( pFile, p, pItem->Head );
        fprintf( pFile, ") {\n" );
        if ( Amap_LibertyItem(p, pItem->Child) )
            Amap_LibertyPrintLibertyItem( pFile, p, Amap_LibertyItem(p, pItem->Child), nOffset + 1 );
        Amap_PrintSpace( pFile, nOffset );
        fprintf( pFile, "}\n" );
    }
    else if ( pItem->Type == AMAP_LIBERTY_EQUA )
    {
        Amap_PrintSpace( pFile, nOffset );
        Amap_PrintWord( pFile, p, pItem->Key );
        fprintf( pFile, " : " );
        Amap_PrintWord( pFile, p, pItem->Head );
        fprintf( pFile, ";\n" );
    }
    else if ( pItem->Type == AMAP_LIBERTY_LIST )
    {
        Amap_PrintSpace( pFile, nOffset );
        Amap_PrintWord( pFile, p, pItem->Key );
        fprintf( pFile, "(" );
        Amap_PrintWord( pFile, p, pItem->Head );
        fprintf( pFile, ");\n" );
    }
    else assert( 0 );
    if ( Amap_LibertyItem(p, pItem->Next) )
        Amap_LibertyPrintLibertyItem( pFile, p, Amap_LibertyItem(p, pItem->Next), nOffset );
}

static Amap_Item_t* Amap_LibertyRoot ( Amap_Tree_t *  p )

inlinestatic

Definition at line 72 of file amapLiberty.c.

{ return p->pItems;                                                 }

static int Amap_LibertySkipEntry ( char **  ppPos, char *  pEnd  )

inlinestatic

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

Synopsis [Skips entry delimited by " :;(){}" ]

Description [Returns 1 if reached the end.]

SideEffects []

SeeAlso []

Definition at line 709 of file amapLiberty.c.

{
    char * pPos = *ppPos;
    if ( *pPos == '\"' )
    {
        for ( pPos++; pPos < pEnd; pPos++ )
            if ( *pPos == '\"' )
            {
                pPos++;
                break;
            }
    }
    else
    {
        for ( ; pPos < pEnd; pPos++ )
            if ( *pPos == ' ' || *pPos == '\r' || *pPos == '\n' || *pPos == '\t' ||
                 *pPos == ':' || *pPos == ';'  || 
                 *pPos == '(' || *pPos == ')'  || 
                 *pPos == '{' || *pPos == '}' )
                break;
    }
    *ppPos = pPos;
    return pPos == pEnd;
}

static int Amap_LibertySkipSpaces ( Amap_Tree_t *  p, char **  ppPos, char *  pEnd, int  fStopAtNewLine  )

inlinestatic

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

Synopsis [Skips spaces.]

Description [Returns 1 if reached the end.]

SideEffects []

SeeAlso []

Definition at line 680 of file amapLiberty.c.

{
    char * pPos = *ppPos;
    for ( ; pPos < pEnd; pPos++ )
    {
        if ( *pPos == '\n' )
        {
            p->nLines++;
            if ( fStopAtNewLine )
                break;
        }        
        if ( !Amap_LibertyCharIsSpace(*pPos) )
            break;
    }
    *ppPos = pPos;
    return pPos == pEnd;
}

Amap_Tree_t* Amap_LibertyStart

(

char *

pFileName

)

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

Synopsis [Starts the parsing manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 951 of file amapLiberty.c.

{
    FILE * pFile;
    Amap_Tree_t * p;
    int RetValue;
    // start the manager
    p = ABC_ALLOC( Amap_Tree_t, 1 );
    memset( p, 0, sizeof(Amap_Tree_t) );
    // read the file into the buffer
    Amap_LibertyFixFileHead( pFileName );
    p->nContents = Amap_LibertyFileSize( pFileName );
    if ( p->nContents == 0 )
    {
        ABC_FREE( p );
        return NULL;
    }
    pFile = fopen( pFileName, "rb" );
    p->pContents = ABC_ALLOC( char, p->nContents+1 );
    RetValue = fread( p->pContents, p->nContents, 1, pFile );
    fclose( pFile );
    p->pContents[p->nContents] = 0;
    // other 
    p->pFileName = Abc_UtilStrsav( pFileName );
    p->nItermAlloc = 10 + Amap_LibertyCountItems( p->pContents, p->pContents+p->nContents );
    p->pItems = ABC_CALLOC( Amap_Item_t, p->nItermAlloc );
    p->nItems = 0;
    p->nLines = 1;
    return p;
}

void Amap_LibertyStop

(

Amap_Tree_t *

p

)

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

Synopsis [Stops the parsing manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 992 of file amapLiberty.c.

{
    ABC_FREE( p->pFileName );
    ABC_FREE( p->pContents );
    ABC_FREE( p->pItems );
    ABC_FREE( p->pError );
    ABC_FREE( p );
}

char* Amap_LibertyTimeStamp

(

)

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

Synopsis [Returns the time stamp.]

Description [The file should be closed.]

SideEffects []

SeeAlso []

Definition at line 175 of file amapLiberty.c.

{
    static char Buffer[100];
    char * TimeStamp;
    time_t ltime;
    // get the current time
    time( &ltime );
    TimeStamp = asctime( localtime( &ltime ) );
    TimeStamp[ strlen(TimeStamp) - 1 ] = 0;
    assert( strlen(TimeStamp) < 100 );
    strcpy( Buffer, TimeStamp );
    return Buffer;
}

static Amap_Pair_t Amap_LibertyUpdateHead ( Amap_Tree_t *  p, Amap_Pair_t  Head  )

inlinestatic

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

Synopsis [Find the matching closing symbol.]

Description []

SideEffects []

SeeAlso []

Definition at line 788 of file amapLiberty.c.

{
    Amap_Pair_t Res;
    char * pBeg = p->pContents + Head.Beg;
    char * pEnd = p->pContents + Head.End;
    char * pFirstNonSpace = NULL;
    char * pLastNonSpace = NULL;
    char * pChar;
    for ( pChar = pBeg; pChar < pEnd; pChar++ )
    {
        if ( *pChar == '\n' )
            p->nLines++;
        if ( Amap_LibertyCharIsSpace(*pChar) )
            continue;
        pLastNonSpace = pChar;
        if ( pFirstNonSpace == NULL )
            pFirstNonSpace = pChar;
    }
    if ( pFirstNonSpace == NULL || pLastNonSpace == NULL )
        return Head;
    assert( pFirstNonSpace && pLastNonSpace );
    Res.Beg = pFirstNonSpace - p->pContents;
    Res.End = pLastNonSpace  - p->pContents + 1;
    return Res;
}

void Amap_LibertyWipeOutComments	(	char *	pBeg,
		char *	pEnd
	)

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

Synopsis [Removes C-style comments.]

Description []

SideEffects []

SeeAlso []

Definition at line 639 of file amapLiberty.c.

{
    char * pCur, * pStart;
    for ( pCur = pBeg; pCur < pEnd; pCur++ )
    if ( pCur[0] == '/' && pCur[1] == '*' )
        for ( pStart = pCur; pCur < pEnd; pCur++ )
        if ( pCur[0] == '*' && pCur[1] == '/' )
        {
            for ( ; pStart < pCur + 2; pStart++ )
            if ( *pStart != '\n' ) *pStart = ' ';
            break;
        }
}

static void Amap_PrintSpace ( FILE *  pFile, int  nOffset  )

inlinestatic

Definition at line 76 of file amapLiberty.c.

{ int i; for ( i = 0; i < nOffset; i++ ) fputc(' ', pFile);         }

static void Amap_PrintWord ( FILE *  pFile, Amap_Tree_t *  p, Amap_Pair_t  Pair  )

inlinestatic

Definition at line 75 of file amapLiberty.c.

{ char * pBeg = p->pContents+Pair.Beg, * pEnd = p->pContents+Pair.End; while ( pBeg < pEnd ) fputc( *pBeg++, pFile ); }