sclLiberty.c File Reference

#include "sclLib.h"
#include "misc/st/st.h"
#include "map/mio/mio.h"

Go to the source code of this file.

Data Structures
struct	Scl_Pair_t_
struct	Scl_Item_t_
struct	Scl_Tree_t_

Macros
#define	ABC_MAX_LIB_STR_LEN   5000
	DECLARATIONS ///. More...
#define	Scl_ItemForEachChild(p, pItem, pChild)   for ( pChild = Scl_LibertyItem(p, pItem->Child); pChild; pChild = Scl_LibertyItem(p, pChild->Next) )
#define	Scl_ItemForEachChildName(p, pItem, pChild, pName)   for ( pChild = Scl_LibertyItem(p, pItem->Child); pChild; pChild = Scl_LibertyItem(p, pChild->Next) ) if ( Scl_LibertyCompare(p, pChild->Key, pName) ) {} else

Typedefs
typedef struct Scl_Pair_t_	Scl_Pair_t
typedef struct Scl_Item_t_	Scl_Item_t
typedef struct Scl_Tree_t_	Scl_Tree_t

Enumerations
enum	Scl_LibertyType_t { SCL_LIBERTY_NONE = 0, SCL_LIBERTY_PROC, SCL_LIBERTY_EQUA, SCL_LIBERTY_LIST }

Functions
static Scl_Item_t *	Scl_LibertyRoot (Scl_Tree_t *p)
static Scl_Item_t *	Scl_LibertyItem (Scl_Tree_t *p, int v)
static int	Scl_LibertyCompare (Scl_Tree_t *p, Scl_Pair_t Pair, char *pStr)
static void	Scl_PrintWord (FILE *pFile, Scl_Tree_t *p, Scl_Pair_t Pair)
static void	Scl_PrintSpace (FILE *pFile, int nOffset)
static int	Scl_LibertyItemId (Scl_Tree_t *p, Scl_Item_t *pItem)
void	Scl_LibertyParseDumpItem (FILE *pFile, Scl_Tree_t *p, Scl_Item_t *pItem, int nOffset)
	FUNCTION DEFINITIONS ///. More...
int	Scl_LibertyParseDump (Scl_Tree_t *p, char *pFileName)
int	Scl_LibertyCountItems (char *pBeg, char *pEnd)
void	Scl_LibertyWipeOutComments (char *pBeg, char *pEnd)
static int	Scl_LibertyCharIsSpace (char c)
static int	Scl_LibertySkipSpaces (Scl_Tree_t *p, char **ppPos, char *pEnd, int fStopAtNewLine)
static int	Scl_LibertySkipEntry (char **ppPos, char *pEnd)
static char *	Scl_LibertyFindMatch (char *pPos, char *pEnd)
static Scl_Pair_t	Scl_LibertyUpdateHead (Scl_Tree_t *p, Scl_Pair_t Head)
static Scl_Item_t *	Scl_LibertyNewItem (Scl_Tree_t *p, int Type)
char *	Scl_LibertyReadString (Scl_Tree_t *p, Scl_Pair_t Pair)
int	Scl_LibertyItemNum (Scl_Tree_t *p, Scl_Item_t *pRoot, char *pName)
int	Scl_LibertyBuildItem (Scl_Tree_t *p, char **ppPos, char *pEnd)
void	Scl_LibertyFixFileName (char *pFileName)
int	Scl_LibertyFileSize (char *pFileName)
char *	Scl_LibertyFileContents (char *pFileName, int nContents)
void	Scl_LibertyStringDump (char *pFileName, Vec_Str_t *vStr)
Scl_Tree_t *	Scl_LibertyStart (char *pFileName)
void	Scl_LibertyStop (Scl_Tree_t *p, int fVerbose)
Scl_Tree_t *	Scl_LibertyParse (char *pFileName, int fVerbose)
int	Scl_LibertyReadCellIsFlop (Scl_Tree_t *p, Scl_Item_t *pCell)
char *	Scl_LibertyReadCellArea (Scl_Tree_t *p, Scl_Item_t *pCell)
char *	Scl_LibertyReadCellLeakage (Scl_Tree_t *p, Scl_Item_t *pCell)
char *	Scl_LibertyReadPinFormula (Scl_Tree_t *p, Scl_Item_t *pPin)
int	Scl_LibertyReadCellIsThreeState (Scl_Tree_t *p, Scl_Item_t *pCell)
int	Scl_LibertyReadCellOutputNum (Scl_Tree_t *p, Scl_Item_t *pCell)
Vec_Str_t *	Scl_LibertyReadGenlibStr (Scl_Tree_t *p, int fVerbose)
Vec_Str_t *	Scl_LibertyParseGenlibStr (char *pFileName, int fVerbose)
static void	Vec_StrPutI_ (Vec_Str_t *vOut, int Val)
static void	Vec_StrPutW_ (Vec_Str_t *vOut, word Val)
static void	Vec_StrPutF_ (Vec_Str_t *vOut, float Val)
static void	Vec_StrPutS_ (Vec_Str_t *vOut, char *Val)
static void	Vec_StrPut_ (Vec_Str_t *vOut)
char *	Scl_LibertyReadDefaultWireLoad (Scl_Tree_t *p)
char *	Scl_LibertyReadDefaultWireLoadSel (Scl_Tree_t *p)
float	Scl_LibertyReadDefaultMaxTrans (Scl_Tree_t *p)
int	Scl_LibertyReadTimeUnit (Scl_Tree_t *p)
void	Scl_LibertyReadLoadUnit (Scl_Tree_t *p, Vec_Str_t *vOut)
void	Scl_LibertyReadWireLoad (Scl_Tree_t *p, Vec_Str_t *vOut)
void	Scl_LibertyReadWireLoadSelect (Scl_Tree_t *p, Vec_Str_t *vOut)
int	Scl_LibertyReadDeriveStrength (Scl_Tree_t *p, Scl_Item_t *pCell)
int	Scl_LibertyReadPinDirection (Scl_Tree_t *p, Scl_Item_t *pPin)
float	Scl_LibertyReadPinCap (Scl_Tree_t *p, Scl_Item_t *pPin, char *pName)
Scl_Item_t *	Scl_LibertyReadPinTiming (Scl_Tree_t *p, Scl_Item_t *pPinOut, char *pNameIn)
Vec_Ptr_t *	Scl_LibertyReadPinTimingAll (Scl_Tree_t *p, Scl_Item_t *pPinOut, char *pNameIn)
int	Scl_LibertyReadTimingSense (Scl_Tree_t *p, Scl_Item_t *pPin)
Vec_Flt_t *	Scl_LibertyReadFloatVec (char *pName)
void	Scl_LibertyDumpTables (Vec_Str_t *vOut, Vec_Flt_t *vInd1, Vec_Flt_t *vInd2, Vec_Flt_t *vValues)
int	Scl_LibertyScanTable (Scl_Tree_t *p, Vec_Ptr_t *vOut, Scl_Item_t *pTiming, char *pName, Vec_Ptr_t *vTemples)
int	Scl_LibertyComputeWorstCase (Vec_Ptr_t *vTables, Vec_Flt_t **pvInd0, Vec_Flt_t **pvInd1, Vec_Flt_t **pvValues)
int	Scl_LibertyReadTable (Scl_Tree_t *p, Vec_Str_t *vOut, Scl_Item_t *pTiming, char *pName, Vec_Ptr_t *vTemples)
void	Scl_LibertyPrintTemplates (Vec_Ptr_t *vRes)
Vec_Ptr_t *	Scl_LibertyReadTemplates (Scl_Tree_t *p)
Vec_Str_t *	Scl_LibertyReadSclStr (Scl_Tree_t *p, int fVerbose, int fVeryVerbose)
SC_Lib *	Abc_SclReadLiberty (char *pFileName, int fVerbose, int fVeryVerbose)
void	Scl_LibertyTest ()

Macro Definition Documentation

#define ABC_MAX_LIB_STR_LEN   5000

DECLARATIONS ///.

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

FileName [sclLiberty.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Standard-cell library representation.]

Synopsis [Liberty parser.]

Author [Alan Mishchenko, Niklas Een]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - August 24, 2012.]

Revision [

Id:

sclLiberty.c,v 1.0 2012/08/24 00:00:00 alanmi Exp

]

Definition at line 32 of file sclLiberty.c.

#define Scl_ItemForEachChild	(		p,
			pItem,
			pChild
	)		for ( pChild = Scl_LibertyItem(p, pItem->Child); pChild; pChild = Scl_LibertyItem(p, pChild->Next) )

Definition at line 82 of file sclLiberty.c.

#define Scl_ItemForEachChildName	(		p,
			pItem,
			pChild,
			pName
	)		for ( pChild = Scl_LibertyItem(p, pItem->Child); pChild; pChild = Scl_LibertyItem(p, pChild->Next) ) if ( Scl_LibertyCompare(p, pChild->Key, pName) ) {} else

Definition at line 84 of file sclLiberty.c.

Typedef Documentation

typedef struct Scl_Item_t_ Scl_Item_t

Definition at line 49 of file sclLiberty.c.

typedef struct Scl_Pair_t_ Scl_Pair_t

Definition at line 42 of file sclLiberty.c.

typedef struct Scl_Tree_t_ Scl_Tree_t

Definition at line 61 of file sclLiberty.c.

Enumeration Type Documentation

enum Scl_LibertyType_t

Enumerator
SCL_LIBERTY_NONE
SCL_LIBERTY_PROC
SCL_LIBERTY_EQUA
SCL_LIBERTY_LIST

Definition at line 35 of file sclLiberty.c.

             { 
    SCL_LIBERTY_NONE = 0,        // 0:  unknown
    SCL_LIBERTY_PROC,            // 1:  procedure :  key(head){body}
    SCL_LIBERTY_EQUA,            // 2:  equation  :  key:head;
    SCL_LIBERTY_LIST             // 3:  list      :  key(head) 
} Scl_LibertyType_t;

Function Documentation

