ver.h File Reference

#include <stdio.h>
#include "base/abc/abc.h"

Include dependency graph for ver.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	Ver_Man_t_

Typedefs
typedef typedefABC_NAMESPACE_HEADER_START struct Ver_Man_t_	Ver_Man_t
	INCLUDES ///.
typedef struct Ver_Stream_t_	Ver_Stream_t

Functions
Abc_Des_t *	Ver_ParseFile (char *pFileName, Abc_Des_t *pGateLib, int fCheck, int fUseMemMan)
	MACRO DEFINITIONS ///.
void	Ver_ParsePrintErrorMessage (Ver_Man_t *p)
void *	Ver_FormulaParser (char *pFormula, void *pMan, Vec_Ptr_t *vNames, Vec_Ptr_t *vStackFn, Vec_Int_t *vStackOp, char *pErrorMessage)
	FUNCTION DEFINITIONS ///.
void *	Ver_FormulaReduction (char *pFormula, void *pMan, Vec_Ptr_t *vNames, char *pErrorMessage)
int	Ver_ParseSkipComments (Ver_Man_t *p)
	DECLARATIONS ///.
char *	Ver_ParseGetName (Ver_Man_t *p)
Ver_Stream_t *	Ver_StreamAlloc (char *pFileName)
	FUNCTION DEFINITIONS ///.
void	Ver_StreamFree (Ver_Stream_t *p)
char *	Ver_StreamGetFileName (Ver_Stream_t *p)
int	Ver_StreamGetFileSize (Ver_Stream_t *p)
int	Ver_StreamGetCurPosition (Ver_Stream_t *p)
int	Ver_StreamGetLineNumber (Ver_Stream_t *p)
int	Ver_StreamIsOkey (Ver_Stream_t *p)
char	Ver_StreamScanChar (Ver_Stream_t *p)
char	Ver_StreamPopChar (Ver_Stream_t *p)
void	Ver_StreamSkipChars (Ver_Stream_t *p, char *pCharsToSkip)
void	Ver_StreamSkipToChars (Ver_Stream_t *p, char *pCharsToStop)
char *	Ver_StreamGetWord (Ver_Stream_t *p, char *pCharsToStop)

Typedef Documentation

Ver_Man_t

typedef typedefABC_NAMESPACE_HEADER_START struct Ver_Man_t_ Ver_Man_t

INCLUDES ///.

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

FileName [ver.h]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Verilog parser.]

Synopsis [External declarations.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - August 19, 2006.]

Revision [

Id

ver.h,v 1.00 2006/08/19 00:00:00 alanmi Exp

] PARAMETERS /// BASIC TYPES ///

Definition at line 45 of file ver.h.

Ver_Stream_t

typedef struct Ver_Stream_t_ Ver_Stream_t

Definition at line 46 of file ver.h.

Function Documentation

Ver_FormulaParser()

void * Ver_FormulaParser ( char * pFormula, void * pMan, Vec_Ptr_t * vNames, Vec_Ptr_t * vStackFn, Vec_Int_t * vStackOp, char * pErrorMessage )

extern

FUNCTION DEFINITIONS ///.

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

Synopsis [Parser of the formula encountered in assign statements.]

Description []

SideEffects []

SeeAlso []

Definition at line 76 of file verFormula.c.

