nickg / nvc / 9898011961

{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>"//"               { comment_caller = YY_START; BEGIN(COMMENT); }

{PSL_COMMENT}            { if (begin_psl_comment()) {

                              BEGIN(PSL);

                              TOKEN(tSTARTPSL);

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

<COMMENT>.*              { }

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

                           comment_caller = YY_START;

                           BEGIN(C_COMMENT);

<VLOG>"/*"               { 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 */ }

<PSL>"--"                { comment_caller = YY_START; BEGIN(COMMENT); }

{ENTITY}                 { TOKEN(tENTITY); }

{IS}                     { TOKEN(tIS); }

{END}                    { TOKEN(tEND); }

{GENERIC}                { TOKEN(tGENERIC); }

{PORT}                   { TOKEN(tPORT); }

{CONSTANT}               { TOKEN(tCONSTANT); }

{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); }

{SIGNAL}                 { TOKEN(tSIGNAL); }

{PROCESS}                { TOKEN(tPROCESS); }

{WAIT}                   { TOKEN(tWAIT); }

{REPORT}                 { TOKEN(tREPORT); }

{INOUT}                  { TOKEN(tINOUT); }

{LINKAGE}                { TOKEN(tLINKAGE); }

{VARIABLE}               { TOKEN(tVARIABLE); }

{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); }

{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); }

<*>"("                   { 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(tASSIGN); }

<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>"->"                { TOKEN(tIFIMPL); }

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

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

<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(tGOTORPT); }

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

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

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

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

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

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

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

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

<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>"assign"           { return tASSIGN; }

<VLOG>"if"               { return tIF; }

<VLOG>"else"             { return tELSE; }

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

<VLOG>"`celldefine"      { }

<VLOG>"`endcelldefine"   { }

<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 tATTRBEGIN; }

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

<VLOG>"specify"          { return tSPECIFY; }

<VLOG>"endspecify"       { return tENDSPECIFY; }

<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; }

<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); }

<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;

static bool begin_psl_comment(void)

   static bool printed = false;

   if (opt_get_int(OPT_PSL_COMMENTS))

static int parse_id(char *str)

   for (char *p = str; *p; p++)

      *p = toupper_iso88591(*p);

   yylval.ident = ident_new(str);

   TOKEN(tID);