SC_Lib* Abc_SclReadLiberty	(	char *	pFileName,
		int	fVerbose,
		int	fVeryVerbose
	)

Definition at line 1626 of file sclLiberty.c.

{
    SC_Lib * pLib;
    Scl_Tree_t * p;
    Vec_Str_t * vStr;
    p = Scl_LibertyParse( pFileName, fVeryVerbose );
    if ( p == NULL )
        return NULL;
//    Scl_LibertyParseDump( p, "temp_.lib" );
    // collect relevant data
    vStr = Scl_LibertyReadSclStr( p, fVerbose, fVeryVerbose );
    Scl_LibertyStop( p, fVeryVerbose );
    if ( vStr == NULL )
        return NULL;
    // construct SCL data-structure
    pLib = Abc_SclReadFromStr( vStr );
    if ( pLib == NULL )
        return NULL;
    pLib->pFileName = Abc_UtilStrsav( pFileName );
    Abc_SclLibNormalize( pLib );
    Vec_StrFree( vStr );
//    printf( "Average slew = %.2f ps\n", Abc_SclComputeAverageSlew(pLib) );
    return pLib;
}

int Scl_LibertyBuildItem	(	Scl_Tree_t *	p,
		char **	ppPos,
		char *	pEnd
	)

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

Synopsis [Returns free item.]

Description []

SideEffects []

SeeAlso []

Definition at line 375 of file sclLiberty.c.

{
    Scl_Item_t * pItem;
    Scl_Pair_t Key, Head, Body;
    char * pNext, * pStop;
    Key.End = 0;
    if ( Scl_LibertySkipSpaces( p, ppPos, pEnd, 0 ) )
        return -2;
    Key.Beg = *ppPos - p->pContents;
    if ( Scl_LibertySkipEntry( ppPos, pEnd ) )
        goto exit;
    Key.End = *ppPos - p->pContents;
    if ( Scl_LibertySkipSpaces( p, ppPos, pEnd, 0 ) )
        goto exit;
    pNext = *ppPos;
    if ( *pNext == ':' )
    {
        *ppPos = pNext + 1;
        if ( Scl_LibertySkipSpaces( p, ppPos, pEnd, 0 ) )
            goto exit;
        Head.Beg = *ppPos - p->pContents;
        if ( Scl_LibertySkipEntry( ppPos, pEnd ) )
            goto exit;
        Head.End = *ppPos - p->pContents;
        if ( Scl_LibertySkipSpaces( p, ppPos, pEnd, 1 ) )
            goto exit;
        pNext = *ppPos;
        if ( *pNext != ';' && *pNext != '\n' )
            goto exit;
        *ppPos = pNext + 1;
        // end of equation
        pItem = Scl_LibertyNewItem( p, SCL_LIBERTY_EQUA );
        pItem->Key  = Key;
        pItem->Head = Scl_LibertyUpdateHead( p, Head );
        pItem->Next = Scl_LibertyBuildItem( p, ppPos, pEnd );
        if ( pItem->Next == -1 )
            goto exit;
        return Scl_LibertyItemId( p, pItem );
    }
    if ( *pNext == '(' )
    {
        pStop = Scl_LibertyFindMatch( pNext, pEnd );
        Head.Beg = pNext - p->pContents + 1;
        Head.End = pStop - p->pContents;
        *ppPos = pStop + 1;
        if ( Scl_LibertySkipSpaces( p, ppPos, pEnd, 0 ) )
        {
            // end of list
            pItem = Scl_LibertyNewItem( p, SCL_LIBERTY_LIST );
            pItem->Key  = Key;
            pItem->Head = Scl_LibertyUpdateHead( p, Head );
            return Scl_LibertyItemId( p, pItem );
        }
        pNext = *ppPos;
        if ( *pNext == '{' ) // beginning of body
        {
            pStop = Scl_LibertyFindMatch( pNext, pEnd );
            Body.Beg = pNext - p->pContents + 1;
            Body.End = pStop - p->pContents;
            // end of body
            pItem = Scl_LibertyNewItem( p, SCL_LIBERTY_PROC );
            pItem->Key  = Key;
            pItem->Head = Scl_LibertyUpdateHead( p, Head );
            pItem->Body = Body;
            *ppPos = pNext + 1;
            pItem->Child = Scl_LibertyBuildItem( p, ppPos, pStop );
            if ( pItem->Child == -1 )
                goto exit;
            *ppPos = pStop + 1;
            pItem->Next = Scl_LibertyBuildItem( p, ppPos, pEnd );
            if ( pItem->Next == -1 )
                goto exit;
            return Scl_LibertyItemId( p, pItem );
        }
        // end of list
        if ( *pNext == ';' )
            *ppPos = pNext + 1;
        pItem = Scl_LibertyNewItem( p, SCL_LIBERTY_LIST );
        pItem->Key  = Key;
        pItem->Head = Scl_LibertyUpdateHead( p, Head );
        pItem->Next = Scl_LibertyBuildItem( p, ppPos, pEnd );
        if ( pItem->Next == -1 )
            goto exit;
        return Scl_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, Scl_LibertyReadString(p, Key) );
    }
    return -1;
}

static int Scl_LibertyCharIsSpace ( char  c )

inlinestatic

Definition at line 215 of file sclLiberty.c.

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

static int Scl_LibertyCompare ( Scl_Tree_t *  p, Scl_Pair_t  Pair, char *  pStr  )

inlinestatic

Definition at line 77 of file sclLiberty.c.

{ return strncmp( p->pContents+Pair.Beg, pStr, Pair.End-Pair.Beg ) || ((int)strlen(pStr) != Pair.End-Pair.Beg); }

int Scl_LibertyComputeWorstCase	(	Vec_Ptr_t *	vTables,
		Vec_Flt_t **	pvInd0,
		Vec_Flt_t **	pvInd1,
		Vec_Flt_t **	pvValues
	)

Definition at line 1131 of file sclLiberty.c.

{
    Vec_Flt_t * vInd0, * vInd1, * vValues;
    Vec_Flt_t * vind0, * vind1, * vvalues;
    int i, k, nTriples = Vec_PtrSize(vTables) / 3;
    float Entry;
    assert( Vec_PtrSize(vTables) > 0 && Vec_PtrSize(vTables) % 3 == 0 );
    if ( nTriples == 1 )
    {
        *pvInd0   = (Vec_Flt_t *)Vec_PtrEntry(vTables, 0);
        *pvInd1   = (Vec_Flt_t *)Vec_PtrEntry(vTables, 1);
        *pvValues = (Vec_Flt_t *)Vec_PtrEntry(vTables, 2);
        Vec_PtrShrink( vTables, 0 );
        return 1;
    }
    vInd0   = Vec_FltDup( (Vec_Flt_t *)Vec_PtrEntry(vTables, 0) );
    vInd1   = Vec_FltDup( (Vec_Flt_t *)Vec_PtrEntry(vTables, 1) );
    vValues = Vec_FltDup( (Vec_Flt_t *)Vec_PtrEntry(vTables, 2) );
    for ( i = 1; i < nTriples; i++ )
    {
        vind0   = (Vec_Flt_t *)Vec_PtrEntry(vTables, i*3+0);
        vind1   = (Vec_Flt_t *)Vec_PtrEntry(vTables, i*3+1);
        vvalues = (Vec_Flt_t *)Vec_PtrEntry(vTables, i*3+2);
        // check equality of indexes
        if ( !Vec_FltEqual(vind0, vInd0) )
            continue;//return 0;
        if ( !Vec_FltEqual(vind1, vInd1) )
            continue;//return 0;
//        Vec_FltForEachEntry( vvalues, Entry, k )
//            Vec_FltAddToEntry( vValues, k, Entry );
        Vec_FltForEachEntry( vvalues, Entry, k )
            if ( Vec_FltEntry(vValues, k) < Entry )
                Vec_FltWriteEntry( vValues, k, Entry );
    }
//    Vec_FltForEachEntry( vValues, Entry, k )
//        Vec_FltWriteEntry( vValues, k, Entry/nTriples );
    // return the result
    *pvInd0 = vInd0;
    *pvInd1 = vInd1;
    *pvValues = vValues;
    return 1;
}

int Scl_LibertyCountItems	(	char *	pBeg,
		char *	pEnd
	)

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

Synopsis [Gets the name to write.]

Description []

SideEffects []

SeeAlso []

Definition at line 168 of file sclLiberty.c.

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

void Scl_LibertyDumpTables	(	Vec_Str_t *	vOut,
		Vec_Flt_t *	vInd1,
		Vec_Flt_t *	vInd2,
		Vec_Flt_t *	vValues
	)

Definition at line 978 of file sclLiberty.c.

{
    int i; float Entry;
    // write entries
    Vec_StrPutI_( vOut, Vec_FltSize(vInd1) );
    Vec_FltForEachEntry( vInd1, Entry, i )
        Vec_StrPutF_( vOut, Entry );
    Vec_StrPut_( vOut );
    // write entries
    Vec_StrPutI_( vOut, Vec_FltSize(vInd2) );
    Vec_FltForEachEntry( vInd2, Entry, i )
        Vec_StrPutF_( vOut, Entry );
    Vec_StrPut_( vOut );
    Vec_StrPut_( vOut );
    // write entries
    assert( Vec_FltSize(vInd1) * Vec_FltSize(vInd2) == Vec_FltSize(vValues) );
    Vec_FltForEachEntry( vValues, Entry, i )
    {
        Vec_StrPutF_( vOut, Entry );
        if ( i % Vec_FltSize(vInd2) == Vec_FltSize(vInd2)-1 )
            Vec_StrPut_( vOut );
    }
    // dump approximations
    Vec_StrPut_( vOut );
    for ( i = 0; i < 3; i++ ) 
        Vec_StrPutF_( vOut, 0 );
    for ( i = 0; i < 4; i++ ) 
        Vec_StrPutF_( vOut, 0 );
    for ( i = 0; i < 6; i++ ) 
        Vec_StrPutF_( vOut, 0 );
    Vec_StrPut_( vOut );
    Vec_StrPut_( vOut );
}