{
    char * pTemp;
    Hop_Obj_t * bFunc, * bTemp;
    int nParans, Flag;
    int Oper, Oper1, Oper2;
    int v;
 
    // clear the stacks and the names
    Vec_PtrClear( vNames );
    Vec_PtrClear( vStackFn );
    Vec_IntClear( vStackOp );
 
    if ( !strcmp(pFormula, "0") || !strcmp(pFormula, "1\'b0") )
        return Hop_ManConst0((Hop_Man_t *)pMan);
    if ( !strcmp(pFormula, "1") || !strcmp(pFormula, "1\'b1") )
        return Hop_ManConst1((Hop_Man_t *)pMan);
 
    // make sure that the number of opening and closing parentheses is the same
    nParans = 0;
    for ( pTemp = pFormula; *pTemp; pTemp++ )
        if ( *pTemp == '(' )
            nParans++;
        else if ( *pTemp == ')' )
            nParans--;
    if ( nParans != 0 )
    {
        sprintf( pErrorMessage, "Parse_FormulaParser(): Different number of opening and closing parentheses ()." );
        return NULL;
    }
 
    // add parentheses
    pTemp = pFormula + strlen(pFormula) + 2;
    *pTemp-- = 0; *pTemp = ')';
    while ( --pTemp != pFormula )
        *pTemp = *(pTemp - 1);
    *pTemp = '(';
 
    // perform parsing
    Flag = VER_PARSE_FLAG_START;
    for ( pTemp = pFormula; *pTemp; pTemp++ )
    {
        switch ( *pTemp )
        {
        // skip all spaces, tabs, and end-of-lines
        case ' ':
        case '\t':
        case '\r':
        case '\n':
            continue;
/*
        // treat Constant 0 as a variable
        case VER_PARSE_SYM_CONST0:
            Vec_PtrPush( vStackFn, Hop_ManConst0(pMan) );  // Cudd_Ref( Hop_ManConst0(pMan) );
            if ( Flag == VER_PARSE_FLAG_VAR )
            {
                sprintf( pErrorMessage, "Parse_FormulaParser(): No operation symbol before constant 0." );
                Flag = VER_PARSE_FLAG_ERROR; 
                break;
            }
            Flag = VER_PARSE_FLAG_VAR; 
            break;
 
        // the same for Constant 1
        case VER_PARSE_SYM_CONST1:
            Vec_PtrPush( vStackFn, Hop_ManConst1(pMan) );  //  Cudd_Ref( Hop_ManConst1(pMan) );
            if ( Flag == VER_PARSE_FLAG_VAR )
            {
                sprintf( pErrorMessage, "Parse_FormulaParser(): No operation symbol before constant 1." );
                Flag = VER_PARSE_FLAG_ERROR; 
                break;
            }
            Flag = VER_PARSE_FLAG_VAR; 
            break;
*/
        case VER_PARSE_SYM_NEGBEF1:
        case VER_PARSE_SYM_NEGBEF2:
            if ( Flag == VER_PARSE_FLAG_VAR )
            {// if NEGBEF follows a variable, AND is assumed
                sprintf( pErrorMessage, "Parse_FormulaParser(): Variable before negation." );
                Flag = VER_PARSE_FLAG_ERROR; 
                break;
            }
            Vec_IntPush( vStackOp, VER_PARSE_OPER_NEG );
            break;
 
        case VER_PARSE_SYM_AND:
        case VER_PARSE_SYM_OR:
        case VER_PARSE_SYM_XOR:
        case VER_PARSE_SYM_MUX1:
        case VER_PARSE_SYM_MUX2:
            if ( Flag != VER_PARSE_FLAG_VAR )
            {
                sprintf( pErrorMessage, "Parse_FormulaParser(): There is no variable before AND, EXOR, or OR." );
                Flag = VER_PARSE_FLAG_ERROR; 
                break;
            }
            if ( *pTemp == VER_PARSE_SYM_AND )
                Vec_IntPush( vStackOp, VER_PARSE_OPER_AND );
            else if ( *pTemp == VER_PARSE_SYM_OR )
                Vec_IntPush( vStackOp, VER_PARSE_OPER_OR );
            else if ( *pTemp == VER_PARSE_SYM_XOR )
                Vec_IntPush( vStackOp, VER_PARSE_OPER_XOR );
            else if ( *pTemp == VER_PARSE_SYM_MUX1 )
                Vec_IntPush( vStackOp, VER_PARSE_OPER_MUX );
//            else if ( *pTemp == VER_PARSE_SYM_MUX2 )
//                Vec_IntPush( vStackOp, VER_PARSE_OPER_MUX );
            Flag = VER_PARSE_FLAG_OPER; 
            break;
 
        case VER_PARSE_SYM_OPEN:
            if ( Flag == VER_PARSE_FLAG_VAR )
            {
                sprintf( pErrorMessage, "Parse_FormulaParser(): Variable before a parenthesis." );
                Flag = VER_PARSE_FLAG_ERROR; 
                break;
            }
            Vec_IntPush( vStackOp, VER_PARSE_OPER_MARK );
            // after an opening bracket, it feels like starting over again
            Flag = VER_PARSE_FLAG_START; 
            break;
 
        case VER_PARSE_SYM_CLOSE:
            if ( Vec_IntSize( vStackOp ) )
            {
                while ( 1 )
                {
                    if ( !Vec_IntSize( vStackOp ) )
                    {
                        sprintf( pErrorMessage, "Parse_FormulaParser(): There is no opening parenthesis\n" );
                        Flag = VER_PARSE_FLAG_ERROR; 
                        break;
                    }
                    Oper = Vec_IntPop( vStackOp );
                    if ( Oper == VER_PARSE_OPER_MARK )
                        break;
                    // skip the second MUX operation
//                    if ( Oper == VER_PARSE_OPER_MUX2 )
//                    {
//                        Oper = Vec_IntPop( vStackOp );
//                        assert( Oper == VER_PARSE_OPER_MUX1 );
//                    }
 
                    // perform the given operation
                    if ( Ver_FormulaParserTopOper( (Hop_Man_t *)pMan, vStackFn, Oper ) == NULL )
                    {
                        sprintf( pErrorMessage, "Parse_FormulaParser(): Unknown operation\n" );
                        return NULL;
                    }
                }
            }
            else
            {
                sprintf( pErrorMessage, "Parse_FormulaParser(): There is no opening parenthesis\n" );
                Flag = VER_PARSE_FLAG_ERROR; 
                break;
            }
            if ( Flag != VER_PARSE_FLAG_ERROR )
                Flag = VER_PARSE_FLAG_VAR; 
            break;
 
 
        default:
            // scan the next name
            v = Ver_FormulaParserFindVar( pTemp, vNames );
            if ( *pTemp == '\\' )
                pTemp++;
            pTemp += (int)(ABC_PTRUINT_T)Vec_PtrEntry( vNames, 2*v ) - 1;
 
            // assume operation AND, if vars follow one another
            if ( Flag == VER_PARSE_FLAG_VAR )
            {
                sprintf( pErrorMessage, "Parse_FormulaParser(): Incorrect state." );
                return NULL;
            }
            bTemp = Hop_IthVar( (Hop_Man_t *)pMan, v );
            Vec_PtrPush( vStackFn, bTemp ); //  Cudd_Ref( bTemp );
            Flag = VER_PARSE_FLAG_VAR; 
            break;
        }
 
        if ( Flag == VER_PARSE_FLAG_ERROR )
            break;      // error exit
        else if ( Flag == VER_PARSE_FLAG_START )
            continue;  //  go on parsing
        else if ( Flag == VER_PARSE_FLAG_VAR )
            while ( 1 )
            {  // check if there are negations in the OpStack     
                if ( !Vec_IntSize(vStackOp) )
                    break;
                Oper = Vec_IntPop( vStackOp );
                if ( Oper != VER_PARSE_OPER_NEG )
                {
                    Vec_IntPush( vStackOp, Oper );
                    break;
                }
                else
                {
//                      Vec_PtrPush( vStackFn, Cudd_Not(Vec_PtrPop(vStackFn)) );
                      Vec_PtrPush( vStackFn, Hop_Not((Hop_Obj_t *)Vec_PtrPop(vStackFn)) );
                }
            }
        else // if ( Flag == VER_PARSE_FLAG_OPER )
            while ( 1 )
            {  // execute all the operations in the OpStack
               // with precedence higher or equal than the last one
                Oper1 = Vec_IntPop( vStackOp ); // the last operation
                if ( !Vec_IntSize(vStackOp) ) 
                {  // if it is the only operation, push it back
                    Vec_IntPush( vStackOp, Oper1 );
                    break;
                }
                Oper2 = Vec_IntPop( vStackOp ); // the operation before the last one
                if ( Oper2 >= Oper1 && !(Oper1 == Oper2 && Oper1 == VER_PARSE_OPER_MUX) )  
                {  // if Oper2 precedence is higher or equal, execute it
                    if ( Ver_FormulaParserTopOper( (Hop_Man_t *)pMan, vStackFn, Oper2 ) == NULL )
                    {
                        sprintf( pErrorMessage, "Parse_FormulaParser(): Unknown operation\n" );
                        return NULL;
                    }
                    Vec_IntPush( vStackOp,  Oper1 );     // push the last operation back
                }
                else
                {  // if Oper2 precedence is lower, push them back and done
                    Vec_IntPush( vStackOp, Oper2 );
                    Vec_IntPush( vStackOp, Oper1 );
                    break;
                }
            }
    }
 
    if ( Flag != VER_PARSE_FLAG_ERROR )
    {
        if ( Vec_PtrSize(vStackFn) )
        {    
            bFunc = (Hop_Obj_t *)Vec_PtrPop(vStackFn);
            if ( !Vec_PtrSize(vStackFn) )
                if ( !Vec_IntSize(vStackOp) )
                {
//                    Cudd_Deref( bFunc );
                    return bFunc;
                }
                else
                    sprintf( pErrorMessage, "Parse_FormulaParser(): Something is left in the operation stack\n" );
            else
                sprintf( pErrorMessage, "Parse_FormulaParser(): Something is left in the function stack\n" );
        }
        else
            sprintf( pErrorMessage, "Parse_FormulaParser(): The input string is empty\n" );
    }
//    Cudd_Ref( bFunc );
//    Cudd_RecursiveDeref( dd, bFunc );
    return NULL;
}

