luke
/
abc
mirror of https://github.com/YosysHQ/abc.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Fixed a typo in variable names.

This commit is contained in:
Alan Mishchenko 2015-02-07 22:29:14 -08:00
parent 55c5c1b58f
commit 68467cfff7
20 changed files with 98 additions and 98 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/base/abci/abc.c
View File

@ -36329,7 +36329,7 @@ usage:
Abc_Print( -2, "\t Functional variables: {a,b} (both a and b are always present)\n");
Abc_Print( -2, "\t Parameter variables: {p,q,r,s,t,u,v,w} (any number from 1 to 8)\n");
Abc_Print( -2, "\t Boolean operators: AND(&), OR(|), XOR(^), MUX(?:), NOT(~)\n");
Abc_Print( -2, "\t Parantheses should be used around each operator. Spaces not allowed.\n");
Abc_Print( -2, "\t Parentheses should be used around each operator. Spaces not allowed.\n");
Abc_Print( -2, "\t Complement (~) is only allowed before variables (use DeMorgan law).\n");
Abc_Print( -2, "\t Examples:\n");
Abc_Print( -2, "\t (((a&b)&~p)|q) stuck-at-0/1 at the output\n");

2
src/base/io/io.c
View File

@ -706,7 +706,7 @@ usage:
fprintf( pAbc->Err, "\t (in this case CA=11001010 is truth table of MUX(Data0,Data1,Ctrl))\n" );
fprintf( pAbc->Err, "\t The lower chars (a,b,c,etc) are reserved for elementary variables.\n" );
fprintf( pAbc->Err, "\t The upper chars (A,B,C,etc) are reserved for hexadecimal digits.\n" );
fprintf( pAbc->Err, "\t No spaces are allowed in formulas. In parantheses, LSB goes first.\n" );
fprintf( pAbc->Err, "\t No spaces are allowed in formulas. In parentheses, LSB goes first.\n" );
return 1;
}

10
src/base/io/ioReadDsd.c
View File

@ -90,17 +90,17 @@ int Io_ReadDsdStrSplit( char * pCur, char * pParts[], int * pTypeXor )
// skip hex truth table
while ( (*pCur >= '0' && *pCur <= '9') || (*pCur >= 'A' && *pCur <= 'F') )
pCur++;
// process parantheses
// process parentheses
if ( *pCur != '(' )
{
printf( "Cannot find the opening paranthesis.\n" );
printf( "Cannot find the opening parenthesis.\n" );
break;
}
// find the corresponding closing paranthesis
// find the corresponding closing parenthesis
pCur = Io_ReadDsdFindEnd( pCur );
if ( pCur == NULL )
{
printf( "Cannot find the closing paranthesis.\n" );
printf( "Cannot find the closing parenthesis.\n" );
break;
}
pCur++;
@ -254,7 +254,7 @@ Abc_Ntk_t * Io_ReadDsd( char * pForm )
Abc_ObjAssignName( Abc_NtkCreatePi(pNtk), (char *)Vec_PtrEntry(vNames, i), NULL );
Abc_NodeFreeNames( vNames );
// transform the formula by inserting parantheses
// transform the formula by inserting parentheses
// this transforms strings like PRIME(a,b,cd) into (PRIME((a),(b),(cd)))
pCur = pFormCopy = ABC_ALLOC( char, 3 * strlen(pForm) + 10 );
*pCur++ = '(';

4
src/base/io/ioWriteBench.c
View File

@ -57,7 +57,7 @@ int Io_WriteBench( Abc_Ntk_t * pNtk, const char * pFileName )
assert( Abc_NtkIsSopNetlist(pNtk) );
if ( !Io_WriteBenchCheckNames(pNtk) )
{
fprintf( stdout, "Io_WriteBench(): Signal names in this benchmark contain parantheses making them impossible to reproduce in the BENCH format. Use \"short_names\".\n" );
fprintf( stdout, "Io_WriteBench(): Signal names in this benchmark contain parentheses making them impossible to reproduce in the BENCH format. Use \"short_names\".\n" );
return 0;
}
pFile = fopen( pFileName, "w" );
@ -179,7 +179,7 @@ int Io_WriteBenchLut( Abc_Ntk_t * pNtk, char * pFileName )
assert( Abc_NtkIsAigNetlist(pNtk) );
if ( !Io_WriteBenchCheckNames(pNtk) )
{
fprintf( stdout, "Io_WriteBenchLut(): Signal names in this benchmark contain parantheses making them impossible to reproduce in the BENCH format. Use \"short_names\".\n" );
fprintf( stdout, "Io_WriteBenchLut(): Signal names in this benchmark contain parentheses making them impossible to reproduce in the BENCH format. Use \"short_names\".\n" );
return 0;
}
pFile = fopen( pFileName, "w" );

2
src/base/io/ioWriteEqn.c
View File