static int parse_ex_id(char *str)

   char *p = str + 1;

   for (char *s = p; *s; ) {

      if (*s == '\\' && *(s + 1) == '\\') s++;

      *p++ = *s++;

   *p = '\0';

   yylval.ident = ident_new(str);

   TOKEN(tID);

static void strip_underscores(char *s)

   bool error = false;

   char *p;

   for (p = s; *s; s++) {

      if (*s != '_')

         *p++ = *s;

      else if ((s[1] == '\0' || s[1] == '_') && !error) {

         error_at(&yylloc, "a literal may not end with an underscore or "

         error = true;

   *p = '\0';

}

static int parse_decimal_literal(const char *str)

   int tok = tERROR;

   char *tmp LOCAL = xstrdup(str);

   strip_underscores(tmp);

   char *dot = strpbrk(tmp, ".");

   if (dot == NULL) {

      char *sign = strpbrk(tmp, "-");

      char *val  = strtok(tmp, "eE");

      char *exp  = strtok(NULL, "eE");

      errno = 0;

      yylval.i64 = strtoll(val, NULL, 10);

      bool overflow = (errno == ERANGE);

      long long int e = (exp ? atoll(exp) : 0);

      if (e >= 0) {  // Minus sign forbidden for an integer literal

         for (; e > 0; e--) {

            if (__builtin_mul_overflow(yylval.i64, INT64_C(10), &yylval.i64))

               overflow = true;

         tok = (sign == NULL) ? tINT : tERROR;

      if (overflow)

         error_at(&yylloc, "value %s is outside implementation defined range "

      yylval.real = strtod(tmp, NULL);

      tok = tREAL;

   TOKEN(tok);

static int parse_based_literal(const char *str)

   int tok = tERROR;

   char *tmp LOCAL = xstrdup(str);

   strip_underscores(tmp);

   char *dot  = strpbrk(tmp, ".");

   char *sign = strpbrk(tmp, "-");

   char *base = strtok(tmp, "#:");

   char *val  = strtok(NULL, "#:");

   char *exp  = strtok(NULL, "eE");

   if ((2 <= atoi(base)) && (atoi(base) <= 16)) {

      if (dot == NULL) {

         char *eptr;

         yylval.i64 = strtoll(val, &eptr, atoi(base));

         long long int e = (exp ? atoll(exp) : 0);

         if (e >= 0) {  // Minus sign forbidden for an integer literal

            for (; e > 0; e--) yylval.i64 *= atoi(base);

            tok = ((*eptr == '\0') && (sign == NULL)) ? tINT : tERROR;

         char *eptr_integer, *eptr_rational;

         char *integer  = strtok(val, ".");

         char *rational = strtok(NULL, ".");

         yylval.real = (double)strtoll(integer, &eptr_integer, atoi(base));

         double tmp = (double)strtoll(rational, &eptr_rational, atoi(base));

         tmp *= pow((double)atoi(base), (double)((long)(0 - strlen(rational))));

         yylval.real += tmp;

         long long int e = (exp ? atoll(exp) : 0);

         if (e != 0)

            yylval.real *= pow((double) atoi(base), (double) e);

         if (*eptr_integer == '\0' && *eptr_rational == '\0')

   TOKEN(tok);

static int parse_string(const char *str)

   char *s = (yylval.str = xstrdup(str));

   s++;

   char *p = s;

   while (*p) {

      if ((*p == *(yylval.str)) && (*(p+1) == *(yylval.str))) p++;

      *s++ = *p++;

   *s = *p;

   TOKEN(tSTRING);

static int parse_bit_string(const char *str)

   char *copy = (yylval.str = xstrdup(str));

   bool error = false;

   for (char *src = copy, *dst = src; *src != '\0'; src++) {

      if (*src == '%')

         *dst++ = '\"';

      else if (*src != '_')

         *dst++ = *src;

      else if ((src[-1] == '\"' || src[1] == '\"') && !error) {

         error_at(&yylloc, "a bit string literal may not start or end with "

         error = true;

      else if (src[-1] == '_' && !error) {

         error_at(&yylloc, "a bit string literal may not contain multiple "

         error = true;

   TOKEN(tBITSTRING);

static int report_unterminated_string(const char *str)

   diag_t *d = diag_new(DIAG_ERROR, &yylloc);

   diag_printf(d, "unterminated string literal");

   diag_hint(d, NULL, "a string literal must fit on one line since it "

   diag_lrm(d, STD_08, "15.7");

   diag_emit(d);

   return parse_string(str);

static int report_bad_identifier(char *str)

   diag_t *d = diag_new(DIAG_ERROR, &yylloc);

   diag_printf(d, "a VHDL basic identifier must not start or end with an "

   diag_lrm(d, STD_08, "15.4.2");

   diag_emit(d);

   return parse_id(str);

static int escape_verilog_string(const char *str)

   char *s = (yylval.str = xstrdup(str));

   for (char *p = s; *p; p++) {

      if (*p == '\\') {

         switch (*++p) {

         case 'n': *s++ = '\n'; break;

         *s++ = *p;

   *s = '\0';

   return tSTRING;

static void warn_lrm(vhdl_standard_t std, const char *fmt, ...)

   va_list ap;

   va_start(ap, fmt);

   diag_t *d = diag_new(DIAG_WARN, &yylloc);

   diag_vprintf(d, fmt, ap);

   diag_hint(d, NULL, "pass $bold$--std=%s$$ to enable this feature",

   diag_emit(d);

   va_end(ap);

}

static void warn_utf8(const char *text)

   static bool warned = false;

   if (!warned) {

      diag_t *d = diag_new(DIAG_WARN, &yylloc);

      diag_printf(d, "possible multi-byte UTF-8 character found in input");

      diag_hint(d, NULL, "the native encoding of VHDL is ISO-8859-1");

      diag_emit(d);