nickg / nvc / 13174766953

{SYNTH_OFF}              { TOKEN(tSYNTHOFF); }

{SYNTH_ON}               { TOKEN(tSYNTHON); }

{COVERAGE_OFF}           { TOKEN(tCOVERAGEOFF); }

{COVERAGE_ON}            { TOKEN(tCOVERAGEON); }

{TRANSLATE_OFF}          { TOKEN(tTRANSLATEOFF); }

{TRANSLATE_ON}           { TOKEN(tTRANSLATEON); }

<VLOG,UDP>"//"           { comment_caller = YY_START; BEGIN(COMMENT); }

{PSL_COMMENT}[^ \t\r\n]  { comment_caller = YY_START; BEGIN(COMMENT); }

{PSL_COMMENT}            { if (begin_psl_comment()) {

                              in_psl_comment = true;

                              BEGIN(PSL);

                              TOKEN(tSTARTPSL);

                              comment_caller = YY_START;

                              BEGIN(COMMENT);

<COMMENT>\n              { BEGIN(comment_caller); }

<COMMENT>.*              { }

"/*"                     { MIN_STD(STD_08, "delimited comments");

                           comment_caller = YY_START;

                           BEGIN(C_COMMENT);

<VLOG,UDP>"/*"           { comment_caller = YY_START; BEGIN(C_COMMENT); }

<C_COMMENT>"*/"          { BEGIN(comment_caller); }

<C_COMMENT>\n            { /* Must match a single character */ }

<C_COMMENT>.             { }

<PSL>;                   { TOKEN(tSEMI); }

<PSL>{PSL_CONT}          { /* Multi-line PSL comment */

                           if (!in_psl_comment) {

                              comment_caller = YY_START;

                              BEGIN(COMMENT);

{ENTITY}                 { TOKEN(tENTITY); }

{IS}                     { TOKEN(tIS); }

{END}                    { TOKEN(tEND); }

{GENERIC}                { TOKEN(tGENERIC); }

{PORT}                   { TOKEN(tPORT); }

{COMPONENT}              { TOKEN(tCOMPONENT); }

{CONFIGURATION}          { TOKEN(tCONFIGURATION); }

{ARCHITECTURE}           { TOKEN(tARCHITECTURE); }

{OF}                     { TOKEN(tOF); }

{BEGIN}                  { TOKEN(tBEGIN); }

{IN}                     { TOKEN(tIN); }

{OUT}                    { TOKEN(tOUT); }

{BUFFER}                 { TOKEN(tBUFFER); }

{BUS}                    { TOKEN(tBUS); }

{REGISTER}               { TOKEN(tREGISTER); }

{UNAFFECTED}             { TOKEN(tUNAFFECTED); }

{PROCESS}                { TOKEN(tPROCESS); }

{WAIT}                   { TOKEN(tWAIT); }

{REPORT}                 { TOKEN(tREPORT); }

{INOUT}                  { TOKEN(tINOUT); }

{LINKAGE}                { TOKEN(tLINKAGE); }

{FOR}                    { TOKEN(tFOR); }

{TYPE}                   { TOKEN(tTYPE); }

{SUBTYPE}                { TOKEN(tSUBTYPE); }

{UNITS}                  { TOKEN(tUNITS); }

{PACKAGE}                { TOKEN(tPACKAGE); }

{LIBRARY}                { TOKEN(tLIBRARY); }

{USE}                    { TOKEN(tUSE); }

{FUNCTION}               { TOKEN(tFUNCTION); }

{IMPURE}                 { TOKEN(tIMPURE); }

{PURE}                   { TOKEN(tPURE); }

{RETURN}                 { TOKEN(tRETURN); }

{ARRAY}                  { TOKEN(tARRAY); }

{OTHERS}                 { TOKEN(tOTHERS); }

{ASSERT}                 { TOKEN(tASSERT); }

{SEVERITY}               { TOKEN(tSEVERITY); }

{ON}                     { TOKEN(tON); }

{MAP}                    { TOKEN(tMAP); }

{IF}                     { TOKEN(tIF); }

{THEN}                   { TOKEN(tTHEN); }

{ELSE}                   { TOKEN(tELSE); }

{ELSIF}                  { TOKEN(tELSIF); }

{BODY}                   { TOKEN(tBODY); }

{WHILE}                  { TOKEN(tWHILE); }

{LOOP}                   { TOKEN(tLOOP); }

{AFTER}                  { TOKEN(tAFTER); }

{ALIAS}                  { TOKEN(tALIAS); }

{ATTRIBUTE}              { TOKEN(tATTRIBUTE); }

{PROCEDURE}              { TOKEN(tPROCEDURE); }

{POSTPONED}              { TOKEN(tPOSTPONED); }

{EXIT}                   { TOKEN(tEXIT); }

{WHEN}                   { TOKEN(tWHEN); }

{CASE}                   { TOKEN(tCASE); }

{TRANSPORT}              { TOKEN(tTRANSPORT); }

{REJECT}                 { TOKEN(tREJECT); }

{INERTIAL}               { TOKEN(tINERTIAL); }

{BLOCK}                  { TOKEN(tBLOCK); }

{WITH}                   { TOKEN(tWITH); }

{SELECT}                 { TOKEN(tSELECT); }

{GENERATE}               { TOKEN(tGENERATE); }

{ACCESS}                 { TOKEN(tACCESS); }

{FILE}                   { TOKEN(tFILE); }

{OPEN}                   { TOKEN(tOPEN); }

{RECORD}                 { TOKEN(tRECORD); }

{NEW}                    { TOKEN(tNEW); }

{SHARED}                 { TOKEN(tSHARED); }

{NEXT}                   { TOKEN(tNEXT); }

{LITERAL}                { TOKEN(tLITERAL); }

{GROUP}                  { TOKEN(tGROUP); }

{LABEL}                  { TOKEN(tLABEL); }

{GUARDED}                { TOKEN(tGUARDED); }

{DISCONNECT}             { TOKEN(tDISCONNECT); }

{REVRANGE}               { TOKEN(tREVRANGE); }

{PROTECTED}              { TOKEN_00(tPROTECTED); }

{CONTEXT}                { TOKEN_08(tCONTEXT); }

{FORCE}                  { TOKEN_08(tFORCE); }

{RELEASE}                { TOKEN_08(tRELEASE); }

{PARAMETER}              { TOKEN_08(tPARAMETER); }

{DEFAULT}                { TOKEN_08(tDEFAULT); }

{COVER}                  { TOKEN_08(tCOVER); }

{VIEW}                   { TOKEN_19(tVIEW); }

{PRIVATE}                { TOKEN_19(tPRIVATE); }

`{IF}                    { TOKEN(tCONDIF); }

`{ELSE}                  { TOKEN(tCONDELSE); }

`{ELSIF}                 { TOKEN(tCONDELSIF); }

`{END}                   { TOKEN(tCONDEND); }

`{ERROR}                 { TOKEN(tCONDERROR); }

`{WARNING}               { TOKEN(tCONDWARN); }

<INITIAL,PSL>{AND}       { TOKEN(tAND); }

<INITIAL,PSL>{OR}        { TOKEN(tOR); }

<INITIAL,PSL>{XOR}       { TOKEN(tXOR); }

<INITIAL,PSL>{XNOR}      { TOKEN(tXNOR); }

<INITIAL,PSL>{NAND}      { TOKEN(tNAND); }

<INITIAL,PSL>{NOR}       { TOKEN(tNOR); }

<INITIAL,PSL>{ABS}       { TOKEN(tABS); }

<INITIAL,PSL>{NOT}       { TOKEN(tNOT); }

<INITIAL,PSL>{ALL}       { TOKEN(tALL); }

<INITIAL,PSL>{TICK}      { TOKEN(tTICK); }

<INITIAL,PSL>{SLL}       { TOKEN(tSLL); }

<INITIAL,PSL>{SRL}       { TOKEN(tSRL); }

<INITIAL,PSL>{SLA}       { TOKEN(tSLA); }

<INITIAL,PSL>{SRA}       { TOKEN(tSRA); }

<INITIAL,PSL>{ROL}       { TOKEN(tROL); }

<INITIAL,PSL>{ROR}       { TOKEN(tROR); }

<INITIAL,PSL>{REM}       { TOKEN(tREM); }

<INITIAL,PSL>{MOD}       { TOKEN(tMOD); }

<INITIAL,PSL>{NULL}      { TOKEN(tNULL); }

<INITIAL,PSL>{RANGE}     { TOKEN(tRANGE); }

<INITIAL,PSL>{TO}        { TOKEN(tTO); }

<INITIAL,PSL>{DOWNTO}    { TOKEN(tDOWNTO); }

<INITIAL,PSL>{UNTIL}     { TOKEN(tUNTIL); }

<INITIAL,PSL>{CONSTANT}  { TOKEN(tCONSTANT); }

<INITIAL,PSL>{SIGNAL}    { TOKEN(tSIGNAL); }

<INITIAL,PSL>{VARIABLE}  { TOKEN(tVARIABLE); }

<UDP>{UDP_LEVEL}         { yylval.i64 = yytext[0]; return tUDPLEVEL; }

<UDP>{UDP_EDGE}          { yylval.i64 = yytext[0]; return tUDPEDGE; }

<UDP>{UDP_INDICATOR}     { yylval.str = xstrdup(yytext); return tUDPIND; }

<*>"("                   { TOKEN(tLPAREN); }

<*>")"                   { TOKEN(tRPAREN); }

<*>"["                   { TOKEN(tLSQUARE); }

<*>"]"                   { TOKEN(tRSQUARE); }

<*>"{"                   { TOKEN(tLBRACE); }

<*>"}"                   { TOKEN(tRBRACE); }

<*>","                   { TOKEN(tCOMMA); }

<*>";"                   { TOKEN(tSEMI); }

<*>":"                   { TOKEN(tCOLON); }

<*>"<"                   { TOKEN(tLT); }

<*>">"                   { TOKEN(tGT); }

<*>"+"                   { TOKEN(tPLUS); }

<*>"-"                   { TOKEN(tMINUS); }

<*>"*"                   { TOKEN(tTIMES); }

<*>"@"                   { TOKEN(tAT); }

<*>"?"                   { TOKEN(tQUESTION); }

<*>"{"                   { TOKEN(tLBRACE); }

<*>"}"                   { TOKEN(tRBRACE); }

<*>"/"                   { TOKEN(tOVER); }

<*>"."                   { TOKEN(tDOT); }

<*>"&"                   { TOKEN(tAMP); }

<*>"|"                   { TOKEN(tBAR); }

<*>"["                   { TOKEN(tLSQUARE); }

<*>"]"                   { TOKEN(tRSQUARE); }

<*>"="                   { TOKEN(tEQ); }

<*>"#"                   { TOKEN(tHASH); }

<*>"~"                   { TOKEN(tTILDE); }

<*>"[["                  { TOKEN(t2LSQUARE); }

<*>"]]"                  { TOKEN(t2RSQUARE); }

<INITIAL,PSL>"!"         { TOKEN(tBAR); }

<VLOG>"!"                { TOKEN(tBANG); }

<INITIAL,PSL>"**"        { TOKEN(tPOWER); }

<INITIAL,PSL>":="        { TOKEN(tWALRUS); }

<INITIAL,PSL>"<>"        { TOKEN(tBOX); }

<INITIAL,PSL>"?<"        { TOKEN_08(tMLT); }

<INITIAL,PSL>"?<="       { TOKEN_08(tMLE); }

<INITIAL,PSL>"?>"        { TOKEN_08(tMGT); }

<INITIAL,PSL>"?>="       { TOKEN_08(tMGE); }

<INITIAL,PSL>"??"        { TOKEN_08(tCCONV); }

<INITIAL,PSL>"/="        { TOKEN(tNEQ); }

<INITIAL,PSL>"?/="       { TOKEN_08(tMNEQ); }

<INITIAL,PSL>"?="        { TOKEN_08(tMEQ); }

<INITIAL,PSL>"<<"        { TOKEN(tLTLT); }

<INITIAL,PSL>">>"        { TOKEN(tGTGT); }

<INITIAL,PSL>"^"         { TOKEN(tCARET); }

<INITIAL,PSL,VLOG>"<="   { TOKEN(tLE); }

<INITIAL,PSL,VLOG>">="   { TOKEN(tGE); }

<INITIAL,PSL,VLOG>"=>"   { TOKEN(tASSOC); }

<PSL>{ASSERT}            { TOKEN(tASSERT); }

<PSL>{ASSUME}            { TOKEN(tASSUME); }

<PSL>{ASSUME_G}          { TOKEN(tASSUMEG); }

<PSL>{RESTRICT}          { TOKEN(tRESTRICT); }

<PSL>{RESTRICT_G}        { TOKEN(tRESTRICTG); }

<PSL>{STRONG}            { TOKEN(tSTRONG); }

<PSL>{FAIRNESS}          { TOKEN(tFAIRNESS); }

<PSL>{COVER}             { TOKEN(tCOVER); }

<PSL>{PROPERTY}          { TOKEN(tPROPERTY); }

<PSL>{SEQUENCE}          { TOKEN(tSEQUENCE); }

<PSL>{CONST}             { TOKEN(tCONST); }

<PSL>{MUTABLE}           { TOKEN(tMUTABLE); }

<PSL>{HDLTYPE}           { TOKEN(tHDLTYPE); }

<PSL>{BOOLEAN}           { TOKEN(tBOOLEAN); }

<PSL>{BIT}               { TOKEN(tBIT); }

<PSL>{BITVECTOR}         { TOKEN(tBITVECTOR); }

<PSL>{NUMERIC}           { TOKEN(tNUMERIC); }

<PSL>{STRING_K}          { TOKEN(tSTRINGK); }

<PSL>{ALWAYS}            { TOKEN(tALWAYS); }

<PSL>{DEFAULT}           { TOKEN(tDEFAULT); }

<PSL>{CLOCK}             { TOKEN(tCLOCK); }

<PSL>{IS}                { TOKEN(tIS); }

<PSL>{IN}                { TOKEN(tIN); }

<PSL>{FOR}               { TOKEN(tFOR); }

<PSL>"->"                { TOKEN(tIFIMPL); }

<PSL>"<->"               { TOKEN(tIFFIMPL); }

<PSL>{NEXT}              { TOKEN(tPSLNEXT); }

<PSL>{NEXT}!             { TOKEN(tNEXT1); }

<PSL>{NEVER}             { TOKEN(tNEVER); }

<PSL>{EVENTUALLY}!       { TOKEN(tEVENTUALLY); }

<PSL>{NEXT_A}            { TOKEN(tNEXTA); }

<PSL>{NEXT_A}!           { TOKEN(tNEXTA1); }

<PSL>{NEXT_E}            { TOKEN(tNEXTE); }

<PSL>{NEXT_EVENT}        { TOKEN(tNEXTEVENT); }

<PSL>"[*"                { TOKEN(tTIMESRPT); }

<PSL>"[+]"               { TOKEN(tPLUSRPT); }

<PSL>"[="                { TOKEN(tEQRPT); }

<PSL>"[->"               { TOKEN(tGOTORPT); }

<PSL>"&&"                { TOKEN(tDBLAMP); }

<PSL>{WITHIN}            { TOKEN(tWITHIN); }

<PSL>{PREV}              { TOKEN(tPREV); }

<PSL>{STABLE}            { TOKEN(tSTABLE); }

<PSL>{ROSE}              { TOKEN(tROSE); }

<PSL>{FELL}              { TOKEN(tFELL); }

<PSL>{ENDED}             { TOKEN(tENDED); }

<PSL>{NONDET}            { TOKEN(tNONDET); }

<PSL>{NONDET_V}          { TOKEN(tNONDETV); }

<PSL>{UNTIL}!            { TOKEN(tUNTIL1); }

<PSL>{UNTIL}_            { TOKEN(tUNTIL_); }

<PSL>{UNTIL}_!           { TOKEN(tUNTIL1_); }

<PSL>{ABORT}             { TOKEN(tABORT); }

<PSL>{ASYNC_ABORT}       { TOKEN(tASYNC_ABORT); }

<PSL>{SYNC_ABORT}        { TOKEN(tSYNC_ABORT); }

<PSL>{BEFORE}            { TOKEN(tBEFORE); }

<PSL>{BEFORE}!           { TOKEN(tBEFORE1); }

<PSL>{BEFORE}_           { TOKEN(tBEFORE_); }

<PSL>{BEFORE}!_          { TOKEN(tBEFORE1_); }

<PSL>"|->"               { TOKEN(tSUFFIXOVR); }

<PSL>"|=>"               { TOKEN(tSUFFIXNON); }

<PSL>{INF}               { TOKEN(tINF); }

<PSL>{ENDPOINT}          { TOKEN(tENDPOINT); }

<VLOG>"module"           { return tMODULE; }

<VLOG>"endmodule"        { return tENDMODULE; }

<VLOG>"input"            { return tINPUT; }

<VLOG>"output"           { return tOUTPUT; }

<VLOG>"inout"            { return tINOUT; }

<VLOG>"reg"              { return tREG; }

<VLOG>"always"           { return tALWAYS; }

<VLOG>"posedge"          { return tPOSEDGE; }

<VLOG>"negedge"          { return tNEGEDGE; }

<VLOG>"initial"          { return tINITIAL; }

<VLOG>"begin"            { return tBEGIN; }

<VLOG>"end"              { return tEND; }

<VLOG>"wire"             { return tWIRE; }

<VLOG>"tri"              { return tTRI; }

<VLOG>"tri0"             { return tTRI0; }

<VLOG>"tri1"             { return tTRI1; }

<VLOG>"wand"             { return tWAND; }

<VLOG>"triand"           { return tTRIAND; }

<VLOG>"wor"              { return tWOR; }

<VLOG>"trior"            { return tTRIOR; }

<VLOG>"trireg"           { return tTRIREG; }

<VLOG>"uwire"            { return tUWIRE; }

<VLOG>"none"             { return tNONE; }

<VLOG>"assign"           { return tASSIGN; }

<VLOG>"if"               { return tIF; }

<VLOG>"else"             { return tELSE; }

<VLOG>"`timescale"       { return tTIMESCALE; }

<VLOG>"`default_nettype" { return tDEFNETTYPE; }

<VLOG>"`celldefine"      { }

<VLOG>"`endcelldefine"   { }

<VLOG>"`begin_keywords"  { return tBEGINKEYWORDS; }

<VLOG>"`end_keywords"    { return tENDKEYWORDS; }

<VLOG>"`__nvc_push"      { return tNVCPUSH; }

<VLOG>"`__nvc_pop"       { return tNVCPOP; }

<VLOG>"supply0"          { return tSUPPLY0; }

<VLOG>"supply1"          { return tSUPPLY1; }

<VLOG>"pulldown"         { return tPULLDOWN; }

<VLOG>"pullup"           { return tPULLUP; }

<VLOG>"forever"          { return tFOREVER; }

<VLOG>"=="               { return tLOGEQ; }

<VLOG>"!="               { return tLOGNEQ; }

<VLOG>"==="              { return tCASEEQ; }

<VLOG>"!=="              { return tCASENEQ; }

<VLOG>"||"               { return tLOGOR; }

<VLOG>"&&"               { return tDBLAMP; }

<VLOG>"<<"               { return tSHIFTLL; }

<VLOG>">>"               { return tSHIFTRL; }

<VLOG>"<<<"              { return tSHIFTLA; }

<VLOG>">>>"              { return tSHIFTRA; }

<VLOG>"(*"               { return tATTRBEGIN; }

<VLOG>"*)"               { return tATTREND; }

<VLOG>"%"                { return tPERCENT; }

<VLOG>"++"               { return tPLUSPLUS; }

<VLOG>"--"               { return tMINUSMINUS; }

<VLOG>"var"              { return tVAR; }

<VLOG>"specify"          { return tSPECIFY; }

<VLOG>"endspecify"       { return tENDSPECIFY; }

<VLOG>"primitive"        { return tPRIMITIVE; }

<VLOG>"endprimitive"     { return tENDPRIMITIVE; }

<VLOG>"table"            { return tTABLE; }

<VLOG,UDP>"endtable"     { return tENDTABLE; }

<VLOG>"and"              { return tAND; }

<VLOG>"nand"             { return tNAND; }

<VLOG>"or"               { return tOR; }

<VLOG>"nor"              { return tNOR; }

<VLOG>"xor"              { return tXOR; }

<VLOG>"not"              { return tNOT; }

<VLOG>"struct"           { return tSTRUCT; }

<VLOG>"void"             { return tVOID; }

<VLOG>"byte"             { return tBYTE; }

<VLOG>"longint"          { return tLONGINT; }

<VLOG>"int"              { return tSVINT; }

<VLOG>"integer"          { return tINTEGER; }

<VLOG>"real"             { return tSVREAL; }

<VLOG>"shortreal"        { return tSHORTREAL; }

<VLOG>"realtime"         { return tREALTIME; }

<VLOG>"time"             { return tTIME; }

<VLOG>"typedef"          { return tTYPEDEF; }

<VLOG>"logic"            { return tLOGIC; }

<VLOG>"enum"             { return tENUM; }

<VLOG>"union"            { return tUNION; }

<VLOG>"tagged"           { return tTAGGED; }

<VLOG>"while"            { return tWHILE; }

<VLOG>"repeat"           { return tREPEAT; }

<VLOG>"do"               { return tDO; }

<VLOG>"task"             { return tTASK; }

<VLOG>"endtask"          { return tENDTASK; }

<VLOG>"function"         { return tFUNCTION; }

<VLOG>"endfunction"      { return tENDFUNCTION; }

<VLOG>"wait"             { return tWAIT; }

<VLOG>"parameter"        { return tPARAMETER; }

<VLOG>"for"              { return tFOR; }

<VLOG>{SYSTASK}          { yylval.str = xstrdup(yytext); return tSYSTASK; }

<VLOG>{VLOG_ID}          { yylval.str = xstrdup(yytext); return tID; }

<VLOG>{INTEGER}          { yylval.str = xstrdup(yytext); return tUNSIGNED; }

<VLOG>{VLOG_STRING}      { return escape_verilog_string(yytext); }

<VLOG>{VLOG_NUMBER}      { yylval.str = xstrdup(yytext); return tNUMBER; }

<VLOG>{VLOG_REAL}        { return parse_verilog_real(yytext); };

<INITIAL,PSL>{DECIMAL}   { return parse_decimal_literal(yytext); }

<INITIAL,PSL>{BASED}     { return parse_based_literal(yytext); }

<INITIAL,PSL>{BITSTRING} { return parse_bit_string(yytext); }

<INITIAL,PSL>{STRING}    { return parse_string(yytext); }

<INITIAL,PSL>{BADSTRING} { return report_unterminated_string(yytext); }

<INITIAL,PSL>{CHAR}      { if (resolve_ir1045()) {

                              yylval.ident = ident_new(yytext);

                              TOKEN(tID);

                           REJECT;

<PSL>{REPORT}            { TOKEN(tREPORT); }

<SDF,SDF_EXPR>"!"       { TOKEN(tBANG); }

<SDF,SDF_EXPR>"<<"      { TOKEN(tLTLT); }

<SDF,SDF_EXPR>">>"      { TOKEN(tGTGT); }

<SDF,SDF_EXPR>"<="      { TOKEN(tLE); }

<SDF,SDF_EXPR>">="      { TOKEN(tGE); }

<SDF,SDF_EXPR>"&&"      { TOKEN(tDBLAMP); }

<SDF,SDF_EXPR>"~&"      { TOKEN(tTILDEAMP); }

<SDF,SDF_EXPR>"~|"      { TOKEN(tTILDEBAR); }

<SDF,SDF_EXPR>"^~"      { TOKEN(tTILDECARET); }

<SDF,SDF_EXPR>"~^"      { TOKEN(tTILDECARET); }

<SDF,SDF_EXPR>"%"       { TOKEN(tPERCENT); }

<SDF,SDF_EXPR>"||"      { TOKEN(tLOGOR); }

<SDF,SDF_EXPR>"^"       { TOKEN(tCARET); }

<SDF,SDF_EXPR>"=="      { TOKEN(tLOGEQ); }

<SDF,SDF_EXPR>"!="      { TOKEN(tLOGNEQ); }

<SDF,SDF_EXPR>"==="     { TOKEN(tCASEEQ); }

<SDF,SDF_EXPR>"!=="     { TOKEN(tCASENEQ); }

<SDF,SDF_EXPR>"//"      { comment_caller = YY_START; BEGIN(COMMENT); }

<SDF,SDF_EXPR>"/*"      { comment_caller = YY_START;

                          BEGIN(C_COMMENT);

                        }

<SDF,SDF_EXPR>{SCALAR_ZERO}   { TOKEN(tSCALARZERO); }

<SDF,SDF_EXPR>{SCALAR_ONE}    { TOKEN(tSCALARONE); }

% /* TODO: Crosscheck SDF definition of decimal */

<SDF,SDF_EXPR>{DECIMAL} { return parse_decimal_literal(yytext); }

% /* VLOG_STRING is defined almost equally as SDF qstring */

<SDF>{VLOG_STRING}     { return parse_string(yytext); }

<SDF>{DELAYFILE}        { TOKEN(tDELAYFILE); }

<SDF>{SDFVERSION}       { TOKEN(tSDFVERSION); }

<SDF>{DESIGN}           { TOKEN(tDESIGN); }

<SDF>{DATE}             { TOKEN(tDATE); }

<SDF>{VENDOR}           { TOKEN(tVENDOR); }

<SDF>{PROGRAM}          { TOKEN(tPROGRAM); }

<SDF>{VERSION}          { TOKEN(tVERSION); }

<SDF>{DIVIDER}          { TOKEN(tDIVIDER); }

<SDF>{VOLTAGE}          { TOKEN(tVOLTAGE); }

<SDF>{PROCESS}          { TOKEN(tPROCESS); }

<SDF>{TEMPERATURE}      { TOKEN(tTEMPERATURE); }

<SDF>{TIMESCALE}        { TOKEN(tTIMESCALE); }

<SDF>{CELL}             { TOKEN(tCELL); }

<SDF>{CELLTYPE}         { TOKEN(tCELLTYPE); }

<SDF>{INSTANCE}         { TOKEN(tINSTANCE); }

<SDF>{DELAY}            { TOKEN(tDELAY); }

<SDF>{ABSOLUTE}         { TOKEN(tABSOLUTE); }

<SDF>{PATHPULSE}        { TOKEN(tPATHPULSE); }

<SDF>{PATHPULSEP}       { TOKEN(tPATHPULSEP); }

<SDF>{INCREMENT}        { TOKEN(tINCREMENT); }

<SDF>{IOPATH}           { TOKEN(tIOPATH); }

<SDF>"posedge"          { TOKEN(tPOSEDGE); }

<SDF>"negedge"          { TOKEN(tNEGEDGE); }

<SDF>{SETUP}            { TOKEN(tSETUP); }

<SDF>{HOLD}             { TOKEN(tHOLD); }

<SDF>{SETUPHOLD}        { TOKEN(tSETUPHOLD); }

<SDF>{RECOVERY}         { TOKEN(tRECOVERY); }

<SDF>{REMOVAL}          { TOKEN(tREMOVAL); }

<SDF>{RECREM}           { TOKEN(tRECREM); }

<SDF>{WIDTH}            { TOKEN(tWIDTH); }

<SDF>{PERIOD}           { TOKEN(tPERIOD); }

<SDF>{SKEW}             { TOKEN(tSKEW); }

<SDF>{BIDIRSKEW}        { TOKEN(tBIDIRSKEW); }

<SDF>{NOCHANGE}         { TOKEN(tNOCHANGE); }

<SDF>{PORT}             { TOKEN(tPORT); }

<SDF>{INTERCONNECT}     { TOKEN(tINTERCONNECT); }

<SDF>{NETDELAY}         { TOKEN(tNETDELAY); }

<SDF>{DEVICE}           { TOKEN(tDEVICE); }

<SDF>{COND}             { TOKEN(tSDFCOND); }

<SDF>{CONDELSE}         { TOKEN(tSDFCONDELSE); }

<SDF>{PATHCONSTRAINT}   { TOKEN(tPATHCONSTR); }

<SDF>{PERIODCONSTRAINT} { TOKEN(tPERIODCONSTR); }

<SDF>{SUM}              { TOKEN(tSUM); }

<SDF>{DIFF}             { TOKEN(tDIFF); }

<SDF>{SKEWCONSTRAINT}   { TOKEN(tSKEWCONSTR); }

<SDF>{ARRIVAL}          { TOKEN(tARRIVAL); }

<SDF>{DEPARTURE}        { TOKEN(tDEPARTURE); }

<SDF>{NAME}             { TOKEN(tNAME); }

<SDF>{EXCEPTION}        { TOKEN(tEXCEPTION); }

<SDF>{LABEL}            { TOKEN(tLABEL); }

<SDF>{TIMINGCHECK}      { TOKEN(tTIMINGCHECK); }

<SDF>{TIMINGENV}        { TOKEN(tTIMINGENV); }

<SDF>{RETAIN}           { TOKEN(tRETAIN); }

<SDF>{SCOND}            { TOKEN(tSCOND); }

<SDF>{CCOND}            { TOKEN(tCCOND); }

<SDF,SDF_EXPR>{SDF_ID}  { yylval.str = xstrdup(yytext); TOKEN(tID); }

<INITIAL,PSL>{UTF8_MB}   { warn_utf8(yytext); REJECT; }

<INITIAL,PSL>{VHDL_ID}   { return parse_id(yytext); }

{EXID}                   { return parse_ex_id(yytext); }

<INITIAL,PSL>{BAD_ID}    { return report_bad_identifier(yytext); }

<*>{SPACE}               { }

<*>"\n"                  { /* Must match a single character */ }

<*><<EOF>>               { return 0; }

<*>.                     { TOKEN(tERROR); }

%%

static int resolve_ir1045(void)

   switch (last_token) {

   default:

      return 1;