@ -219,7 +219,7 @@ int Io_NtkWriteEqnCheck( Abc_Ntk_t * pNtk )
int i, k, Length;
int RetValue = 1;
// make sure the network does not have proper names, such as "0" or "1" or containing parantheses
// make sure the network does not have proper names, such as "0" or "1" or containing parentheses
Abc_NtkForEachObj( pNtk, pObj, i )
{
pName = Nm_ManFindNameById(pNtk->pManName, i);

2
src/base/io/ioWriteList.c
View File

@ -38,7 +38,7 @@ used it in order to reason on relatively small weighed direct graphs. I
simply list all vertices, one per line and for each vertex "V_source" I
list all vertices that are "sinks" with respect to it, i.e. such that
there is a distinct arc between "V_source" and each of them (in
paranthesis I list the name of the edge and its weight (number of latency
parenthesis I list the name of the edge and its weight (number of latency
on that path). For instance, if you look at the following graph, you have
that vertex "v_5" is connected to vertex "v_6" through a directed arc
called "v_5_to_v_6" whose latency is equal to 3, i.e. there are three

2
src/base/io/ioWriteSmv.c
View File

@ -75,7 +75,7 @@ int Io_WriteSmv( Abc_Ntk_t * pNtk, char * pFileName )
assert( Abc_NtkIsSopNetlist(pNtk) );
if ( !Io_WriteSmvCheckNames(pNtk) )
{
fprintf( stdout, "Io_WriteSmv(): Signal names in this benchmark contain parantheses making them impossible to reproduce in the SMV format. Use \"short_names\".\n" );
fprintf( stdout, "Io_WriteSmv(): Signal names in this benchmark contain parentheses making them impossible to reproduce in the SMV format. Use \"short_names\".\n" );
return 0;
}
pFile = fopen( pFileName, "w" );

40
src/base/ver/verCore.c
View File

@ -412,7 +412,7 @@ int Ver_ParseModule( Ver_Man_t * pMan )
// get the network with this name
pNtk = Ver_ParseFindOrCreateNetwork( pMan, pWord );
// make sure we stopped at the opening paranthesis
// make sure we stopped at the opening parenthesis
if ( Ver_StreamPopChar(p) != '(' )
{
sprintf( pMan->sError, "Cannot find \"(\" after \"module\" in network %s.", pNtk->pName );
@ -420,7 +420,7 @@ int Ver_ParseModule( Ver_Man_t * pMan )
return 0;
}
// skip to the end of parantheses
// skip to the end of parentheses
do {
if ( Ver_ParseGetName( pMan ) == NULL )
return 0;
@ -432,7 +432,7 @@ int Ver_ParseModule( Ver_Man_t * pMan )
Symbol = Ver_StreamPopChar(p);
if ( Symbol != ';' )
{
sprintf( pMan->sError, "Expected closing paranthesis after \"module\"." );
sprintf( pMan->sError, "Expected closing parenthesis after \"module\"." );
Ver_ParsePrintErrorMessage( pMan );
return 0;
}
@ -654,7 +654,7 @@ int Ver_ParseSignalPrefix( Ver_Man_t * pMan, char ** ppWord, int * pnMsb, int *
{
assert( *pWord == ':' );
nLsb = atoi( pWord + 1 );
// find the closing paranthesis
// find the closing parenthesis
while ( *pWord && *pWord != ']' )
pWord++;
if ( *pWord == 0 )
@ -1340,7 +1340,7 @@ int Ver_ParseGateStandard( Ver_Man_t * pMan, Abc_Ntk_t * pNtk, Ver_GateType_t Ga
// this is gate name - throw it away
if ( Ver_StreamPopChar(p) != '(' )
{
sprintf( pMan->sError, "Cannot parse a standard gate (expected opening paranthesis)." );
sprintf( pMan->sError, "Cannot parse a standard gate (expected opening parenthesis)." );
Ver_ParsePrintErrorMessage( pMan );
return 0;
}
@ -1377,7 +1377,7 @@ int Ver_ParseGateStandard( Ver_Man_t * pMan, Abc_Ntk_t * pNtk, Ver_GateType_t Ga
// skip comma
if ( Symbol != ',' )
{
sprintf( pMan->sError, "Cannot parse a standard gate %s (expected closing paranthesis).", Abc_ObjName(Abc_ObjFanout0(pNode)) );
sprintf( pMan->sError, "Cannot parse a standard gate %s (expected closing parenthesis).", Abc_ObjName(Abc_ObjFanout0(pNode)) );
Ver_ParsePrintErrorMessage( pMan );
return 0;
}
@ -1436,7 +1436,7 @@ int Ver_ParseFlopStandard( Ver_Man_t * pMan, Abc_Ntk_t * pNtk )
// this is gate name - throw it away
if ( Ver_StreamPopChar(p) != '(' )
{
sprintf( pMan->sError, "Cannot parse a standard gate (expected opening paranthesis)." );
sprintf( pMan->sError, "Cannot parse a standard gate (expected opening parenthesis)." );
Ver_ParsePrintErrorMessage( pMan );
return 0;
}
@ -1573,7 +1573,7 @@ int Ver_ParseGate( Ver_Man_t * pMan, Abc_Ntk_t * pNtk, Mio_Gate_t * pGate )
// this is gate name - throw it away
if ( Ver_StreamPopChar(p) != '(' )
{
sprintf( pMan->sError, "Cannot parse gate %s (expected opening paranthesis).", Mio_GateReadName(pGate) );
sprintf( pMan->sError, "Cannot parse gate %s (expected opening parenthesis).", Mio_GateReadName(pGate) );
Ver_ParsePrintErrorMessage( pMan );
return 0;
}
@ -1613,10 +1613,10 @@ int Ver_ParseGate( Ver_Man_t * pMan, Abc_Ntk_t * pNtk, Mio_Gate_t * pGate )
return 0;
}
// open the paranthesis
// open the parenthesis
if ( Ver_StreamPopChar(p) != '(' )
{
sprintf( pMan->sError, "Cannot formal parameter %s of gate %s (expected opening paranthesis).", pWord, Mio_GateReadName(pGate) );
sprintf( pMan->sError, "Cannot formal parameter %s of gate %s (expected opening parenthesis).", pWord, Mio_GateReadName(pGate) );
Ver_ParsePrintErrorMessage( pMan );
return 0;
}
@ -1646,10 +1646,10 @@ int Ver_ParseGate( Ver_Man_t * pMan, Abc_Ntk_t * pNtk, Mio_Gate_t * pGate )
return 0;
}
// close the paranthesis
// close the parenthesis
if ( Ver_StreamPopChar(p) != ')' )
{
sprintf( pMan->sError, "Cannot formal parameter %s of gate %s (expected closing paranthesis).", pWord, Mio_GateReadName(pGate) );
sprintf( pMan->sError, "Cannot formal parameter %s of gate %s (expected closing parenthesis).", pWord, Mio_GateReadName(pGate) );
Ver_ParsePrintErrorMessage( pMan );
return 0;
}
@ -1678,7 +1678,7 @@ int Ver_ParseGate( Ver_Man_t * pMan, Abc_Ntk_t * pNtk, Mio_Gate_t * pGate )
// skip comma
if ( Symbol != ',' )
{
sprintf( pMan->sError, "Cannot formal parameter %s of gate %s (expected closing paranthesis).", pWord, Mio_GateReadName(pGate) );
sprintf( pMan->sError, "Cannot formal parameter %s of gate %s (expected closing parenthesis).", pWord, Mio_GateReadName(pGate) );
Ver_ParsePrintErrorMessage( pMan );
return 0;
}
@ -1754,7 +1754,7 @@ int Ver_ParseBox( Ver_Man_t * pMan, Abc_Ntk_t * pNtk, Abc_Ntk_t * pNtkBox )
// continue parsing the box
if ( Ver_StreamPopChar(p) != '(' )
{
sprintf( pMan->sError, "Cannot parse box %s (expected opening paranthesis).", Abc_ObjName(pNode) );
sprintf( pMan->sError, "Cannot parse box %s (expected opening parenthesis).", Abc_ObjName(pNode) );
Ver_ParsePrintErrorMessage( pMan );
return 0;
}
@ -1791,10 +1791,10 @@ int Ver_ParseBox( Ver_Man_t * pMan, Abc_Ntk_t * pNtk, Abc_Ntk_t * pNtkBox )
// save the name
pBundle->pNameFormal = Extra_UtilStrsav( pWord );
// open the paranthesis
// open the parenthesis
if ( Ver_StreamPopChar(p) != '(' )
{
sprintf( pMan->sError, "Cannot formal parameter %s of box %s (expected opening paranthesis).", pWord, Abc_ObjName(pNode));
sprintf( pMan->sError, "Cannot formal parameter %s of box %s (expected opening parenthesis).", pWord, Abc_ObjName(pNode));
Ver_ParsePrintErrorMessage( pMan );
return 0;
}
@ -2002,11 +2002,11 @@ int Ver_ParseBox( Ver_Man_t * pMan, Abc_Ntk_t * pNtk, Abc_Ntk_t * pNtkBox )
if ( fFormalIsGiven )
{
// close the paranthesis
// close the parenthesis
Ver_ParseSkipComments( pMan );
if ( Ver_StreamPopChar(p) != ')' )
{
sprintf( pMan->sError, "Cannot parse formal parameter %s of box %s (expected closing paranthesis).", pWord, Abc_ObjName(pNode) );
sprintf( pMan->sError, "Cannot parse formal parameter %s of box %s (expected closing parenthesis).", pWord, Abc_ObjName(pNode) );
Ver_ParsePrintErrorMessage( pMan );
return 0;
}
@ -2179,7 +2179,7 @@ int Ver_ParseConnectBox( Ver_Man_t * pMan, Abc_Obj_t * pBox )
if ( !strcmp(pBundle->pNameFormal, pNameFormal) )
break;
assert( pBundle != NULL );
// if the bundle is not found, try without parantheses
// if the bundle is not found, try without parentheses
if ( k == Vec_PtrSize(vBundles) )
{
pBundle = NULL;
@ -2230,7 +2230,7 @@ int Ver_ParseConnectBox( Ver_Man_t * pMan, Abc_Obj_t * pBox )
if ( !strcmp(pBundle->pNameFormal, pNameFormal) )
break;
assert( pBundle != NULL );
// if the name is not found, try without parantheses
// if the name is not found, try without parentheses
if ( k == Vec_PtrSize(vBundles) )
{
pBundle = NULL;

18
src/base/ver/verFormula.c
View File

@ -28,8 +28,8 @@ ABC_NAMESPACE_IMPL_START
////////////////////////////////////////////////////////////////////////
// the list of operation symbols to be used in expressions
#define VER_PARSE_SYM_OPEN '(' // opening paranthesis
#define VER_PARSE_SYM_CLOSE ')' // closing paranthesis
#define VER_PARSE_SYM_OPEN '(' // opening parenthesis
#define VER_PARSE_SYM_CLOSE ')' // closing parenthesis
#define VER_PARSE_SYM_CONST0 '0' // constant 0
#define VER_PARSE_SYM_CONST1 '1' // constant 1
#define VER_PARSE_SYM_NEGBEF1 '!' // negation before the variable
@ -47,7 +47,7 @@ ABC_NAMESPACE_IMPL_START
#define VER_PARSE_OPER_OR 4 // logic OR
#define VER_PARSE_OPER_EQU 3 // equvalence (a'b'| ab )
#define VER_PARSE_OPER_MUX 2 // MUX(a,b,c) (ab | a'c )
#define VER_PARSE_OPER_MARK 1 // OpStack token standing for an opening paranthesis
#define VER_PARSE_OPER_MARK 1 // OpStack token standing for an opening parenthesis
// these are values of the internal Flag
#define VER_PARSE_FLAG_START 1 // after the opening parenthesis
@ -91,7 +91,7 @@ void * Ver_FormulaParser( char * pFormula, void * pMan, Vec_Ptr_t * vNames, Vec_
if ( !strcmp(pFormula, "1") || !strcmp(pFormula, "1\'b1") )
return Hop_ManConst1((Hop_Man_t *)pMan);
// make sure that the number of opening and closing parantheses is the same
// make sure that the number of opening and closing parentheses is the same
nParans = 0;
for ( pTemp = pFormula; *pTemp; pTemp++ )
if ( *pTemp == '(' )
@ -100,11 +100,11 @@ void * Ver_FormulaParser( char * pFormula, void * pMan, Vec_Ptr_t * vNames, Vec_
nParans--;
if ( nParans != 0 )
{
sprintf( pErrorMessage, "Parse_FormulaParser(): Different number of opening and closing parantheses ()." );
sprintf( pErrorMessage, "Parse_FormulaParser(): Different number of opening and closing parentheses ()." );
return NULL;
}
// add parantheses
// add parentheses
pTemp = pFormula + strlen(pFormula) + 2;
*pTemp-- = 0; *pTemp = ')';
while ( --pTemp != pFormula )
@ -186,7 +186,7 @@ void * Ver_FormulaParser( char * pFormula, void * pMan, Vec_Ptr_t * vNames, Vec_
case VER_PARSE_SYM_OPEN:
if ( Flag == VER_PARSE_FLAG_VAR )
{
sprintf( pErrorMessage, "Parse_FormulaParser(): Variable before a paranthesis." );
sprintf( pErrorMessage, "Parse_FormulaParser(): Variable before a parenthesis." );
Flag = VER_PARSE_FLAG_ERROR;
break;
}
@ -202,7 +202,7 @@ void * Ver_FormulaParser( char * pFormula, void * pMan, Vec_Ptr_t * vNames, Vec_
{
if ( !Vec_IntSize( vStackOp ) )
{
sprintf( pErrorMessage, "Parse_FormulaParser(): There is no opening paranthesis\n" );
sprintf( pErrorMessage, "Parse_FormulaParser(): There is no opening parenthesis\n" );
Flag = VER_PARSE_FLAG_ERROR;
break;
}
@ -226,7 +226,7 @@ void * Ver_FormulaParser( char * pFormula, void * pMan, Vec_Ptr_t * vNames, Vec_
}
else
{
sprintf( pErrorMessage, "Parse_FormulaParser(): There is no opening paranthesis\n" );
sprintf( pErrorMessage, "Parse_FormulaParser(): There is no opening parenthesis\n" );
Flag = VER_PARSE_FLAG_ERROR;
break;
}

2
src/base/ver/verStream.c
View File

@ -48,7 +48,7 @@ struct Ver_Stream_t_
char * pBufferEnd; // the first position not used by currently loaded data
char * pBufferStop; // the position where loading new data will be done
// tokens given to the user
char pChars[VER_WORD_SIZE+5]; // temporary storage for a word (plus end-of-string and two parantheses)
char pChars[VER_WORD_SIZE+5]; // temporary storage for a word (plus end-of-string and two parentheses)
int nChars; // the total number of characters in the word
// status of the parser
int fStop; // this flag goes high when the end of file is reached

18
src/base/wlc/wlcReadVer.c
View File

@ -193,7 +193,7 @@ static inline char * Wlc_PrsFindSymbolTwo( char * pStr, char Symb, char Symb2 )
return pStr;
return NULL;
}
static inline char * Wlc_PrsFindClosingParanthesis( char * pStr, char Open, char Close )
static inline char * Wlc_PrsFindClosingParenthesis( char * pStr, char Open, char Close )
{
int Counter = 0;
int fNotName = 1;
@ -624,18 +624,18 @@ static inline int Wlc_PrsFindDefinition( Wlc_Prs_t * p, char * pStr, Vec_Int_t *
if ( Wlc_PrsFindSymbolTwo(pStr, '>', '>') && Wlc_PrsFindSymbolTwo(pStr, '<', '<') )
{
// THIS IS A HACK TO DETECT rotating shifters
char * pClose = Wlc_PrsFindClosingParanthesis( pStr, '(', ')' );
char * pClose = Wlc_PrsFindClosingParenthesis( pStr, '(', ')' );
if ( pClose == NULL )
return Wlc_PrsWriteErrorMessage( p, pStr, "Expecting closing paranthesis." );
return Wlc_PrsWriteErrorMessage( p, pStr, "Expecting closing parenthesis." );
*pStr = ' '; *pClose = 0;
pStr = Wlc_PrsSkipSpaces( pStr );
fRotating = 1;
}
else
{
char * pClose = Wlc_PrsFindClosingParanthesis( pStr, '(', ')' );
char * pClose = Wlc_PrsFindClosingParenthesis( pStr, '(', ')' );
if ( pClose == NULL )
return Wlc_PrsWriteErrorMessage( p, pStr, "Expecting closing paranthesis." );
return Wlc_PrsWriteErrorMessage( p, pStr, "Expecting closing parenthesis." );
*pStr = *pClose = ' ';
pStr = Wlc_PrsSkipSpaces( pStr );
}
@ -655,13 +655,13 @@ static inline int Wlc_PrsFindDefinition( Wlc_Prs_t * p, char * pStr, Vec_Int_t *
else if ( pStr[0] == '~' )
Type = WLC_OBJ_BIT_NOT;
else assert( 0 );
// skip parantheses
// skip parentheses
pStr = Wlc_PrsSkipSpaces( pStr+1 );
if ( pStr[0] == '(' )
{
char * pClose = Wlc_PrsFindClosingParanthesis( pStr, '(', ')' );
char * pClose = Wlc_PrsFindClosingParenthesis( pStr, '(', ')' );
if ( pClose == NULL )
return Wlc_PrsWriteErrorMessage( p, pStr, "Expecting closing paranthesis." );
return Wlc_PrsWriteErrorMessage( p, pStr, "Expecting closing parenthesis." );
*pStr = *pClose = ' ';
}
if ( !(pStr = Wlc_PrsReadName(p, pStr, vFanins)) )
@ -1097,7 +1097,7 @@ startword:
fFlopOut = (pStart[0] == 'q');
pStart = Wlc_PrsFindSymbol( pStart, '(' );
if ( pStart == NULL )
return Wlc_PrsWriteErrorMessage( p, pStart, "Cannot read opening paranthesis in the flop description." );
return Wlc_PrsWriteErrorMessage( p, pStart, "Cannot read opening parenthesis in the flop description." );
pStart = Wlc_PrsFindName( pStart+1, &pName );
if ( pStart == NULL )
return Wlc_PrsWriteErrorMessage( p, pStart, "Cannot read name inside flop description." );

20
src/bdd/parse/parseCore.c
View File

@ -24,11 +24,11 @@
and underscores: For example: 1) a&b <+> c'&d => a + b;
2) a1 b2 c3' dummy' + (a2+b2')c3 dummy
2) Constant values 0 and 1 can be used just like normal variables
3) Any boolean operator (listed below) and parantheses can be used
3) Any boolean operator (listed below) and parentheses can be used
any number of times provided there are equal number of opening
and closing parantheses.
and closing parentheses.
4) By default, absence of an operator between vars and before and
after parantheses is taken for AND.
after parentheses is taken for AND.
5) Both complementation prefix and complementation suffix can be
used at the same time (but who needs this?)
6) Spaces (tabs, end-of-lines) may be inserted anywhere,
@ -47,8 +47,8 @@ ABC_NAMESPACE_IMPL_START
// the list of operation symbols to be used in expressions
#define PARSE_SYM_OPEN '(' // opening paranthesis
#define PARSE_SYM_CLOSE ')' // closing paranthesis
#define PARSE_SYM_OPEN '(' // opening parenthesis
#define PARSE_SYM_CLOSE ')' // closing parenthesis
#define PARSE_SYM_LOWER '[' // shifts one rank down
#define PARSE_SYM_RAISE ']' // shifts one rank up
#define PARSE_SYM_CONST0 '0' // constant 0
@ -81,7 +81,7 @@ ABC_NAMESPACE_IMPL_START
#define PARSE_OPER_EQU 6 // equvalence (a'b'| ab )
#define PARSE_OPER_FLR 5 // implication ( a' | b )
#define PARSE_OPER_FLL 4 // backward imp ( 'b | a )
#define PARSE_OPER_MARK 1 // OpStack token standing for an opening paranthesis
#define PARSE_OPER_MARK 1 // OpStack token standing for an opening parenthesis
// these are values of the internal Flag
#define PARSE_FLAG_START 1 // after the opening parenthesis
@ -133,7 +133,7 @@ DdNode * Parse_FormulaParser( FILE * pOutput, char * pFormulaInit, int nVars, in
return NULL;
}
// make sure that the number of opening and closing parantheses is the same
// make sure that the number of opening and closing parentheses is the same
nParans = 0;
for ( pTemp = pFormulaInit; *pTemp; pTemp++ )
if ( *pTemp == '(' )
@ -142,7 +142,7 @@ DdNode * Parse_FormulaParser( FILE * pOutput, char * pFormulaInit, int nVars, in
nParans--;
if ( nParans != 0 )
{
fprintf( pOutput, "Parse_FormulaParser(): Different number of opening and closing parantheses ().\n" );
fprintf( pOutput, "Parse_FormulaParser(): Different number of opening and closing parentheses ().\n" );
return NULL;
}
@ -326,7 +326,7 @@ DdNode * Parse_FormulaParser( FILE * pOutput, char * pFormulaInit, int nVars, in
{
if ( Parse_StackOpIsEmpty( pStackOp ) )
{
fprintf( pOutput, "Parse_FormulaParser(): There is no opening paranthesis\n" );
fprintf( pOutput, "Parse_FormulaParser(): There is no opening parenthesis\n" );
Flag = PARSE_FLAG_ERROR;
break;
}
@ -353,7 +353,7 @@ DdNode * Parse_FormulaParser( FILE * pOutput, char * pFormulaInit, int nVars, in
}
else
{
fprintf( pOutput, "Parse_FormulaParser(): There is no opening paranthesis\n" );
fprintf( pOutput, "Parse_FormulaParser(): There is no opening parenthesis\n" );
Flag = PARSE_FLAG_ERROR;
break;
}

18
src/bdd/parse/parseEqn.c
View File

@ -29,8 +29,8 @@ ABC_NAMESPACE_IMPL_START
// the list of operation symbols to be used in expressions
#define PARSE_EQN_SYM_OPEN '(' // opening paranthesis
#define PARSE_EQN_SYM_CLOSE ')' // closing paranthesis
#define PARSE_EQN_SYM_OPEN '(' // opening parenthesis
#define PARSE_EQN_SYM_CLOSE ')' // closing parenthesis
#define PARSE_EQN_SYM_CONST0 '0' // constant 0
#define PARSE_EQN_SYM_CONST1 '1' // constant 1
#define PARSE_EQN_SYM_NEG '!' // negation before the variable
@ -41,7 +41,7 @@ ABC_NAMESPACE_IMPL_START
#define PARSE_EQN_OPER_NEG 10 // negation
#define PARSE_EQN_OPER_AND 9 // logic AND
#define PARSE_EQN_OPER_OR 7 // logic OR
#define PARSE_EQN_OPER_MARK 1 // OpStack token standing for an opening paranthesis
#define PARSE_EQN_OPER_MARK 1 // OpStack token standing for an opening parenthesis
// these are values of the internal Flag
#define PARSE_EQN_FLAG_START 1 // after the opening parenthesis
@ -80,7 +80,7 @@ Hop_Obj_t * Parse_FormulaParserEqn( FILE * pOutput, char * pFormInit, Vec_Ptr_t
int Oper, Oper1, Oper2;
int i, v;
// make sure that the number of opening and closing parantheses is the same
// make sure that the number of opening and closing parentheses is the same
nParans = 0;
for ( pTemp = pFormInit; *pTemp; pTemp++ )
if ( *pTemp == '(' )
@ -89,7 +89,7 @@ Hop_Obj_t * Parse_FormulaParserEqn( FILE * pOutput, char * pFormInit, Vec_Ptr_t
nParans--;
if ( nParans != 0 )
{
fprintf( pOutput, "Parse_FormulaParserEqn(): Different number of opening and closing parantheses ().\n" );
fprintf( pOutput, "Parse_FormulaParserEqn(): Different number of opening and closing parentheses ().\n" );
return NULL;
}
@ -158,7 +158,7 @@ Hop_Obj_t * Parse_FormulaParserEqn( FILE * pOutput, char * pFormInit, Vec_Ptr_t
if ( Flag == PARSE_EQN_FLAG_VAR )
{
// Parse_StackOpPush( pStackOp, PARSE_EQN_OPER_AND );
fprintf( pOutput, "Parse_FormulaParserEqn(): An opening paranthesis follows a var without operation sign.\n" );
fprintf( pOutput, "Parse_FormulaParserEqn(): An opening parenthesis follows a var without operation sign.\n" );
Flag = PARSE_EQN_FLAG_ERROR;
break;
}
@ -173,7 +173,7 @@ Hop_Obj_t * Parse_FormulaParserEqn( FILE * pOutput, char * pFormInit, Vec_Ptr_t
{
if ( Parse_StackOpIsEmpty( pStackOp ) )
{
fprintf( pOutput, "Parse_FormulaParserEqn(): There is no opening paranthesis\n" );
fprintf( pOutput, "Parse_FormulaParserEqn(): There is no opening parenthesis\n" );
Flag = PARSE_EQN_FLAG_ERROR;
break;
}
@ -194,7 +194,7 @@ Hop_Obj_t * Parse_FormulaParserEqn( FILE * pOutput, char * pFormInit, Vec_Ptr_t
}
else
{
fprintf( pOutput, "Parse_FormulaParserEqn(): There is no opening paranthesis\n" );
fprintf( pOutput, "Parse_FormulaParserEqn(): There is no opening parenthesis\n" );
Flag = PARSE_EQN_FLAG_ERROR;
break;
}
@ -211,7 +211,7 @@ Hop_Obj_t * Parse_FormulaParserEqn( FILE * pOutput, char * pFormInit, Vec_Ptr_t
{
if ( pTemp[i] == PARSE_EQN_SYM_NEG || pTemp[i] == PARSE_EQN_SYM_OPEN )
{
fprintf( pOutput, "Parse_FormulaParserEqn(): The negation sign or an opening paranthesis inside the variable name.\n" );
fprintf( pOutput, "Parse_FormulaParserEqn(): The negation sign or an opening parenthesis inside the variable name.\n" );
Flag = PARSE_EQN_FLAG_ERROR;
break;
}

18
src/map/amap/amapParse.c
View File

@ -30,8 +30,8 @@ ABC_NAMESPACE_IMPL_START
////////////////////////////////////////////////////////////////////////
// the list of operation symbols to be used in expressions
#define AMAP_EQN_SYM_OPEN '(' // opening paranthesis
#define AMAP_EQN_SYM_CLOSE ')' // closing paranthesis
#define AMAP_EQN_SYM_OPEN '(' // opening parenthesis
#define AMAP_EQN_SYM_CLOSE ')' // closing parenthesis
#define AMAP_EQN_SYM_CONST0 '0' // constant 0
#define AMAP_EQN_SYM_CONST1 '1' // constant 1
#define AMAP_EQN_SYM_NEG '!' // negation before the variable
@ -47,7 +47,7 @@ ABC_NAMESPACE_IMPL_START
#define AMAP_EQN_OPER_AND 9 // logic AND
#define AMAP_EQN_OPER_XOR 8 // logic XOR
#define AMAP_EQN_OPER_OR 7 // logic OR
#define AMAP_EQN_OPER_MARK 1 // OpStack token standing for an opening paranthesis
#define AMAP_EQN_OPER_MARK 1 // OpStack token standing for an opening parenthesis
// these are values of the internal Flag
#define AMAP_EQN_FLAG_START 1 // after the opening parenthesis
@ -114,7 +114,7 @@ Hop_Obj_t * Amap_ParseFormula( FILE * pOutput, char * pFormInit, Vec_Ptr_t * vVa
int Oper, Oper1, Oper2;
int i, v;
// make sure that the number of opening and closing parantheses is the same
// make sure that the number of opening and closing parentheses is the same
nParans = 0;
for ( pTemp = pFormInit; *pTemp; pTemp++ )
if ( *pTemp == '(' )
@ -123,7 +123,7 @@ Hop_Obj_t * Amap_ParseFormula( FILE * pOutput, char * pFormInit, Vec_Ptr_t * vVa
nParans--;
if ( nParans != 0 )
{
fprintf( pOutput, "Amap_ParseFormula(): Different number of opening and closing parantheses ().\n" );
fprintf( pOutput, "Amap_ParseFormula(): Different number of opening and closing parentheses ().\n" );
return NULL;
}
@ -207,7 +207,7 @@ Hop_Obj_t * Amap_ParseFormula( FILE * pOutput, char * pFormInit, Vec_Ptr_t * vVa
if ( Flag == AMAP_EQN_FLAG_VAR )
{
Vec_IntPush( pStackOp, AMAP_EQN_OPER_AND );
// fprintf( pOutput, "Amap_ParseFormula(): An opening paranthesis follows a var without operation sign.\n" );
// fprintf( pOutput, "Amap_ParseFormula(): An opening parenthesis follows a var without operation sign.\n" );
// Flag = AMAP_EQN_FLAG_ERROR;
// break;
}
@ -222,7 +222,7 @@ Hop_Obj_t * Amap_ParseFormula( FILE * pOutput, char * pFormInit, Vec_Ptr_t * vVa
{
if ( Vec_IntSize( pStackOp ) == 0 )
{
fprintf( pOutput, "Amap_ParseFormula(): There is no opening paranthesis\n" );
fprintf( pOutput, "Amap_ParseFormula(): There is no opening parenthesis\n" );
Flag = AMAP_EQN_FLAG_ERROR;
break;
}
@ -243,7 +243,7 @@ Hop_Obj_t * Amap_ParseFormula( FILE * pOutput, char * pFormInit, Vec_Ptr_t * vVa
}
else
{
fprintf( pOutput, "Amap_ParseFormula(): There is no opening paranthesis\n" );
fprintf( pOutput, "Amap_ParseFormula(): There is no opening parenthesis\n" );
Flag = AMAP_EQN_FLAG_ERROR;
break;
}
@ -262,7 +262,7 @@ Hop_Obj_t * Amap_ParseFormula( FILE * pOutput, char * pFormInit, Vec_Ptr_t * vVa
{
if ( pTemp[i] == AMAP_EQN_SYM_NEG || pTemp[i] == AMAP_EQN_SYM_OPEN )
{
fprintf( pOutput, "Amap_ParseFormula(): The negation sign or an opening paranthesis inside the variable name.\n" );
fprintf( pOutput, "Amap_ParseFormula(): The negation sign or an opening parenthesis inside the variable name.\n" );
Flag = AMAP_EQN_FLAG_ERROR;
break;
}

4
src/map/if/ifTune.c
View File

@ -233,7 +233,7 @@ int Ifn_ManStrCheck( char * pStr, int * pnInps, int * pnObjs )
*pnObjs = MaxVar + 1 + nNodes;
return 1;
}
static inline char * Ifn_NtkParseFindClosingParanthesis( char * pStr, char Open, char Close )
static inline char * Ifn_NtkParseFindClosingParenthesis( char * pStr, char Open, char Close )
{
int Counter = 0;
assert( *pStr == Open );
@ -253,7 +253,7 @@ int Ifn_NtkParseInt_rec( char * pStr, Ifn_Ntk_t * p, char ** ppFinal, int * piNo
Ifn_Obj_t * pObj;
int nFanins = 0, pFanins[IFN_INS];
int Type = Inf_ManOpenSymb( pStr );
char * pLim = Ifn_NtkParseFindClosingParanthesis( pStr++, Ifn_Symbs[Type][0], Ifn_Symbs[Type][1] );
char * pLim = Ifn_NtkParseFindClosingParenthesis( pStr++, Ifn_Symbs[Type][0], Ifn_Symbs[Type][1] );
*ppFinal = NULL;
if ( pLim == NULL )
return Ifn_ErrorMessage( "For symbol \'%c\' cannot find matching symbol \'%c\'.\n", Ifn_Symbs[Type][0], Ifn_Symbs[Type][1] );

6
src/map/mapper/mapperSuper.c
View File

@ -149,7 +149,7 @@ int Map_LibraryReadFile( Map_SuperLib_t * pLib, FILE * pFile )
// get the gate
pGate = Map_LibraryReadGate( pLib, pTemp, pLib->nVarsMax );
assert( pGate->Num == nCounter + 1 );
// count the number of parantheses in the formula - this is the number of gates
// count the number of parentheses in the formula - this is the number of gates
for ( pTemp = pGate->pFormula; *pTemp; pTemp++ )
pGate->nGates += (*pTemp == '(');
// verify the truth table
@ -261,7 +261,7 @@ char * Map_LibraryReadFormulaStep( char * pFormula, char * pStrings[], int * pnS
// skip leading spaces
for ( pName = pFormula; *pName && *pName == ' '; pName++ );
assert( *pName );
// find the first opening paranthesis
// find the first opening parenthesis
for ( pPar1 = pName; *pPar1 && *pPar1 != '('; pPar1++ );
if ( *pPar1 == 0 )
{
@ -271,7 +271,7 @@ char * Map_LibraryReadFormulaStep( char * pFormula, char * pStrings[], int * pnS
// overwrite it with space
assert( *pPar1 == '(' );
*pPar1 = 0;
// find the corresponding closing paranthesis
// find the corresponding closing parenthesis
for ( CountPars = 1, pPar2 = pPar1 + 1; *pPar2 && CountPars; pPar2++ )
if ( *pPar2 == '(' )
CountPars++;

18
src/map/mio/mioParse.c
View File

@ -27,8 +27,8 @@ ABC_NAMESPACE_IMPL_START
////////////////////////////////////////////////////////////////////////
// the list of operation symbols to be used in expressions
#define MIO_EQN_SYM_OPEN '(' // opening paranthesis
#define MIO_EQN_SYM_CLOSE ')' // closing paranthesis
#define MIO_EQN_SYM_OPEN '(' // opening parenthesis
#define MIO_EQN_SYM_CLOSE ')' // closing parenthesis
#define MIO_EQN_SYM_CONST0 '0' // constant 0
#define MIO_EQN_SYM_CONST1 '1' // constant 1
#define MIO_EQN_SYM_NEG '!' // negation before the variable
@ -44,7 +44,7 @@ ABC_NAMESPACE_IMPL_START
#define MIO_EQN_OPER_AND 9 // logic AND
#define MIO_EQN_OPER_XOR 8 // logic XOR
#define MIO_EQN_OPER_OR 7 // logic OR
#define MIO_EQN_OPER_MARK 1 // OpStack token standing for an opening paranthesis
#define MIO_EQN_OPER_MARK 1 // OpStack token standing for an opening parenthesis
// these are values of the internal Flag
#define MIO_EQN_FLAG_START 1 // after the opening parenthesis
@ -114,7 +114,7 @@ Vec_Int_t * Mio_ParseFormula( char * pFormInit, char ** ppVarNames, int nVars )
int Oper, Oper1, Oper2;
int i, v;
// make sure that the number of opening and closing parantheses is the same
// make sure that the number of opening and closing parentheses is the same
nParans = 0;
for ( pTemp = pFormInit; *pTemp; pTemp++ )
if ( *pTemp == '(' )
@ -123,7 +123,7 @@ Vec_Int_t * Mio_ParseFormula( char * pFormInit, char ** ppVarNames, int nVars )
nParans--;
if ( nParans != 0 )
{
fprintf( stdout, "Mio_ParseFormula(): Different number of opening and closing parantheses ().\n" );
fprintf( stdout, "Mio_ParseFormula(): Different number of opening and closing parentheses ().\n" );
return NULL;
}
@ -207,7 +207,7 @@ Vec_Int_t * Mio_ParseFormula( char * pFormInit, char ** ppVarNames, int nVars )
if ( Flag == MIO_EQN_FLAG_VAR )
{
Vec_IntPush( pStackOp, MIO_EQN_OPER_AND );
// fprintf( stdout, "Mio_ParseFormula(): An opening paranthesis follows a var without operation sign.\n" );
// fprintf( stdout, "Mio_ParseFormula(): An opening parenthesis follows a var without operation sign.\n" );
// Flag = MIO_EQN_FLAG_ERROR;
// break;
}
@ -222,7 +222,7 @@ Vec_Int_t * Mio_ParseFormula( char * pFormInit, char ** ppVarNames, int nVars )
{
if ( Vec_IntSize( pStackOp ) == 0 )
{
fprintf( stdout, "Mio_ParseFormula(): There is no opening paranthesis\n" );
fprintf( stdout, "Mio_ParseFormula(): There is no opening parenthesis\n" );
Flag = MIO_EQN_FLAG_ERROR;
break;
}
@ -243,7 +243,7 @@ Vec_Int_t * Mio_ParseFormula( char * pFormInit, char ** ppVarNames, int nVars )
}
else
{
fprintf( stdout, "Mio_ParseFormula(): There is no opening paranthesis\n" );
fprintf( stdout, "Mio_ParseFormula(): There is no opening parenthesis\n" );
Flag = MIO_EQN_FLAG_ERROR;
break;
}
@ -262,7 +262,7 @@ Vec_Int_t * Mio_ParseFormula( char * pFormInit, char ** ppVarNames, int nVars )
{
if ( pTemp[i] == MIO_EQN_SYM_NEG || pTemp[i] == MIO_EQN_SYM_OPEN )
{
fprintf( stdout, "Mio_ParseFormula(): The negation sign or an opening paranthesis inside the variable name.\n" );
fprintf( stdout, "Mio_ParseFormula(): The negation sign or an opening parenthesis inside the variable name.\n" );
Flag = MIO_EQN_FLAG_ERROR;
break;
}

2
src/map/super/superWrite.c
View File

@ -35,7 +35,7 @@ ABC_NAMESPACE_IMPL_START
GATENAME1( GATENAME2( a, c ), GATENAME3( a, d ), ... )
The gate names (GATENAME1, etc) are the names as they appear in the .genlib library.
The primary inputs of the gates are denoted by lowercase chars 'a', 'b', etc.
The parantheses are mandatory for each gate, except for the wire.
The parentheses are mandatory for each gate, except for the wire.
The wire name can be omitted, so that "a" can be used instead of "**wire**( a )".
The spaces are optional in any position of this string.

2
src/opt/dau/dauMerge.c
View File

@ -264,7 +264,7 @@ static inline void Dau_DsdMergeInlineDefinitions( char * pDsd, int * pMatches, D
/**Function*************************************************************
Synopsis [Computes independence status for each opening paranthesis.]
Synopsis [Computes independence status for each opening parenthesis.]
Description []

6
src/sat/bmc/bmcFault.c
View File

@ -384,12 +384,12 @@ int Gia_FormStrCount( char * pStr, int * pnVars, int * pnPars )
int i, Counter = 0;
if ( pStr[0] != '(' )
{
printf( "The first symbol should be the opening paranthesis \"(\".\n" );
printf( "The first symbol should be the opening parenthesis \"(\".\n" );
return 1;
}
if ( pStr[strlen(pStr)-1] != ')' )
{
printf( "The last symbol should be the closing paranthesis \")\".\n" );
printf( "The last symbol should be the closing parenthesis \")\".\n" );
return 1;
}
for ( i = 0; pStr[i]; i++ )
@ -399,7 +399,7 @@ int Gia_FormStrCount( char * pStr, int * pnVars, int * pnPars )
Counter--;
if ( Counter != 0 )
{
printf( "The number of opening and closing parantheses is not equal.\n" );
printf( "The number of opening and closing parentheses is not equal.\n" );
return 1;
}
*pnVars = 0;