Here is the call graph for this function:

Ver_FormulaReduction()

void * Ver_FormulaReduction ( char * pFormula, void * pMan, Vec_Ptr_t * vNames, char * pErrorMessage )

extern

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

Synopsis [Returns the AIG representation of the reduction formula.]

Description []

SideEffects []

SeeAlso []

Definition at line 435 of file verFormula.c.

{
    Hop_Obj_t * pRes = NULL;
    int v, fCompl;
    char Symbol;
 
    // get the operation
    Symbol = *pFormula++;
    fCompl = ( Symbol == '~' );
    if ( fCompl )
        Symbol = *pFormula++;
    // check the operation
    if ( Symbol != '&' && Symbol != '|' && Symbol != '^' )
    {
        sprintf( pErrorMessage, "Ver_FormulaReduction(): Unknown operation (%c)\n", Symbol );
        return NULL;
    }
    // skip the brace
    while ( *pFormula++ != '{' );
    // parse the names
    Vec_PtrClear( vNames );
    while ( *pFormula != '}' )
    {
        v = Ver_FormulaParserFindVar( pFormula, vNames );
        pFormula += (int)(ABC_PTRUINT_T)Vec_PtrEntry( vNames, 2*v );
        while ( *pFormula == ' ' || *pFormula == ',' )
            pFormula++;
    }
    // compute the function
    if ( Symbol == '&' )
        pRes = Hop_CreateAnd( (Hop_Man_t *)pMan, Vec_PtrSize(vNames)/2 );
    else if ( Symbol == '|' )
        pRes = Hop_CreateOr( (Hop_Man_t *)pMan, Vec_PtrSize(vNames)/2 );
    else if ( Symbol == '^' )
        pRes = Hop_CreateExor( (Hop_Man_t *)pMan, Vec_PtrSize(vNames)/2 );
    return Hop_NotCond( pRes, fCompl );
}