char* Scl_LibertyFileContents	(	char *	pFileName,
		int	nContents
	)

Definition at line 503 of file sclLiberty.c.

{
    FILE * pFile = fopen( pFileName, "rb" );
    char * pContents = ABC_ALLOC( char, nContents+1 );
    int RetValue;
    RetValue = fread( pContents, nContents, 1, pFile );
    fclose( pFile );
    pContents[nContents] = 0;
    return pContents;
}

int Scl_LibertyFileSize

(

char *

pFileName

)

Definition at line 488 of file sclLiberty.c.

{
    FILE * pFile;
    int nFileSize;
    pFile = fopen( pFileName, "rb" );
    if ( pFile == NULL )
    {
        printf( "Scl_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* Scl_LibertyFindMatch ( char *  pPos, char *  pEnd  )

inlinestatic

Definition at line 262 of file sclLiberty.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 Scl_LibertyFixFileName

(

char *

pFileName

)

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

Synopsis [File management.]

Description []

SideEffects []

SeeAlso []

Definition at line 481 of file sclLiberty.c.

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

static Scl_Item_t* Scl_LibertyItem ( Scl_Tree_t *  p, int  v  )

inlinestatic

Definition at line 76 of file sclLiberty.c.

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

static int Scl_LibertyItemId ( Scl_Tree_t *  p, Scl_Item_t *  pItem  )

inlinestatic

Definition at line 80 of file sclLiberty.c.

{ return pItem - p->pItems;                                         }

int Scl_LibertyItemNum	(	Scl_Tree_t *	p,
		Scl_Item_t *	pRoot,
		char *	pName
	)

Definition at line 355 of file sclLiberty.c.

{
    Scl_Item_t * pItem;
    int Counter = 0;
    Scl_ItemForEachChildName( p, pRoot, pItem, pName )
        Counter++;
    return Counter;
}

static Scl_Item_t* Scl_LibertyNewItem ( Scl_Tree_t *  p, int  Type  )

inlinestatic

Definition at line 320 of file sclLiberty.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++;
}

Scl_Tree_t* Scl_LibertyParse	(	char *	pFileName,
		int	fVerbose
	)

Definition at line 573 of file sclLiberty.c.

{
    Scl_Tree_t * p;
    char * pPos;
    if ( (p = Scl_LibertyStart(pFileName)) == NULL )
        return NULL;
    pPos = p->pContents;
    Scl_LibertyWipeOutComments( p->pContents, p->pContents+p->nContents );
    if ( !Scl_LibertyBuildItem( p, &pPos, p->pContents + p->nContents ) == 0 )
    {
        if ( p->pError ) printf( "%s", p->pError );
        printf( "Parsing failed.  " );
        Abc_PrintTime( 1, "Parsing time", Abc_Clock() - p->clkStart );
    }
    else if ( fVerbose )
    {
        printf( "Parsing finished successfully.  " );
        Abc_PrintTime( 1, "Parsing time", Abc_Clock() - p->clkStart );
    }
    return p;
}

int Scl_LibertyParseDump	(	Scl_Tree_t *	p,
		char *	pFileName
	)

Definition at line 136 of file sclLiberty.c.

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

void Scl_LibertyParseDumpItem	(	FILE *	pFile,
		Scl_Tree_t *	p,
		Scl_Item_t *	pItem,
		int	nOffset
	)

FUNCTION DEFINITIONS ///.

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

Synopsis [Prints parse tree in Liberty format.]

Description []

SideEffects []

SeeAlso []

Definition at line 102 of file sclLiberty.c.

{
    if ( pItem->Type == SCL_LIBERTY_PROC )
    {
        Scl_PrintSpace( pFile, nOffset );
        Scl_PrintWord( pFile, p, pItem->Key );
        fprintf( pFile, "(" );
        Scl_PrintWord( pFile, p, pItem->Head );
        fprintf( pFile, ") {\n" );
        if ( Scl_LibertyItem(p, pItem->Child) )
            Scl_LibertyParseDumpItem( pFile, p, Scl_LibertyItem(p, pItem->Child), nOffset + 2 );
        Scl_PrintSpace( pFile, nOffset );
        fprintf( pFile, "}\n" );
    }
    else if ( pItem->Type == SCL_LIBERTY_EQUA )
    {
        Scl_PrintSpace( pFile, nOffset );
        Scl_PrintWord( pFile, p, pItem->Key );
        fprintf( pFile, " : " );
        Scl_PrintWord( pFile, p, pItem->Head );
        fprintf( pFile, ";\n" );
    }
    else if ( pItem->Type == SCL_LIBERTY_LIST )
    {
        Scl_PrintSpace( pFile, nOffset );
        Scl_PrintWord( pFile, p, pItem->Key );
        fprintf( pFile, "(" );
        Scl_PrintWord( pFile, p, pItem->Head );
        fprintf( pFile, ");\n" );
    }
    else assert( 0 );
    if ( Scl_LibertyItem(p, pItem->Next) )
        Scl_LibertyParseDumpItem( pFile, p, Scl_LibertyItem(p, pItem->Next), nOffset );
}

Vec_Str_t* Scl_LibertyParseGenlibStr	(	char *	pFileName,
		int	fVerbose
	)

Definition at line 735 of file sclLiberty.c.

{
    Scl_Tree_t * p;
    Vec_Str_t * vStr;
    p = Scl_LibertyParse( pFileName, fVerbose );
    if ( p == NULL )
        return NULL;
//    Scl_LibertyRead( p, "temp_.lib" );
    vStr = Scl_LibertyReadGenlibStr( p, fVerbose );
    Scl_LibertyStop( p, fVerbose );
//    Scl_LibertyStringDump( "test_genlib.lib", vStr );
    return vStr;
}

void Scl_LibertyPrintTemplates

(

Vec_Ptr_t *

vRes

)

Definition at line 1323 of file sclLiberty.c.

{
    Vec_Flt_t * vArray; int i;
    assert( Vec_PtrSize(vRes) % 4 == 0 );
    printf( "There are %d slew/load templates\n", Vec_PtrSize(vRes) % 4 );
    Vec_PtrForEachEntry( Vec_Flt_t *, vRes, vArray, i )
    {
        if ( i % 4 == 0 )
            printf( "%s\n", (char *)vArray );
        else if ( i % 4 == 1 )
            printf( "%d\n", (int)(vArray != NULL) );
        else if ( i % 4 == 2 || i % 4 == 3 )
            Vec_FltPrint( vArray );
        if ( i % 4 == 3 )
            printf( "\n" );
    }
}

char* Scl_LibertyReadCellArea	(	Scl_Tree_t *	p,
		Scl_Item_t *	pCell
	)

Definition at line 615 of file sclLiberty.c.

{
    Scl_Item_t * pArea;
    Scl_ItemForEachChildName( p, pCell, pArea, "area" )
        return Scl_LibertyReadString(p, pArea->Head);
    return 0;
}

int Scl_LibertyReadCellIsFlop	(	Scl_Tree_t *	p,
		Scl_Item_t *	pCell
	)

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

Synopsis [Fetching attributes.]

Description []

SideEffects []

SeeAlso []

Definition at line 606 of file sclLiberty.c.

{
    Scl_Item_t * pAttr;
    Scl_ItemForEachChild( p, pCell, pAttr )
        if ( !Scl_LibertyCompare(p, pAttr->Key, "ff") ||
             !Scl_LibertyCompare(p, pAttr->Key, "latch") )
            return 1;
    return 0;
}

int Scl_LibertyReadCellIsThreeState	(	Scl_Tree_t *	p,
		Scl_Item_t *	pCell
	)

Definition at line 646 of file sclLiberty.c.

{
    Scl_Item_t * pPin, * pItem;
    Scl_ItemForEachChildName( p, pCell, pPin, "pin" )
        Scl_ItemForEachChildName( p, pPin, pItem, "three_state" )
            return 1;
    return 0;
}

char* Scl_LibertyReadCellLeakage	(	Scl_Tree_t *	p,
		Scl_Item_t *	pCell
	)

Definition at line 622 of file sclLiberty.c.

{
    Scl_Item_t * pItem, * pChild;
    Scl_ItemForEachChildName( p, pCell, pItem, "cell_leakage_power" )
        return Scl_LibertyReadString(p, pItem->Head);
    // look for another type
    Scl_ItemForEachChildName( p, pCell, pItem, "leakage_power" )
    {
        Scl_ItemForEachChildName( p, pItem, pChild, "when" )
            break;
        if ( pChild && !Scl_LibertyCompare(p, pChild->Key, "when") )
            continue;
        Scl_ItemForEachChildName( p, pItem, pChild, "value" )
            return Scl_LibertyReadString(p, pChild->Head);
    }
    return 0;
}

int Scl_LibertyReadCellOutputNum	(	Scl_Tree_t *	p,
		Scl_Item_t *	pCell
	)

Definition at line 654 of file sclLiberty.c.

{
    Scl_Item_t * pPin;
    int Counter = 0;
    Scl_ItemForEachChildName( p, pCell, pPin, "pin" )
        if ( Scl_LibertyReadPinFormula(p, pPin) )
            Counter++;
    return Counter;
}

float Scl_LibertyReadDefaultMaxTrans

(

Scl_Tree_t *

p

)

Definition at line 801 of file sclLiberty.c.

{
    Scl_Item_t * pItem;
    Scl_ItemForEachChildName( p, Scl_LibertyRoot(p), pItem, "default_max_transition" )
        return atof(Scl_LibertyReadString(p, pItem->Head));
    return 0;
}

char* Scl_LibertyReadDefaultWireLoad

(

Scl_Tree_t *

p

)

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

Synopsis [Parsing Liberty into internal data representation.]

Description []

SideEffects []

SeeAlso []

Definition at line 787 of file sclLiberty.c.

{
    Scl_Item_t * pItem;
    Scl_ItemForEachChildName( p, Scl_LibertyRoot(p), pItem, "default_wire_load" )
        return Scl_LibertyReadString(p, pItem->Head);
    return "";
}

char* Scl_LibertyReadDefaultWireLoadSel

(

Scl_Tree_t *

p

)

Definition at line 794 of file sclLiberty.c.

{
    Scl_Item_t * pItem;
    Scl_ItemForEachChildName( p, Scl_LibertyRoot(p), pItem, "default_wire_load_selection" )
        return Scl_LibertyReadString(p, pItem->Head);
    return "";
}

int Scl_LibertyReadDeriveStrength	(	Scl_Tree_t *	p,
		Scl_Item_t *	pCell
	)

Definition at line 905 of file sclLiberty.c.

{
    Scl_Item_t * pItem;
    Scl_ItemForEachChildName( p, pCell, pItem, "drive_strength" )
        return atoi(Scl_LibertyReadString(p, pItem->Head));
    return 0;
}

Vec_Flt_t* Scl_LibertyReadFloatVec

(

char *

pName

)

Definition at line 969 of file sclLiberty.c.

{
    char * pToken;
    Vec_Flt_t * vValues = Vec_FltAlloc( 100 );
    for ( pToken = strtok(pName, " \t\n\r\\\","); pToken; pToken = strtok(NULL, " \t\n\r\\\",") )
        Vec_FltPush( vValues, atof(pToken) );
    return vValues;
}

Vec_Str_t* Scl_LibertyReadGenlibStr	(	Scl_Tree_t *	p,
		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 675 of file sclLiberty.c.

{
    Vec_Str_t * vStr;
    Scl_Item_t * pCell, * pOutput, * pInput;
    char * pFormula;
    vStr = Vec_StrAlloc( 1000 );
    Vec_StrPrintStr( vStr, "GATE          _const0_  0.000000  z=CONST0;\n" );
    Vec_StrPrintStr( vStr, "GATE          _const1_  0.000000  z=CONST1;\n" );
    Scl_ItemForEachChildName( p, Scl_LibertyRoot(p), pCell, "cell" )
    {
        if ( Scl_LibertyReadCellIsFlop(p, pCell) )
        {
            if ( fVerbose )  printf( "Scl_LibertyReadGenlib() skipped sequential cell \"%s\".\n", Scl_LibertyReadString(p, pCell->Head) );
            continue;
        }
        if ( Scl_LibertyReadCellIsThreeState(p, pCell) )
        {
            if ( fVerbose )  printf( "Scl_LibertyReadGenlib() skipped three-state cell \"%s\".\n", Scl_LibertyReadString(p, pCell->Head) );
            continue;
        }
        if ( Scl_LibertyReadCellOutputNum(p, pCell) == 0 )
        {
            if ( fVerbose )  printf( "Scl_LibertyReadGenlib() skipped cell \"%s\" without logic function.\n", Scl_LibertyReadString(p, pCell->Head) );
            continue;
        }
        // iterate through output pins
        Scl_ItemForEachChildName( p, pCell, pOutput, "pin" )
        {
            if ( (pFormula = Scl_LibertyReadPinFormula(p, pOutput)) ) 
                continue;
            if ( !strcmp(pFormula, "0") || !strcmp(pFormula, "1") )
            {
                if ( fVerbose ) printf( "Scl_LibertyReadGenlib() skipped cell \"%s\" with constant formula \"%s\".\n", Scl_LibertyReadString(p, pCell->Head), pFormula );
                break;
            }
            Vec_StrPrintStr( vStr, "GATE " );
            Vec_StrPrintStr( vStr, Scl_LibertyReadString(p, pCell->Head) );
            Vec_StrPrintStr( vStr, " " );
            Vec_StrPrintStr( vStr, Scl_LibertyReadCellArea(p, pCell) );
            Vec_StrPrintStr( vStr, " " );
            Vec_StrPrintStr( vStr, Scl_LibertyReadString(p, pOutput->Head) );
            Vec_StrPrintStr( vStr, "=" );
            Vec_StrPrintStr( vStr, pFormula );
            Vec_StrPrintStr( vStr, ";\n" );
            // iterate through input pins
            Scl_ItemForEachChildName( p, pCell, pInput, "pin" )
            {
                if ( Scl_LibertyReadPinFormula(p, pInput) == NULL )
                    continue;
                Vec_StrPrintStr( vStr, "  PIN " );
                Vec_StrPrintStr( vStr, Scl_LibertyReadString(p, pInput->Head) );
                Vec_StrPrintStr( vStr, " UNKNOWN  1  999  1.00  0.00  1.00  0.00\n" );
            }
        }
    }
    Vec_StrPrintStr( vStr, "\n.end\n" );
    Vec_StrPush( vStr, '\0' );
//    printf( "%s", Vec_StrArray(vStr) );
    return vStr;
}

void Scl_LibertyReadLoadUnit	(	Scl_Tree_t *	p,
		Vec_Str_t *	vOut
	)

Definition at line 828 of file sclLiberty.c.

{
    Scl_Item_t * pItem;
    Scl_ItemForEachChildName( p, Scl_LibertyRoot(p), pItem, "capacitive_load_unit" )
    {
        // expecting (1.00,ff) or (1, pf) ... 12 or 15 for 'pf' or 'ff'
        char * pHead   = Scl_LibertyReadString(p, pItem->Head);
        float First    = atof(strtok(pHead, " \t\n\r\\\","));
        char * pSecond = strtok(NULL, " \t\n\r\\\",");
        Vec_StrPutF_( vOut, First );
        if ( pSecond && !strcmp(pSecond, "pf") )
            Vec_StrPutI_( vOut, 12 );
        else if ( pSecond && !strcmp(pSecond, "ff") )
            Vec_StrPutI_( vOut, 15 );
        else break;
        return;
    }
    printf( "Libery parser cannot read \"capacitive_load_unit\". Assuming   capacitive_load_unit(1, pf).\n" );
    Vec_StrPutF_( vOut, 1.0 );
    Vec_StrPutI_( vOut, 12 );
}

float Scl_LibertyReadPinCap	(	Scl_Tree_t *	p,
		Scl_Item_t *	pPin,
		char *	pName
	)

Definition at line 926 of file sclLiberty.c.

{
    Scl_Item_t * pItem;
    Scl_ItemForEachChildName( p, pPin, pItem, pName )
        return atof(Scl_LibertyReadString(p, pItem->Head));
    return 0;
}

int Scl_LibertyReadPinDirection	(	Scl_Tree_t *	p,
		Scl_Item_t *	pPin
	)

Definition at line 912 of file sclLiberty.c.

{
    Scl_Item_t * pItem;
    Scl_ItemForEachChildName( p, pPin, pItem, "direction" )
    {
        char * pToken = Scl_LibertyReadString(p, pItem->Head);
        if ( !strcmp(pToken, "input") )
            return 0;
        if ( !strcmp(pToken, "output") )
            return 1;
        break;
    }
    return -1;
}

char* Scl_LibertyReadPinFormula	(	Scl_Tree_t *	p,
		Scl_Item_t *	pPin
	)

Definition at line 639 of file sclLiberty.c.

{
    Scl_Item_t * pFunc;
    Scl_ItemForEachChildName( p, pPin, pFunc, "function" )
        return Scl_LibertyReadString(p, pFunc->Head);
    return NULL;
}

Scl_Item_t* Scl_LibertyReadPinTiming	(	Scl_Tree_t *	p,
		Scl_Item_t *	pPinOut,
		char *	pNameIn
	)

Definition at line 933 of file sclLiberty.c.

{
    Scl_Item_t * pTiming, * pPinIn;
    Scl_ItemForEachChildName( p, pPinOut, pTiming, "timing" )
        Scl_ItemForEachChildName( p, pTiming, pPinIn, "related_pin" )
            if ( !strcmp(Scl_LibertyReadString(p, pPinIn->Head), pNameIn) )
                return pTiming;
    return NULL;
}

Vec_Ptr_t* Scl_LibertyReadPinTimingAll	(	Scl_Tree_t *	p,
		Scl_Item_t *	pPinOut,
		char *	pNameIn
	)

Definition at line 942 of file sclLiberty.c.

{
    Vec_Ptr_t * vTimings;
    Scl_Item_t * pTiming, * pPinIn;
    vTimings = Vec_PtrAlloc( 16 );
    Scl_ItemForEachChildName( p, pPinOut, pTiming, "timing" )
        Scl_ItemForEachChildName( p, pTiming, pPinIn, "related_pin" )
            if ( !strcmp(Scl_LibertyReadString(p, pPinIn->Head), pNameIn) )
                Vec_PtrPush( vTimings, pTiming );
    return vTimings;
}

Vec_Str_t* Scl_LibertyReadSclStr	(	Scl_Tree_t *	p,
		int	fVerbose,
		int	fVeryVerbose
	)

Definition at line 1394 of file sclLiberty.c.

{
    int fUseFirstTable = 0;
    Vec_Str_t * vOut;
    Vec_Ptr_t * vNameIns, * vTemples = NULL;
    Scl_Item_t * pCell, * pPin, * pTiming;
    Vec_Wrd_t * vTruth;
    char * pFormula, * pName;
    int i, k, Counter, nOutputs, nCells;
    int nSkipped[3] = {0};

    // read delay-table templates
    vTemples = Scl_LibertyReadTemplates( p );

    // start the library
    vOut = Vec_StrAlloc( 10000 );
    Vec_StrPutI_( vOut, ABC_SCL_CUR_VERSION );

    // top level information
    Vec_StrPut_( vOut );
    Vec_StrPutS_( vOut, Scl_LibertyReadString(p, Scl_LibertyRoot(p)->Head) );
    Vec_StrPutS_( vOut, Scl_LibertyReadDefaultWireLoad(p) );
    Vec_StrPutS_( vOut, Scl_LibertyReadDefaultWireLoadSel(p) );
    Vec_StrPutF_( vOut, Scl_LibertyReadDefaultMaxTrans(p) );
    Vec_StrPutI_( vOut, Scl_LibertyReadTimeUnit(p) );
    Scl_LibertyReadLoadUnit( p, vOut );
    Vec_StrPut_( vOut );
    Vec_StrPut_( vOut );

    // read wire loads
    Scl_LibertyReadWireLoad( p, vOut );
    Scl_LibertyReadWireLoadSelect( p, vOut );

    // count cells
    nCells = 0;
    Scl_ItemForEachChildName( p, Scl_LibertyRoot(p), pCell, "cell" )
    {
        if ( Scl_LibertyReadCellIsFlop(p, pCell) )
        {
            if ( fVeryVerbose )  printf( "Scl_LibertyReadGenlib() skipped sequential cell \"%s\".\n", Scl_LibertyReadString(p, pCell->Head) );
            nSkipped[0]++;
            continue;
        }
        if ( Scl_LibertyReadCellIsThreeState(p, pCell) )
        {
            if ( fVeryVerbose )  printf( "Scl_LibertyReadGenlib() skipped three-state cell \"%s\".\n", Scl_LibertyReadString(p, pCell->Head) );
            nSkipped[1]++;
            continue;
        }
        if ( (Counter = Scl_LibertyReadCellOutputNum(p, pCell)) == 0 )
        {
            if ( fVeryVerbose )  printf( "Scl_LibertyReadGenlib() skipped cell \"%s\" without logic function.\n", Scl_LibertyReadString(p, pCell->Head) );
            nSkipped[2]++;
            continue;
        }
        nCells++;
    }
    // read cells
    Vec_StrPutI_( vOut, nCells );
    Vec_StrPut_( vOut );
    Vec_StrPut_( vOut );
    Scl_ItemForEachChildName( p, Scl_LibertyRoot(p), pCell, "cell" )
    {
        if ( Scl_LibertyReadCellIsFlop(p, pCell) )
            continue;
        if ( Scl_LibertyReadCellIsThreeState(p, pCell) )
            continue;
        if ( (Counter = Scl_LibertyReadCellOutputNum(p, pCell)) == 0 )
            continue;
        // top level information
        Vec_StrPutS_( vOut, Scl_LibertyReadString(p, pCell->Head) );
        pName = Scl_LibertyReadCellArea(p, pCell);
        Vec_StrPutF_( vOut, pName ? atof(pName) : 1 );
        pName = Scl_LibertyReadCellLeakage(p, pCell);
        Vec_StrPutF_( vOut, pName ? atof(pName) : 0 );
        Vec_StrPutI_( vOut, Scl_LibertyReadDeriveStrength(p, pCell) );
        // pin count
        nOutputs = Scl_LibertyReadCellOutputNum( p, pCell );
        Vec_StrPutI_( vOut, Scl_LibertyItemNum(p, pCell, "pin") - nOutputs );
        Vec_StrPutI_( vOut, nOutputs );
        Vec_StrPut_( vOut );
        Vec_StrPut_( vOut );

        // input pins
        vNameIns = Vec_PtrAlloc( 16 );
        Scl_ItemForEachChildName( p, pCell, pPin, "pin" )
        {
            float CapOne, CapRise, CapFall;
            if ( Scl_LibertyReadPinFormula(p, pPin) != NULL ) // skip output pin
                continue;
            assert( Scl_LibertyReadPinDirection(p, pPin) == 0 );
            pName = Scl_LibertyReadString(p, pPin->Head);
            Vec_PtrPush( vNameIns, Abc_UtilStrsav(pName) );
            Vec_StrPutS_( vOut, pName );
            CapOne  = Scl_LibertyReadPinCap( p, pPin, "capacitance" );
            CapRise = Scl_LibertyReadPinCap( p, pPin, "rise_capacitance" );
            CapFall = Scl_LibertyReadPinCap( p, pPin, "fall_capacitance" );
            if ( CapRise == 0 )
                CapRise = CapOne;
            if ( CapFall == 0 )
                CapFall = CapOne;
            Vec_StrPutF_( vOut, CapRise );
            Vec_StrPutF_( vOut, CapFall );
            Vec_StrPut_( vOut );
        }
        Vec_StrPut_( vOut );
        // output pins
        Scl_ItemForEachChildName( p, pCell, pPin, "pin" )
        {
            if ( !Scl_LibertyReadPinFormula(p, pPin) ) // skip input pin
                continue;
            assert( Scl_LibertyReadPinDirection(p, pPin) == 1 );
            pName = Scl_LibertyReadString(p, pPin->Head);
            Vec_StrPutS_( vOut, pName );
            Vec_StrPutF_( vOut, Scl_LibertyReadPinCap( p, pPin, "max_capacitance" ) );
            Vec_StrPutF_( vOut, Scl_LibertyReadPinCap( p, pPin, "max_transition" ) );
            Vec_StrPutI_( vOut, Vec_PtrSize(vNameIns) );
            pFormula = Scl_LibertyReadPinFormula(p, pPin);
            Vec_StrPutS_( vOut, pFormula );
            // write truth table
            vTruth = Mio_ParseFormulaTruth( pFormula, (char **)Vec_PtrArray(vNameIns), Vec_PtrSize(vNameIns) );
            for ( i = 0; i < Abc_Truth6WordNum(Vec_PtrSize(vNameIns)); i++ )
                Vec_StrPutW_( vOut, Vec_WrdEntry(vTruth, i) );
            Vec_WrdFree( vTruth );
            Vec_StrPut_( vOut );
            Vec_StrPut_( vOut );

            // write the delay tables
            if ( fUseFirstTable )
            {
                Vec_PtrForEachEntry( char *, vNameIns, pName, i )
                {
                    pTiming = Scl_LibertyReadPinTiming( p, pPin, pName );
                    Vec_StrPutS_( vOut, pName );
                    Vec_StrPutI_( vOut, (int)(pTiming != NULL) );
                    if ( pTiming == NULL ) // output does not depend on input
                        continue;
                    Vec_StrPutI_( vOut, Scl_LibertyReadTimingSense(p, pTiming) );
                    Vec_StrPut_( vOut );
                    Vec_StrPut_( vOut );
                    // some cells only have 'rise' or 'fall' but not both - here we work around this
                    if ( !Scl_LibertyReadTable( p, vOut, pTiming, "cell_rise",           vTemples ) )
                        if ( !Scl_LibertyReadTable( p, vOut, pTiming, "cell_fall",       vTemples ) )
                                { printf( "Table cannot be found\n" ); return NULL; }                              
                    if ( !Scl_LibertyReadTable( p, vOut, pTiming, "cell_fall",           vTemples ) )
                        if ( !Scl_LibertyReadTable( p, vOut, pTiming, "cell_rise",       vTemples ) )
                                { printf( "Table cannot be found\n" ); return NULL; }                              
                    if ( !Scl_LibertyReadTable( p, vOut, pTiming, "rise_transition",     vTemples ) )
                        if ( !Scl_LibertyReadTable( p, vOut, pTiming, "fall_transition", vTemples ) )
                                { printf( "Table cannot be found\n" ); return NULL; }                              
                    if ( !Scl_LibertyReadTable( p, vOut, pTiming, "fall_transition",     vTemples ) )
                        if ( !Scl_LibertyReadTable( p, vOut, pTiming, "rise_transition", vTemples ) )
                                { printf( "Table cannot be found\n" ); return NULL; }  
                }
                continue;
            }

            // write the timing tables
            Vec_PtrForEachEntry( char *, vNameIns, pName, i )
            {
                Vec_Ptr_t * vTables[4];
                Vec_Ptr_t * vTimings;
                vTimings = Scl_LibertyReadPinTimingAll( p, pPin, pName );
                Vec_StrPutS_( vOut, pName );
                Vec_StrPutI_( vOut, (int)(Vec_PtrSize(vTimings) != 0) );
                if ( Vec_PtrSize(vTimings) == 0 ) // output does not depend on input
                {
                    Vec_PtrFree( vTimings );
                    continue;
                }
                Vec_StrPutI_( vOut, Scl_LibertyReadTimingSense(p, (Scl_Item_t *)Vec_PtrEntry(vTimings, 0)) );
                Vec_StrPut_( vOut );
                Vec_StrPut_( vOut );
                // collect the timing tables
                for ( k = 0; k < 4; k++ )
                    vTables[k] = Vec_PtrAlloc( 16 );
                Vec_PtrForEachEntry( Scl_Item_t *, vTimings, pTiming, k )
                {
                    // some cells only have 'rise' or 'fall' but not both - here we work around this
                    if ( !Scl_LibertyScanTable( p, vTables[0], pTiming, "cell_rise",           vTemples ) )
                        if ( !Scl_LibertyScanTable( p, vTables[0], pTiming, "cell_fall",       vTemples ) )
                                { printf( "Table cannot be found\n" ); return NULL; }                              
                    if ( !Scl_LibertyScanTable( p, vTables[1], pTiming, "cell_fall",           vTemples ) )
                        if ( !Scl_LibertyScanTable( p, vTables[1], pTiming, "cell_rise",       vTemples ) )
                                { printf( "Table cannot be found\n" ); return NULL; }                              
                    if ( !Scl_LibertyScanTable( p, vTables[2], pTiming, "rise_transition",     vTemples ) )
                        if ( !Scl_LibertyScanTable( p, vTables[2], pTiming, "fall_transition", vTemples ) )
                                { printf( "Table cannot be found\n" ); return NULL; }                              
                    if ( !Scl_LibertyScanTable( p, vTables[3], pTiming, "fall_transition",     vTemples ) )
                        if ( !Scl_LibertyScanTable( p, vTables[3], pTiming, "rise_transition", vTemples ) )
                                { printf( "Table cannot be found\n" ); return NULL; }  
                }
                Vec_PtrFree( vTimings );
                // compute worse case of the tables
                for ( k = 0; k < 4; k++ )
                {
                    Vec_Flt_t * vInd0, * vInd1, * vValues;
                    if ( !Scl_LibertyComputeWorstCase( vTables[k], &vInd0, &vInd1, &vValues ) )
                        { printf( "Table indexes have different values\n" ); return NULL; }  
                    Vec_VecFree( (Vec_Vec_t *)vTables[k] );
                    Scl_LibertyDumpTables( vOut, vInd0, vInd1, vValues );
                    Vec_FltFree( vInd0 );
                    Vec_FltFree( vInd1 );
                    Vec_FltFree( vValues );
                }
            }
        }
        Vec_StrPut_( vOut );
        Vec_PtrFreeFree( vNameIns );
    }
    // free templates
    if ( vTemples )
    {
        Vec_Flt_t * vArray;
        assert( Vec_PtrSize(vTemples) % 4 == 0 );
        Vec_PtrForEachEntry( Vec_Flt_t *, vTemples, vArray, i )
            if ( i % 4 == 0 )
                ABC_FREE( vArray );
            else if ( i % 4 == 2 || i % 4 == 3 )
                Vec_FltFree( vArray );
        Vec_PtrFree( vTemples );
    }
    if ( fVerbose )
    {
        printf( "Library \"%s\" from \"%s\" has %d cells ", 
            Scl_LibertyReadString(p, Scl_LibertyRoot(p)->Head), p->pFileName, nCells );
        printf( "(%d skipped: %d seq; %d tri-state; %d no func).  ", 
            nSkipped[0]+nSkipped[1]+nSkipped[2], nSkipped[0], nSkipped[1], nSkipped[2] );
        Abc_PrintTime( 1, "Time", Abc_Clock() - p->clkStart );
    }
    return vOut;
}

char* Scl_LibertyReadString	(	Scl_Tree_t *	p,
		Scl_Pair_t	Pair
	)

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

Synopsis [Gets the name to write.]

Description []

SideEffects []

SeeAlso []

Definition at line 341 of file sclLiberty.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 ); 
    if ( Pair.Beg < Pair.End && Buffer[0] == '\"' )
    {
        assert( Buffer[Pair.End-Pair.Beg-1] == '\"' );
        Buffer[Pair.End-Pair.Beg-1] = 0;
        return Buffer + 1;
    }
    Buffer[Pair.End-Pair.Beg] = 0;
    return Buffer;
}

int Scl_LibertyReadTable	(	Scl_Tree_t *	p,
		Vec_Str_t *	vOut,
		Scl_Item_t *	pTiming,
		char *	pName,
		Vec_Ptr_t *	vTemples
	)

Definition at line 1174 of file sclLiberty.c.

{
    Vec_Flt_t * vIndex1 = NULL;
    Vec_Flt_t * vIndex2 = NULL;
    Vec_Flt_t * vValues = NULL;
    Vec_Flt_t * vInd1, * vInd2;
    Scl_Item_t * pItem, * pTable = NULL;
    char * pThis, * pTempl = NULL;
    int iPlace, i;
    float Entry;
    // find the table
    Scl_ItemForEachChildName( p, pTiming, pTable, pName )
        break;
    if ( pTable == NULL )
        return 0;
    // find the template
    pTempl = Scl_LibertyReadString(p, pTable->Head);
    if ( pTempl == NULL || pTempl[0] == 0 )
    {
        // read the numbers
        Scl_ItemForEachChild( p, pTable, pItem )
        {
            if ( !Scl_LibertyCompare(p, pItem->Key, "index_1") )
                assert(vIndex1 == NULL), vIndex1 = Scl_LibertyReadFloatVec( Scl_LibertyReadString(p, pItem->Head) );
            else if ( !Scl_LibertyCompare(p, pItem->Key, "index_2") )
                assert(vIndex2 == NULL), vIndex2 = Scl_LibertyReadFloatVec( Scl_LibertyReadString(p, pItem->Head) );
            else if ( !Scl_LibertyCompare(p, pItem->Key, "values") )
                assert(vValues == NULL), vValues = Scl_LibertyReadFloatVec( Scl_LibertyReadString(p, pItem->Head) );
        }
        if ( vIndex1 == NULL || vIndex2 == NULL || vValues == NULL )
            { printf( "Incomplete table specification\n" ); return 0; }
        // dump the table
        vInd1 = vIndex1;
        vInd2 = vIndex2;
        // write entries
        Vec_StrPutI_( vOut, Vec_FltSize(vInd1) );
        Vec_FltForEachEntry( vInd1, Entry, i )
            Vec_StrPutF_( vOut, Entry );
        Vec_StrPut_( vOut );
        // write entries
        Vec_StrPutI_( vOut, Vec_FltSize(vInd2) );
        Vec_FltForEachEntry( vInd2, Entry, i )
            Vec_StrPutF_( vOut, Entry );
        Vec_StrPut_( vOut );
        Vec_StrPut_( vOut );
        // write entries
        assert( Vec_FltSize(vInd1) * Vec_FltSize(vInd2) == Vec_FltSize(vValues) );
        Vec_FltForEachEntry( vValues, Entry, i )
        {
            Vec_StrPutF_( vOut, Entry );
            if ( i % Vec_FltSize(vInd2) == Vec_FltSize(vInd2)-1 )
                Vec_StrPut_( vOut );
        }
    }
    else
    {
        // fetch the template
        iPlace = -1;
        Vec_PtrForEachEntry( char *, vTemples, pThis, i )
            if ( i % 4 == 0 && !strcmp(pTempl, pThis) )
            {  
                iPlace = i;
                break;
            }
        if ( iPlace == -1 )
            { printf( "Template cannot be found in the template library\n" ); return 0; }
        // read the numbers
        Scl_ItemForEachChild( p, pTable, pItem )
        {
            if ( !Scl_LibertyCompare(p, pItem->Key, "index_1") )
                assert(vIndex1 == NULL), vIndex1 = Scl_LibertyReadFloatVec( Scl_LibertyReadString(p, pItem->Head) );
            else if ( !Scl_LibertyCompare(p, pItem->Key, "index_2") )
                assert(vIndex2 == NULL), vIndex2 = Scl_LibertyReadFloatVec( Scl_LibertyReadString(p, pItem->Head) );
            else if ( !Scl_LibertyCompare(p, pItem->Key, "values") )
                assert(vValues == NULL), vValues = Scl_LibertyReadFloatVec( Scl_LibertyReadString(p, pItem->Head) );
        }
        // check the template style
        vInd1 = (Vec_Flt_t *)Vec_PtrEntry( vTemples, iPlace + 2 ); // slew
        vInd2 = (Vec_Flt_t *)Vec_PtrEntry( vTemples, iPlace + 3 ); // load
        if ( Vec_PtrEntry(vTemples, iPlace + 1) == NULL ) // normal order (vIndex1 is slew; vIndex2 is load)
        {
            assert( !vIndex1 || Vec_FltSize(vIndex1) == Vec_FltSize(vInd1) );
            assert( !vIndex2 || Vec_FltSize(vIndex2) == Vec_FltSize(vInd2) );
            vInd1 = vIndex1 ? vIndex1 : vInd1;
            vInd2 = vIndex2 ? vIndex2 : vInd2;
            // write entries
            Vec_StrPutI_( vOut, Vec_FltSize(vInd1) );
            Vec_FltForEachEntry( vInd1, Entry, i )
                Vec_StrPutF_( vOut, Entry );
            Vec_StrPut_( vOut );
            // write entries
            Vec_StrPutI_( vOut, Vec_FltSize(vInd2) );
            Vec_FltForEachEntry( vInd2, Entry, i )
                Vec_StrPutF_( vOut, Entry );
            Vec_StrPut_( vOut );
            Vec_StrPut_( vOut );
            // write entries
            assert( Vec_FltSize(vInd1) * Vec_FltSize(vInd2) == Vec_FltSize(vValues) );
            Vec_FltForEachEntry( vValues, Entry, i )
            {
                Vec_StrPutF_( vOut, Entry );
                if ( i % Vec_FltSize(vInd2) == Vec_FltSize(vInd2)-1 )
                    Vec_StrPut_( vOut );
            }
        }
        else  // reverse order (vIndex2 is slew; vIndex1 is load)
        {
            assert( !vIndex2 || Vec_FltSize(vIndex2) == Vec_FltSize(vInd1) );
            assert( !vIndex1 || Vec_FltSize(vIndex1) == Vec_FltSize(vInd2) );
            vInd1 = vIndex2 ? vIndex2 : vInd1;
            vInd2 = vIndex1 ? vIndex1 : vInd2;
            // write entries
            Vec_StrPutI_( vOut, Vec_FltSize(vInd1) );
            Vec_FltForEachEntry( vInd1, Entry, i )
                Vec_StrPutF_( vOut, Entry );
            Vec_StrPut_( vOut );
            // write entries
            Vec_StrPutI_( vOut, Vec_FltSize(vInd2) );
            Vec_FltForEachEntry( vInd2, Entry, i )
                Vec_StrPutF_( vOut, Entry );
            Vec_StrPut_( vOut );
            Vec_StrPut_( vOut );
            // write entries -- transpose
            assert( Vec_FltSize(vInd1) * Vec_FltSize(vInd2) == Vec_FltSize(vValues) );
            Vec_FltForEachEntry( vValues, Entry, i )
            {
                int x = i % Vec_FltSize(vInd2);
                int y = i / Vec_FltSize(vInd2);
                Entry = Vec_FltEntry( vValues, x * Vec_FltSize(vInd1) + y );
                Vec_StrPutF_( vOut, Entry );
                if ( i % Vec_FltSize(vInd2) == Vec_FltSize(vInd2)-1 )
                    Vec_StrPut_( vOut );
            }
        }
    }
    Vec_StrPut_( vOut );
    for ( i = 0; i < 3; i++ ) 
        Vec_StrPutF_( vOut, 0 );
    for ( i = 0; i < 4; i++ ) 
        Vec_StrPutF_( vOut, 0 );
    for ( i = 0; i < 6; i++ ) 
        Vec_StrPutF_( vOut, 0 );
    Vec_FltFreeP( &vIndex1 );
    Vec_FltFreeP( &vIndex2 );
    Vec_FltFreeP( &vValues );
    Vec_StrPut_( vOut );
    Vec_StrPut_( vOut );
    return 1;
}

Vec_Ptr_t* Scl_LibertyReadTemplates

(

Scl_Tree_t *

p

)

Definition at line 1340 of file sclLiberty.c.

{
    Vec_Ptr_t * vRes = NULL;
    Vec_Flt_t * vIndex1, * vIndex2;
    Scl_Item_t * pTempl, * pItem;
    char * pVar1, * pVar2;
    int fFlag0, fFlag1;
    vRes = Vec_PtrAlloc( 100 );
    Scl_ItemForEachChildName( p, Scl_LibertyRoot(p), pTempl, "lu_table_template" )
    {
        pVar1 = pVar2 = NULL;
        vIndex1 = vIndex2 = NULL;
        Scl_ItemForEachChild( p, pTempl, pItem )
        {
            if ( !Scl_LibertyCompare(p, pItem->Key, "index_1") )
                assert(vIndex1 == NULL), vIndex1 = Scl_LibertyReadFloatVec( Scl_LibertyReadString(p, pItem->Head) );
            else if ( !Scl_LibertyCompare(p, pItem->Key, "index_2") )
                assert(vIndex2 == NULL), vIndex2 = Scl_LibertyReadFloatVec( Scl_LibertyReadString(p, pItem->Head) );
            else if ( !Scl_LibertyCompare(p, pItem->Key, "variable_1") )
                assert(pVar1 == NULL), pVar1 = Abc_UtilStrsav( Scl_LibertyReadString(p, pItem->Head) );
            else if ( !Scl_LibertyCompare(p, pItem->Key, "variable_2") )
                assert(pVar2 == NULL), pVar2 = Abc_UtilStrsav( Scl_LibertyReadString(p, pItem->Head) );
        }
        if ( pVar1 == NULL || pVar2 == NULL )
        {
            ABC_FREE( pVar1 );  
            ABC_FREE( pVar2 );
            Vec_FltFreeP( &vIndex1 );
            Vec_FltFreeP( &vIndex2 );
            continue;
        }
        assert( pVar1 != NULL && pVar2 != NULL );
        fFlag0 = (!strcmp(pVar1, "input_net_transition") && !strcmp(pVar2, "total_output_net_capacitance"));
        fFlag1 = (!strcmp(pVar2, "input_net_transition") && !strcmp(pVar1, "total_output_net_capacitance"));
        ABC_FREE( pVar1 );  
        ABC_FREE( pVar2 );
        if ( !fFlag0 && !fFlag1 )
        {
            Vec_FltFreeP( &vIndex1 );
            Vec_FltFreeP( &vIndex2 );
            continue;
        }
        Vec_PtrPush( vRes, Abc_UtilStrsav( Scl_LibertyReadString(p, pTempl->Head) ) );
        Vec_PtrPush( vRes, fFlag0 ? NULL : (void *)(ABC_PTRINT_T)1 );
        Vec_PtrPush( vRes, fFlag0 ? vIndex1 : vIndex2 );
        Vec_PtrPush( vRes, fFlag0 ? vIndex2 : vIndex1 );
    }
    if ( Vec_PtrSize(vRes) == 0 )
        Abc_Print( 0, "Templates are not defined.\n" );
    // print templates
//    printf( "Found %d templates\n", Vec_PtrSize(vRes)/4 );
//    Scl_LibertyPrintTemplates( vRes );
    return vRes;
}

int Scl_LibertyReadTimeUnit

(

Scl_Tree_t *

p

)

Definition at line 808 of file sclLiberty.c.

{
    Scl_Item_t * pItem;
    Scl_ItemForEachChildName( p, Scl_LibertyRoot(p), pItem, "time_unit" )
    {
        char * pUnit = Scl_LibertyReadString(p, pItem->Head);
        // 9=1ns, 10=100ps, 11=10ps, 12=1ps
        if ( !strcmp(pUnit, "1ns") )
            return 9;
        if ( !strcmp(pUnit, "100ps") )
            return 10;
        if ( !strcmp(pUnit, "10ps") )
            return 11;
        if ( !strcmp(pUnit, "1ps") )
            return 12;
        break;
    }
    printf( "Libery parser cannot read \"time_unit\".  Assuming   time_unit : \"1ns\".\n" );
    return 9;
}

int Scl_LibertyReadTimingSense	(	Scl_Tree_t *	p,
		Scl_Item_t *	pPin
	)

Definition at line 953 of file sclLiberty.c.

{
    Scl_Item_t * pItem;
    Scl_ItemForEachChildName( p, pPin, pItem, "timing_sense" )
    {
        char * pToken = Scl_LibertyReadString(p, pItem->Head);
        if ( !strcmp(pToken, "positive_unate") )
            return sc_ts_Pos;
        if ( !strcmp(pToken, "negative_unate") )
            return sc_ts_Neg;
        if ( !strcmp(pToken, "non_unate") )
            return sc_ts_Non;
        break;
    }
    return sc_ts_Non;
}

void Scl_LibertyReadWireLoad	(	Scl_Tree_t *	p,
		Vec_Str_t *	vOut
	)

Definition at line 849 of file sclLiberty.c.

{
    Scl_Item_t * pItem, * pChild;
    Vec_StrPutI_( vOut, Scl_LibertyItemNum(p, Scl_LibertyRoot(p), "wire_load") );
    Vec_StrPut_( vOut );
    Scl_ItemForEachChildName( p, Scl_LibertyRoot(p), pItem, "wire_load" )
    {
        Vec_StrPutS_( vOut, Scl_LibertyReadString(p, pItem->Head) );
        Scl_ItemForEachChildName( p, pItem, pChild, "capacitance" )
            Vec_StrPutF_( vOut, atof(Scl_LibertyReadString(p, pChild->Head)) );
        Scl_ItemForEachChildName( p, pItem, pChild, "slope" )
            Vec_StrPutF_( vOut, atof(Scl_LibertyReadString(p, pChild->Head)) );
        Vec_StrPut_( vOut );
        Vec_StrPutI_( vOut, Scl_LibertyItemNum(p, pItem, "fanout_length") );
        Vec_StrPut_( vOut );
        Scl_ItemForEachChildName( p, pItem, pChild, "fanout_length" )
        {
            char * pHead  = Scl_LibertyReadString(p, pChild->Head);
            int    First  = atoi( strtok(pHead, " ,") );
            float  Second = atof( strtok(NULL, " ") );
            Vec_StrPutI_( vOut, First );
            Vec_StrPutF_( vOut, Second );
            Vec_StrPut_( vOut );
        }
        Vec_StrPut_( vOut );
    }
    Vec_StrPut_( vOut );
}

void Scl_LibertyReadWireLoadSelect	(	Scl_Tree_t *	p,
		Vec_Str_t *	vOut
	)

Definition at line 877 of file sclLiberty.c.

{
    Scl_Item_t * pItem, * pChild;
    Vec_StrPutI_( vOut, Scl_LibertyItemNum(p, Scl_LibertyRoot(p), "wire_load_selection") );
    Vec_StrPut_( vOut );
    Scl_ItemForEachChildName( p, Scl_LibertyRoot(p), pItem, "wire_load_selection" )
    {
        Vec_StrPutS_( vOut, Scl_LibertyReadString(p, pItem->Head) );
        Vec_StrPut_( vOut );
        Vec_StrPutI_( vOut, Scl_LibertyItemNum(p, pItem, "wire_load_from_area") );
        Vec_StrPut_( vOut );
        Scl_ItemForEachChildName( p, pItem, pChild, "wire_load_from_area" )
        {
            char * pHead  = Scl_LibertyReadString(p, pChild->Head);
            float  First  = atof( strtok(pHead, " ,") );
            float  Second = atof( strtok(NULL, " ,") );
            char * pThird = strtok(NULL, " ");
            if ( pThird[0] == '\"' )
                assert(pThird[strlen(pThird)-1] == '\"'), pThird[strlen(pThird)-1] = 0, pThird++;
            Vec_StrPutF_( vOut, First );
            Vec_StrPutF_( vOut, Second );
            Vec_StrPutS_( vOut, pThird );
            Vec_StrPut_( vOut );
        }
        Vec_StrPut_( vOut );
    }
    Vec_StrPut_( vOut );
}

static Scl_Item_t* Scl_LibertyRoot ( Scl_Tree_t *  p )

inlinestatic

Definition at line 75 of file sclLiberty.c.

{ return p->pItems;                                                 }

int Scl_LibertyScanTable	(	Scl_Tree_t *	p,
		Vec_Ptr_t *	vOut,
		Scl_Item_t *	pTiming,
		char *	pName,
		Vec_Ptr_t *	vTemples
	)

Definition at line 1011 of file sclLiberty.c.

{
    Vec_Flt_t * vIndex1 = NULL;
    Vec_Flt_t * vIndex2 = NULL;
    Vec_Flt_t * vValues = NULL;
    Vec_Flt_t * vInd1, * vInd2;
    Scl_Item_t * pItem, * pTable = NULL;
    char * pThis, * pTempl = NULL;
    int iPlace, i;
    float Entry;
    // find the table
    Scl_ItemForEachChildName( p, pTiming, pTable, pName )
        break;
    if ( pTable == NULL )
        return 0;
    // find the template
    pTempl = Scl_LibertyReadString(p, pTable->Head);
    if ( pTempl == NULL || pTempl[0] == 0 )
    {
        // read the numbers
        Scl_ItemForEachChild( p, pTable, pItem )
        {
            if ( !Scl_LibertyCompare(p, pItem->Key, "index_1") )
                assert(vIndex1 == NULL), vIndex1 = Scl_LibertyReadFloatVec( Scl_LibertyReadString(p, pItem->Head) );
            else if ( !Scl_LibertyCompare(p, pItem->Key, "index_2") )
                assert(vIndex2 == NULL), vIndex2 = Scl_LibertyReadFloatVec( Scl_LibertyReadString(p, pItem->Head) );
            else if ( !Scl_LibertyCompare(p, pItem->Key, "values") )
                assert(vValues == NULL), vValues = Scl_LibertyReadFloatVec( Scl_LibertyReadString(p, pItem->Head) );
        }
        if ( vIndex1 == NULL || vIndex2 == NULL || vValues == NULL )
            { printf( "Incomplete table specification\n" ); return 0; }
        // dump the table
        vInd1 = vIndex1;
        vInd2 = vIndex2;
        // write entries
        Vec_PtrPush( vOut, vInd1 );
        Vec_PtrPush( vOut, vInd2 );
        Vec_PtrPush( vOut, vValues );
    }
    else if ( !strcmp(pTempl, "scalar") )
    {
        Scl_ItemForEachChild( p, pTable, pItem )
            if ( !Scl_LibertyCompare(p, pItem->Key, "values") )
            {
                assert(vValues == NULL);
                vValues = Scl_LibertyReadFloatVec( Scl_LibertyReadString(p, pItem->Head) );
                assert( Vec_FltSize(vValues) == 1 );
                // write entries
                Vec_PtrPush( vOut, Vec_IntStart(1) );
                Vec_PtrPush( vOut, Vec_IntStart(1) );
                Vec_PtrPush( vOut, vValues );
                break;
            }
            else
            { printf( "Cannot read \"scalar\" template\n" ); return 0; }
    }
    else
    {
        // fetch the template
        iPlace = -1;
        Vec_PtrForEachEntry( char *, vTemples, pThis, i )
            if ( i % 4 == 0 && !strcmp(pTempl, pThis) )
            {  
                iPlace = i;
                break;
            }
        if ( iPlace == -1 )
            { printf( "Template cannot be found in the template library\n" ); return 0; }
        // read the numbers
        Scl_ItemForEachChild( p, pTable, pItem )
        {
            if ( !Scl_LibertyCompare(p, pItem->Key, "index_1") )
                assert(vIndex1 == NULL), vIndex1 = Scl_LibertyReadFloatVec( Scl_LibertyReadString(p, pItem->Head) );
            else if ( !Scl_LibertyCompare(p, pItem->Key, "index_2") )
                assert(vIndex2 == NULL), vIndex2 = Scl_LibertyReadFloatVec( Scl_LibertyReadString(p, pItem->Head) );
            else if ( !Scl_LibertyCompare(p, pItem->Key, "values") )
                assert(vValues == NULL), vValues = Scl_LibertyReadFloatVec( Scl_LibertyReadString(p, pItem->Head) );
        }
        // check the template style
        vInd1 = (Vec_Flt_t *)Vec_PtrEntry( vTemples, iPlace + 2 ); // slew
        vInd2 = (Vec_Flt_t *)Vec_PtrEntry( vTemples, iPlace + 3 ); // load
        if ( Vec_PtrEntry(vTemples, iPlace + 1) == NULL ) // normal order (vIndex1 is slew; vIndex2 is load)
        {
            assert( !vIndex1 || Vec_FltSize(vIndex1) == Vec_FltSize(vInd1) );
            assert( !vIndex2 || Vec_FltSize(vIndex2) == Vec_FltSize(vInd2) );
            vInd1 = vIndex1 ? vIndex1 : vInd1;
            vInd2 = vIndex2 ? vIndex2 : vInd2;
            // write entries
            Vec_PtrPush( vOut, Vec_FltDup(vInd1) );
            Vec_PtrPush( vOut, Vec_FltDup(vInd2) );
            Vec_PtrPush( vOut, Vec_FltDup(vValues) );
        }
        else  // reverse order (vIndex2 is slew; vIndex1 is load)
        {
            Vec_Flt_t * vValues2 = Vec_FltAlloc( Vec_FltSize(vValues) );
            assert( !vIndex2 || Vec_FltSize(vIndex2) == Vec_FltSize(vInd1) );
            assert( !vIndex1 || Vec_FltSize(vIndex1) == Vec_FltSize(vInd2) );
            vInd1 = vIndex2 ? vIndex2 : vInd1;
            vInd2 = vIndex1 ? vIndex1 : vInd2;
            // write entries -- transpose
            assert( Vec_FltSize(vInd1) * Vec_FltSize(vInd2) == Vec_FltSize(vValues) );
            Vec_FltForEachEntry( vValues, Entry, i )
            {
                int x = i % Vec_FltSize(vInd2);
                int y = i / Vec_FltSize(vInd2);
                Entry = Vec_FltEntry( vValues, x * Vec_FltSize(vInd1) + y );
                Vec_FltPush( vValues2, Entry );
            }
            assert( Vec_FltSize(vValues) == Vec_FltSize(vValues2) );
            // write entries
            Vec_PtrPush( vOut, Vec_FltDup(vInd1) );
            Vec_PtrPush( vOut, Vec_FltDup(vInd2) );
            Vec_PtrPush( vOut, vValues2 );
        }
        Vec_FltFreeP( &vIndex1 );
        Vec_FltFreeP( &vIndex2 );
        Vec_FltFreeP( &vValues );
    }
    return 1;
}

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

inlinestatic

Definition at line 237 of file sclLiberty.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 Scl_LibertySkipSpaces ( Scl_Tree_t *  p, char **  ppPos, char *  pEnd, int  fStopAtNewLine  )

inlinestatic

Definition at line 219 of file sclLiberty.c.

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

Scl_Tree_t* Scl_LibertyStart

(

char *

pFileName

)

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

Synopsis [Starts the parsing manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 537 of file sclLiberty.c.

{
    Scl_Tree_t * p;
    int RetValue;
    // read the file into the buffer
    Scl_LibertyFixFileName( pFileName );
    RetValue = Scl_LibertyFileSize( pFileName );
    if ( RetValue == 0 )
        return NULL;
    // start the manager
    p = ABC_ALLOC( Scl_Tree_t, 1 );
    memset( p, 0, sizeof(Scl_Tree_t) );
    p->clkStart  = Abc_Clock();
    p->nContents = RetValue;
    p->pContents = Scl_LibertyFileContents( pFileName, p->nContents );
    // other 
    p->pFileName = Abc_UtilStrsav( pFileName );
    p->nItermAlloc = 10 + Scl_LibertyCountItems( p->pContents, p->pContents+p->nContents );
    p->pItems = ABC_CALLOC( Scl_Item_t, p->nItermAlloc );
    p->nItems = 0;
    p->nLines = 1;
    return p;
}

void Scl_LibertyStop	(	Scl_Tree_t *	p,
		int	fVerbose
	)

Definition at line 560 of file sclLiberty.c.

{
    if ( fVerbose )
    {
        printf( "Memory = %7.2f MB. ", 1.0 * (p->nContents + p->nItermAlloc * sizeof(Scl_Item_t))/(1<<20) );
        ABC_PRT( "Time", Abc_Clock() - p->clkStart );
    }
    ABC_FREE( p->pFileName );
    ABC_FREE( p->pContents );
    ABC_FREE( p->pItems );
    ABC_FREE( p->pError );
    ABC_FREE( p );
}

void Scl_LibertyStringDump	(	char *	pFileName,
		Vec_Str_t *	vStr
	)

Definition at line 513 of file sclLiberty.c.

{
    FILE * pFile = fopen( pFileName, "wb" );
    int RetValue;
    if ( pFile == NULL )
    {
        printf( "Scl_LibertyStringDump(): The output file is unavailable.\n" );
        return;
    }
    RetValue = fwrite( Vec_StrArray(vStr), 1, Vec_StrSize(vStr), pFile );
    fclose( pFile );
}

void Scl_LibertyTest

(

)

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

Synopsis [Experiments with Liberty parsing.]

Description []

SideEffects []

SeeAlso []

Definition at line 1662 of file sclLiberty.c.

{
    char * pFileName = "bwrc.lib";
    int fVerbose = 1;
    int fVeryVerbose = 0;
    Scl_Tree_t * p;
    Vec_Str_t * vStr;
//    return;
    p = Scl_LibertyParse( pFileName, fVeryVerbose );
    if ( p == NULL )
        return;
//    Scl_LibertyParseDump( p, "temp_.lib" );
    vStr = Scl_LibertyReadSclStr( p, fVerbose, fVeryVerbose );
    Scl_LibertyStringDump( "test_scl.lib", vStr );
    Vec_StrFree( vStr );
    Scl_LibertyStop( p, fVerbose );
}

static Scl_Pair_t Scl_LibertyUpdateHead ( Scl_Tree_t *  p, Scl_Pair_t  Head  )

inlinestatic

Definition at line 294 of file sclLiberty.c.

{
    Scl_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 ( Scl_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 Scl_LibertyWipeOutComments	(	char *	pBeg,
		char *	pEnd
	)

Definition at line 191 of file sclLiberty.c.

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

static void Scl_PrintSpace ( FILE *  pFile, int  nOffset  )

inlinestatic

Definition at line 79 of file sclLiberty.c.

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

static void Scl_PrintWord ( FILE *  pFile, Scl_Tree_t *  p, Scl_Pair_t  Pair  )

inlinestatic

Definition at line 78 of file sclLiberty.c.

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

static void Vec_StrPut_ ( Vec_Str_t *  vOut )

inlinestatic

Definition at line 773 of file sclLiberty.c.

{ }

static void Vec_StrPutF_ ( Vec_Str_t *  vOut, float  Val  )

inlinestatic

Definition at line 771 of file sclLiberty.c.

{ Vec_StrPutF( vOut, Val );  }

static void Vec_StrPutI_ ( Vec_Str_t *  vOut, int  Val  )

inlinestatic

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

Synopsis [Enabling debug output.]

Description []

SideEffects []

SeeAlso []

Definition at line 769 of file sclLiberty.c.

{ Vec_StrPutI( vOut, Val );  }

static void Vec_StrPutS_ ( Vec_Str_t *  vOut, char *  Val  )

inlinestatic

Definition at line 772 of file sclLiberty.c.

{ Vec_StrPutS( vOut, Val );  }

static void Vec_StrPutW_ ( Vec_Str_t *  vOut, word  Val  )

inlinestatic

Definition at line 770 of file sclLiberty.c.

{ Vec_StrPutW( vOut, Val );  }