Here is the call graph for this function:

Ver_ParseFile()

Abc_Des_t * Ver_ParseFile ( char * pFileName, Abc_Des_t * pGateLib, int fCheck, int fUseMemMan )

extern

MACRO DEFINITIONS ///.

ITERATORS /// FUNCTION DECLARATIONS ///

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

Synopsis [File parser.]

Description []

SideEffects []

SeeAlso []

Definition at line 165 of file verCore.c.

{
    Ver_Man_t * p;
    Abc_Des_t * pDesign;
    // start the parser
    p = Ver_ParseStart( pFileName, pGateLib );
    p->fMapped    = glo_fMapped;
    p->fCheck     = fCheck;
    p->fUseMemMan = fUseMemMan;
    if ( glo_fMapped )
    {
        Hop_ManStop((Hop_Man_t *)p->pDesign->pManFunc);
        p->pDesign->pManFunc = NULL;
    }
    // parse the file
    Ver_ParseInternal( p );
    // save the result
    pDesign = p->pDesign;
    p->pDesign = NULL;
    // stop the parser
    Ver_ParseStop( p );
    return pDesign;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Ver_ParseGetName()

char * Ver_ParseGetName ( Ver_Man_t * pMan )

extern

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

Synopsis [Parses a Verilog name that can be being with a slash.]

Description []

SideEffects []

SeeAlso []

Definition at line 91 of file verParse.c.

{
    Ver_Stream_t * p = pMan->pReader;
    char Symbol;
    char * pWord;
    pMan->fNameLast = 0;
    if ( !Ver_StreamIsOkey(p) )
        return NULL;
    if ( !Ver_ParseSkipComments( pMan ) )
        return NULL;
    Symbol = Ver_StreamScanChar( p );
    if ( Symbol == '\\' )
    {
        pMan->fNameLast = 1;
        Ver_StreamPopChar( p );
        pWord = Ver_StreamGetWord( p, " \r\n" );
        Ver_StreamSkipChars( p, " \r\n" );
        if ( Ver_StreamScanChar(p) == '[' )
        {
            char This, * pEnd = pWord + strlen( pWord );
            while ( (This = Ver_StreamPopChar(p)) != ']' )
                *pEnd++ = This;
            *pEnd++ = This;
            *pEnd = 0;
        }
    }
    else
        pWord = Ver_StreamGetWord( p, " \t\n\r(),;" );
    if ( Ver_StreamIsOkey(p) && !Ver_ParseSkipComments( pMan ) )
        return NULL;
    return pWord;
}

Here is the call graph for this function:

Ver_ParsePrintErrorMessage()

void Ver_ParsePrintErrorMessage ( Ver_Man_t * p )

extern

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

Synopsis [Prints the error message including the file name and line number.]

Description []

SideEffects []

SeeAlso []

Definition at line 278 of file verCore.c.

{
    p->fError = 1;
    if ( p->fTopLevel ) // the line number is not given
        fprintf( p->Output, "%s: %s\n", p->pFileName, p->sError );
    else // print the error message with the line number
        fprintf( p->Output, "%s (line %d): %s\n", 
            p->pFileName, Ver_StreamGetLineNumber(p->pReader), p->sError );
    // free the data
    Ver_ParseFreeData( p );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Ver_ParseSkipComments()

int Ver_ParseSkipComments ( Ver_Man_t * pMan )

extern

DECLARATIONS ///.

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

FileName [verParse.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Verilog parser.]

Synopsis [Performs some Verilog parsing tasks.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - August 19, 2006.]

Revision [

Id

verParse.c,v 1.00 2006/08/19 00:00:00 alanmi Exp

] FUNCTION DEFINITIONS /// Function*************************************************************

Synopsis [Skips the comments of they are present.]

Description []

SideEffects []

SeeAlso []

Definition at line 45 of file verParse.c.

{
    Ver_Stream_t * p = pMan->pReader;
    char Symbol;
    // skip spaces
    Ver_StreamSkipChars( p, " \t\n\r" );
    if ( !Ver_StreamIsOkey(pMan->pReader) )
        return 1;
    // read the first symbol
    Symbol = Ver_StreamScanChar( p );
    if ( Symbol != '/' )
        return 1;
    Ver_StreamPopChar( p );
    // read the second symbol
    Symbol = Ver_StreamScanChar( p );
    if ( Symbol == '/' )
    { // skip till the end of line
        Ver_StreamSkipToChars( p, "\n" );
        return Ver_ParseSkipComments( pMan );
    }
    if ( Symbol == '*' )
    { // skip till the next occurrence of */
        Ver_StreamPopChar( p );
        do {
            Ver_StreamSkipToChars( p, "*" );
            Ver_StreamPopChar( p );
        } while ( Ver_StreamScanChar( p ) != '/' );
        Ver_StreamPopChar( p );
        return Ver_ParseSkipComments( pMan );
    }
    sprintf( pMan->sError, "Cannot parse after symbol \"/\"." );
    Ver_ParsePrintErrorMessage( pMan );
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Ver_StreamAlloc()

Ver_Stream_t * Ver_StreamAlloc ( char * pFileName )

extern

FUNCTION DEFINITIONS ///.

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

Synopsis [Starts the file reader for the given file.]

Description []

SideEffects []

SeeAlso []

Definition at line 74 of file verStream.c.

{
    Ver_Stream_t * p;
    FILE * pFile;
    int nCharsToRead;
    int RetValue;
    // check if the file can be opened
    pFile = fopen( pFileName, "rb" );
    if ( pFile == NULL )
    {
        printf( "Ver_StreamAlloc(): Cannot open input file \"%s\".\n", pFileName );
        return NULL;
    }
    // start the file reader    
    p = ABC_ALLOC( Ver_Stream_t, 1 );
    memset( p, 0, sizeof(Ver_Stream_t) );
    p->pFileName   = pFileName;
    p->pFile       = pFile;
    // get the file size, in bytes
    fseek( pFile, 0, SEEK_END );  
    p->nFileSize = ftell( pFile );  
    rewind( pFile ); 
    // allocate the buffer
    p->pBuffer = ABC_ALLOC( char, VER_BUFFER_SIZE+1 );
    p->nBufferSize = VER_BUFFER_SIZE;
    p->pBufferCur  = p->pBuffer;
    // determine how many chars to read
    nCharsToRead = VER_MINIMUM(p->nFileSize, VER_BUFFER_SIZE);
    // load the first part into the buffer
    RetValue = fread( p->pBuffer, nCharsToRead, 1, p->pFile );
    p->nFileRead = nCharsToRead;
    // set the ponters to the end and the stopping point
    p->pBufferEnd  = p->pBuffer + nCharsToRead;
    p->pBufferStop = (p->nFileRead == p->nFileSize)? p->pBufferEnd : p->pBuffer + VER_BUFFER_SIZE - VER_OFFSET_SIZE;
    // start the arrays
    p->nLineCounter = 1; // 1-based line counting
    return p;
}

Here is the call graph for this function:

Ver_StreamFree()

void Ver_StreamFree ( Ver_Stream_t * p )

extern

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

Synopsis [Stops the file reader.]

Description []

SideEffects []

SeeAlso []

Definition at line 157 of file verStream.c.

{
    if ( p->pFile )
        fclose( p->pFile );
    ABC_FREE( p->pBuffer );
    ABC_FREE( p );
}

Ver_StreamGetCurPosition()

int Ver_StreamGetCurPosition ( Ver_Stream_t * p )

extern

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

Synopsis [Returns the current reading position.]

Description []

SideEffects []

SeeAlso []

Definition at line 208 of file verStream.c.

{
    return p->nFileRead - (p->pBufferEnd - p->pBufferCur);
}

Ver_StreamGetFileName()

char * Ver_StreamGetFileName ( Ver_Stream_t * p )

extern

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

Synopsis [Returns the file size.]

Description []

SideEffects []

SeeAlso []

Definition at line 176 of file verStream.c.

{
    return p->pFileName;
}

Ver_StreamGetFileSize()

int Ver_StreamGetFileSize ( Ver_Stream_t * p )

extern

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

Synopsis [Returns the file size.]

Description []

SideEffects []

SeeAlso []

Definition at line 192 of file verStream.c.

{
    return p->nFileSize;
}

Ver_StreamGetLineNumber()

int Ver_StreamGetLineNumber ( Ver_Stream_t * p )

extern

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

Synopsis [Returns the line number for the given token.]

Description []

SideEffects []

SeeAlso []

Definition at line 224 of file verStream.c.

{
    return p->nLineCounter;
}

Here is the caller graph for this function:

Ver_StreamGetWord()

char * Ver_StreamGetWord ( Ver_Stream_t * p, char * pCharsToStop )

extern

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

Synopsis [Returns current word delimited by the set of symbols.]

Description [Modifies the stream by inserting 0 at the first encounter of one of the symbols in the list.]

SideEffects []

SeeAlso []

Definition at line 397 of file verStream.c.

{
    char * pChar, * pTemp;
    if ( p->fStop )
        return NULL;
    assert( pCharsToStop != NULL );
    // check if the new data should to be loaded
    if ( p->pBufferCur > p->pBufferStop )
        Ver_StreamReload( p );
    // skip the symbols
    p->nChars = 0;
    for ( pChar = p->pBufferCur; pChar < p->pBufferEnd; pChar++ )
    {
        // skip symbols as long as they are NOT in the list
        for ( pTemp = pCharsToStop; *pTemp; pTemp++ )
            if ( *pChar == *pTemp )
                break;
        if ( *pTemp == 0 ) // pChar is not found in the list
        {
            p->pChars[p->nChars++] = *pChar;
            if ( p->nChars == VER_WORD_SIZE )
            {
                printf( "Ver_StreamGetWord(): The buffer size is exceeded.\n" );
                return NULL;
            }
            // count the lines
            if ( *pChar == '\n' )
                p->nLineCounter++;
            continue;
        }
        // the symbol is found - move the position, set the word end, return the word
        p->pBufferCur = pChar;
        p->pChars[p->nChars] = 0;
        return p->pChars;
    }
    // the file is finished or the last part continued 
    // through VER_OFFSET_SIZE chars till the end of the buffer
    if ( p->pBufferStop == p->pBufferEnd ) // end of file
    {
        p->fStop = 1;
        p->pChars[p->nChars] = 0;
        return p->pChars;
    }
    printf( "Ver_StreamGetWord() failed to parse the file \"%s\".\n", p->pFileName );
    return NULL;
}

Here is the caller graph for this function:

Ver_StreamIsOkey()

int Ver_StreamIsOkey ( Ver_Stream_t * p )

extern

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

Synopsis [Returns current symbol.]

Description []

SideEffects []

SeeAlso []

Definition at line 242 of file verStream.c.

{
    return !p->fStop;
}

Here is the caller graph for this function:

Ver_StreamPopChar()

char Ver_StreamPopChar ( Ver_Stream_t * p )

extern

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

Synopsis [Returns current symbol and moves to the next.]

Description []

SideEffects []

SeeAlso []

Definition at line 275 of file verStream.c.

{
    assert( !p->fStop );
    // check if the new data should to be loaded
    if ( p->pBufferCur > p->pBufferStop )
        Ver_StreamReload( p );
    // check if there are symbols left
    if ( p->pBufferCur == p->pBufferEnd ) // end of file
    {
        p->fStop = 1;
        return -1;
    }
    // count the lines
    if ( *p->pBufferCur == '\n' )
        p->nLineCounter++;
    return *p->pBufferCur++;
}

Here is the caller graph for this function:

Ver_StreamScanChar()

char Ver_StreamScanChar ( Ver_Stream_t * p )

extern

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

Synopsis [Returns current symbol.]

Description []

SideEffects []

SeeAlso []

Definition at line 258 of file verStream.c.

{
    assert( !p->fStop );
    return *p->pBufferCur;
}

Here is the caller graph for this function:

Ver_StreamSkipChars()

void Ver_StreamSkipChars ( Ver_Stream_t * p, char * pCharsToSkip )

extern

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

Synopsis [Skips the current symbol and all symbols from the list.]

Description []

SideEffects []

SeeAlso []

Definition at line 304 of file verStream.c.

{
    char * pChar, * pTemp;
    assert( !p->fStop );
    assert( pCharsToSkip != NULL );
    // check if the new data should to be loaded
    if ( p->pBufferCur > p->pBufferStop )
        Ver_StreamReload( p );
    // skip the symbols
    for ( pChar = p->pBufferCur; pChar < p->pBufferEnd; pChar++ )
    {
        // skip symbols as long as they are in the list
        for ( pTemp = pCharsToSkip; *pTemp; pTemp++ )
            if ( *pChar == *pTemp )
                break;
        if ( *pTemp == 0 ) // pChar is not found in the list
        {
            p->pBufferCur = pChar;
            return;
        }
        // count the lines
        if ( *pChar == '\n' )
            p->nLineCounter++;
    }
    // the file is finished or the last part continued 
    // through VER_OFFSET_SIZE chars till the end of the buffer
    if ( p->pBufferStop == p->pBufferEnd ) // end of file
    {
        p->fStop = 1;
        return;
    }
    printf( "Ver_StreamSkipSymbol() failed to parse the file \"%s\".\n", p->pFileName );
}

Here is the caller graph for this function:

Ver_StreamSkipToChars()

void Ver_StreamSkipToChars ( Ver_Stream_t * p, char * pCharsToStop )

extern

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

Synopsis [Skips all symbols until encountering one from the list.]

Description []

SideEffects []

SeeAlso []

Definition at line 349 of file verStream.c.

{
    char * pChar, * pTemp;
    assert( !p->fStop );
    assert( pCharsToStop != NULL );
    // check if the new data should to be loaded
    if ( p->pBufferCur > p->pBufferStop )
        Ver_StreamReload( p );
    // skip the symbols
    for ( pChar = p->pBufferCur; pChar < p->pBufferEnd; pChar++ )
    {
        // skip symbols as long as they are NOT in the list
        for ( pTemp = pCharsToStop; *pTemp; pTemp++ )
            if ( *pChar == *pTemp )
                break;
        if ( *pTemp == 0 ) // pChar is not found in the list
        {
            // count the lines
            if ( *pChar == '\n' )
                p->nLineCounter++;
            continue;
        }
        // the symbol is found - move position and return
        p->pBufferCur = pChar;
        return;
    }
    // the file is finished or the last part continued 
    // through VER_OFFSET_SIZE chars till the end of the buffer
    if ( p->pBufferStop == p->pBufferEnd ) // end of file
    {
        p->fStop = 1;
        return;
    }
    printf( "Ver_StreamSkipToSymbol() failed to parse the file \"%s\".\n", p->pFileName );
}

Here is the caller graph for this function: