first commit
authorLuke Kenneth Casson Leighton <lkcl@lkcl.net>
Wed, 24 Apr 2019 15:00:53 +0000 (16:00 +0100)
committerLuke Kenneth Casson Leighton <lkcl@lkcl.net>
Wed, 24 Apr 2019 15:00:53 +0000 (16:00 +0100)
.gitignore [new file with mode: 0644]
lexor.lex [new file with mode: 0644]
lexor.py [new file with mode: 0644]
parse.py [new file with mode: 0644]
parse.y [new file with mode: 0644]
parse_sv.py [new file with mode: 0644]
svparse.py [new file with mode: 0644]

diff --git a/.gitignore b/.gitignore
new file mode 100644 (file)
index 0000000..d58d739
--- /dev/null
@@ -0,0 +1,4 @@
+*.pyc
+.*.sw?
+parsetab.py*
+parsetok.py*
diff --git a/lexor.lex b/lexor.lex
new file mode 100644 (file)
index 0000000..b99329b
--- /dev/null
+++ b/lexor.lex
@@ -0,0 +1,1636 @@
+%{
+/*
+ * Copyright (c) 1998-2017 Stephen Williams (steve@icarus.com)
+ *
+ *    This source code is free software; you can redistribute it
+ *    and/or modify it in source code form under the terms of the GNU
+ *    General Public License as published by the Free Software
+ *    Foundation; either version 2 of the License, or (at your option)
+ *    any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program; if not, write to the Free Software
+ *    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+# include "config.h"
+
+      //# define YYSTYPE lexval
+
+# include  <iostream>
+# include  "compiler.h"
+# include  "parse_misc.h"
+# include  "parse_api.h"
+# include  "parse.h"
+# include  <cctype>
+# include  <cstring>
+# include  "lexor_keyword.h"
+# include  "discipline.h"
+# include  <list>
+
+# define YY_USER_INIT reset_lexor();
+# define yylval VLlval
+
+# define YY_NO_INPUT
+
+/*
+ * Lexical location information is passed in the yylloc variable to th
+ * parser. The file names, strings, are kept in a list so that I can
+ * re-use them. The set_file_name function will return a pointer to
+ * the name as it exists in the list (and delete the passed string.)
+ * If the name is new, it will be added to the list.
+ */
+extern YYLTYPE yylloc;
+
+char* strdupnew(char const *str)
+{
+       return str ? strcpy(new char [strlen(str)+1], str) : 0;
+}
+
+static const char* set_file_name(char*text)
+{
+      perm_string path = filename_strings.make(text);
+      delete[]text;
+
+       /* Check this file name with the list of library file
+          names. If there is a match, then turn on the
+          pform_library_flag. This is how the parser knows that
+          modules declared in this file are library modules. */
+      pform_library_flag = library_file_map[path];
+      return path;
+}
+
+void reset_lexor();
+static void line_directive();
+static void line_directive2();
+static void reset_all();
+
+verinum*make_unsized_binary(const char*txt);
+verinum*make_undef_highz_dec(const char*txt);
+verinum*make_unsized_dec(const char*txt);
+verinum*make_unsized_octal(const char*txt);
+verinum*make_unsized_hex(const char*txt);
+
+static int dec_buf_div2(char *buf);
+
+static void process_timescale(const char*txt);
+static void process_ucdrive(const char*txt);
+
+static list<int> keyword_mask_stack;
+
+static int comment_enter;
+static bool in_module = false;
+static bool in_UDP = false;
+bool in_celldefine = false;
+UCDriveType uc_drive = UCD_NONE;
+
+/*
+ * The parser sometimes needs to indicate to the lexor that the next
+ * identifier needs to be understood in the context of a package. The
+ * parser feeds back that left context with calls to the
+ * lex_in_package_scope.
+ */
+static PPackage* in_package_scope = 0;
+void lex_in_package_scope(PPackage*pkg)
+{
+      in_package_scope = pkg;
+}
+
+%}
+
+/*
+%x CCOMMENT
+%x PCOMMENT
+%x LCOMMENT
+%x CSTRING
+%s UDPTABLE
+%x PPTIMESCALE
+%x PPUCDRIVE
+%x PPDEFAULT_NETTYPE
+%x PPBEGIN_KEYWORDS
+%s EDGES
+%x REAL_SCALE
+*/
+
+W [ \t\b\f\r]+
+
+S [afpnumkKMGT]
+
+TU [munpf]
+
+%%
+
+  /* Recognize the various line directives. */
+^"#line"[ \t]+.+ { line_directive(); }
+^[ \t]?"`line"[ \t]+.+ { line_directive2(); }
+
+[ \t\b\f\r] { ; }
+\n { yylloc.first_line += 1; }
+
+  /* C++ style comments start with / / and run to the end of the
+     current line. These are very easy to handle. The meta-comments
+     format is a little more tricky to handle, but do what we can. */
+
+  /* The lexor detects "// synthesis translate_on/off" meta-comments,
+     we handle them here by turning on/off a flag. The pform uses
+     that flag to attach implicit attributes to "initial" and
+     "always" statements. */
+
+"//"{W}*"synthesis"{W}+"translate_on"{W}*\n { pform_mc_translate_on(true); }
+"//"{W}*"synthesis"{W}+"translate_off"{W}*\n { pform_mc_translate_on(false); }
+"//" { comment_enter = YY_START; BEGIN(LCOMMENT); }
+<LCOMMENT>.    { yymore(); }
+<LCOMMENT>\n   { yylloc.first_line += 1; BEGIN(comment_enter); }
+
+
+  /* The contents of C-style comments are ignored, like white space. */
+
+"/*" { comment_enter = YY_START; BEGIN(CCOMMENT); }
+<CCOMMENT>.    { ; }
+<CCOMMENT>\n   { yylloc.first_line += 1; }
+<CCOMMENT>"*/" { BEGIN(comment_enter); }
+
+
+"(*" { return K_PSTAR; }
+"*)" { return K_STARP; }
+".*" { return K_DOTSTAR; }
+"<<" { return K_LS; }
+"<<<" { return K_LS; /* Note: Functionally, <<< is the same as <<. */}
+">>"  { return K_RS; }
+">>>" { return K_RSS; }
+"**" { return K_POW; }
+"<=" { return K_LE; }
+">=" { return K_GE; }
+"=>" { return K_EG; }
+"+=>"|"-=>"    {
+                       /*
+                        * Resolve the ambiguity between the += assignment
+                        * operator and +=> polarity edge path operator
+                        *
+                        * +=> should be treated as two separate tokens '+' and
+                        * '=>' (K_EG), therefore we only consume the first
+                        * character of the matched pattern i.e. either + or -
+                        * and push back the rest of the matches text (=>) in
+                        * the input stream.
+                        */
+                       yyless(1);
+                       return yytext[0];
+               }
+"*>" { return K_SG; }
+"==" { return K_EQ; }
+"!=" { return K_NE; }
+"===" { return K_CEQ; }
+"!==" { return K_CNE; }
+"==?" { return K_WEQ; }
+"!=?" { return K_WNE; }
+"||" { return K_LOR; }
+"&&" { return K_LAND; }
+"&&&" { return K_TAND; }
+"~|" { return K_NOR; }
+"~^" { return K_NXOR; }
+"^~" { return K_NXOR; }
+"~&" { return K_NAND; }
+"->" { return K_TRIGGER; }
+"+:" { return K_PO_POS; }
+"-:" { return K_PO_NEG; }
+"<+" { return K_CONTRIBUTE; }
+"+=" { return K_PLUS_EQ; }
+"-=" { return K_MINUS_EQ; }
+"*=" { return K_MUL_EQ; }
+"/=" { return K_DIV_EQ; }
+"%=" { return K_MOD_EQ; }
+"&=" { return K_AND_EQ; }
+"|=" { return K_OR_EQ; }
+"^=" { return K_XOR_EQ; }
+"<<=" { return K_LS_EQ; }
+">>=" { return K_RS_EQ; }
+"<<<=" { return K_LS_EQ; }
+">>>=" { return K_RSS_EQ; }
+"++" { return K_INCR; }
+"--" {return K_DECR; }
+"'{" { return K_LP; }
+"::" { return K_SCOPE_RES; }
+
+  /* Watch out for the tricky case of (*). Cannot parse this as "(*"
+     and ")", but since I know that this is really ( * ), replace it
+     with "*" and return that. */
+"("{W}*"*"{W}*")" { return '*'; }
+
+<EDGES>"]" { BEGIN(0); return yytext[0]; }
+[}{;:\[\],()#=.@&!?<>%|^~+*/-] { return yytext[0]; }
+
+\"            { BEGIN(CSTRING); }
+<CSTRING>\\\\ { yymore(); /* Catch \\, which is a \ escaping itself */ }
+<CSTRING>\\\" { yymore(); /* Catch \", which is an escaped quote */ }
+<CSTRING>\n   { BEGIN(0);
+                yylval.text = strdupnew(yytext);
+               VLerror(yylloc, "Missing close quote of string.");
+               yylloc.first_line += 1;
+               return STRING; }
+<CSTRING>\"   { BEGIN(0);
+                yylval.text = strdupnew(yytext);
+               yylval.text[strlen(yytext)-1] = 0;
+               return STRING; }
+<CSTRING>.    { yymore(); }
+
+  /* The UDP Table is a unique lexical environment. These are most
+     tokens that we can expect in a table. */
+<UDPTABLE>\(\?0\)    { return '_'; }
+<UDPTABLE>\(\?1\)    { return '+'; }
+<UDPTABLE>\(\?[xX]\) { return '%'; }
+<UDPTABLE>\(\?\?\)  { return '*'; }
+<UDPTABLE>\(01\)    { return 'r'; }
+<UDPTABLE>\(0[xX]\) { return 'Q'; }
+<UDPTABLE>\(b[xX]\) { return 'q'; }
+<UDPTABLE>\(b0\)    { return 'f'; /* b0 is 10|00, but only 10 is meaningful */}
+<UDPTABLE>\(b1\)    { return 'r'; /* b1 is 11|01, but only 01 is meaningful */}
+<UDPTABLE>\(0\?\)   { return 'P'; }
+<UDPTABLE>\(10\)    { return 'f'; }
+<UDPTABLE>\(1[xX]\) { return 'M'; }
+<UDPTABLE>\(1\?\)   { return 'N'; }
+<UDPTABLE>\([xX]0\) { return 'F'; }
+<UDPTABLE>\([xX]1\) { return 'R'; }
+<UDPTABLE>\([xX]\?\) { return 'B'; }
+<UDPTABLE>[bB]     { return 'b'; }
+<UDPTABLE>[lL]     { return 'l'; /* IVL extension */ }
+<UDPTABLE>[hH]     { return 'h'; /* IVL extension */ }
+<UDPTABLE>[fF]     { return 'f'; }
+<UDPTABLE>[rR]     { return 'r'; }
+<UDPTABLE>[xX]     { return 'x'; }
+<UDPTABLE>[nN]     { return 'n'; }
+<UDPTABLE>[pP]     { return 'p'; }
+<UDPTABLE>[01\?\*\-:;] { return yytext[0]; }
+
+<EDGES>"01" { return K_edge_descriptor; }
+<EDGES>"0x" { return K_edge_descriptor; }
+<EDGES>"0z" { return K_edge_descriptor; }
+<EDGES>"10" { return K_edge_descriptor; }
+<EDGES>"1x" { return K_edge_descriptor; }
+<EDGES>"1z" { return K_edge_descriptor; }
+<EDGES>"x0" { return K_edge_descriptor; }
+<EDGES>"x1" { return K_edge_descriptor; }
+<EDGES>"z0" { return K_edge_descriptor; }
+<EDGES>"z1" { return K_edge_descriptor; }
+
+[a-zA-Z_][a-zA-Z0-9$_]* {
+      int rc = lexor_keyword_code(yytext, yyleng);
+      switch (rc) {
+         case IDENTIFIER:
+           yylval.text = strdupnew(yytext);
+           if (strncmp(yylval.text,"PATHPULSE$", 10) == 0)
+                 rc = PATHPULSE_IDENTIFIER;
+           break;
+
+         case K_edge:
+           BEGIN(EDGES);
+           break;
+
+         case K_module:
+         case K_macromodule:
+           in_module = true;
+           break;
+
+         case K_endmodule:
+           in_module = false;
+           break;
+
+         case K_primitive:
+           in_UDP = true;
+           break;
+
+         case K_endprimitive:
+           in_UDP = false;
+           break;
+
+         case K_table:
+           BEGIN(UDPTABLE);
+           break;
+
+         default:
+           yylval.text = 0;
+           break;
+      }
+
+       /* Special case: If this is part of a scoped name, then check
+          the package for identifier details. For example, if the
+          source file is  foo::bar, the parse.y will note the
+          PACKAGE_IDENTIFIER and "::" token and mark the
+          "in_package_scope" variable. Then this lexor will see the
+          identifier here and interpret it in the package scope. */
+      if (in_package_scope) {
+           if (rc == IDENTIFIER) {
+                 if (data_type_t*type = pform_test_type_identifier(in_package_scope, yylval.text)) {
+                       yylval.type_identifier.text = yylval.text;
+                       yylval.type_identifier.type = type;
+                       rc = TYPE_IDENTIFIER;
+                 }
+           }
+           in_package_scope = 0;
+           return rc;
+      }
+
+       /* If this identifier names a discipline, then return this as
+          a DISCIPLINE_IDENTIFIER and return the discipline as the
+          value instead. */
+      if (rc == IDENTIFIER && gn_verilog_ams_flag) {
+           perm_string tmp = lex_strings.make(yylval.text);
+           map<perm_string,ivl_discipline_t>::iterator cur = disciplines.find(tmp);
+           if (cur != disciplines.end()) {
+                 delete[]yylval.text;
+                 yylval.discipline = (*cur).second;
+                 rc = DISCIPLINE_IDENTIFIER;
+           }
+      }
+
+       /* If this identifier names a previously declared package, then
+          return this as a PACKAGE_IDENTIFIER instead. */
+      if (rc == IDENTIFIER && gn_system_verilog()) {
+           if (PPackage*pkg = pform_test_package_identifier(yylval.text)) {
+                 delete[]yylval.text;
+                 yylval.package = pkg;
+                 rc = PACKAGE_IDENTIFIER;
+           }
+      }
+
+       /* If this identifier names a previously declared type, then
+          return this as a TYPE_IDENTIFIER instead. */
+      if (rc == IDENTIFIER && gn_system_verilog()) {
+           if (data_type_t*type = pform_test_type_identifier(yylval.text)) {
+                 yylval.type_identifier.text = yylval.text;
+                 yylval.type_identifier.type = type;
+                 rc = TYPE_IDENTIFIER;
+           }
+      }
+
+      return rc;
+  }
+
+
+\\[^ \t\b\f\r\n]+         {
+      yylval.text = strdupnew(yytext+1);
+      if (gn_system_verilog()) {
+           if (PPackage*pkg = pform_test_package_identifier(yylval.text)) {
+                 delete[]yylval.text;
+                 yylval.package = pkg;
+                 return PACKAGE_IDENTIFIER;
+           }
+      }
+      if (gn_system_verilog()) {
+           if (data_type_t*type = pform_test_type_identifier(yylval.text)) {
+                 yylval.type_identifier.text = yylval.text;
+                 yylval.type_identifier.type = type;
+                 return TYPE_IDENTIFIER;
+           }
+      }
+      return IDENTIFIER;
+  }
+
+\$([a-zA-Z0-9$_]+)        {
+       /* The 1364-1995 timing checks. */
+      if (strcmp(yytext,"$hold") == 0)
+           return K_Shold;
+      if (strcmp(yytext,"$nochange") == 0)
+           return K_Snochange;
+      if (strcmp(yytext,"$period") == 0)
+           return K_Speriod;
+      if (strcmp(yytext,"$recovery") == 0)
+           return K_Srecovery;
+      if (strcmp(yytext,"$setup") == 0)
+           return K_Ssetup;
+      if (strcmp(yytext,"$setuphold") == 0)
+           return K_Ssetuphold;
+      if (strcmp(yytext,"$skew") == 0)
+           return K_Sskew;
+      if (strcmp(yytext,"$width") == 0)
+           return K_Swidth;
+       /* The new 1364-2001 timing checks. */
+      if (strcmp(yytext,"$fullskew") == 0)
+           return K_Sfullskew;
+      if (strcmp(yytext,"$recrem") == 0)
+           return K_Srecrem;
+      if (strcmp(yytext,"$removal") == 0)
+           return K_Sremoval;
+      if (strcmp(yytext,"$timeskew") == 0)
+           return K_Stimeskew;
+
+      if (strcmp(yytext,"$attribute") == 0)
+           return KK_attribute;
+
+      if (gn_system_verilog() && strcmp(yytext,"$unit") == 0) {
+           yylval.package = pform_units.back();
+           return PACKAGE_IDENTIFIER;
+      }
+
+      yylval.text = strdupnew(yytext);
+      return SYSTEM_IDENTIFIER; }
+
+
+\'[sS]?[dD][ \t]*[0-9][0-9_]* {
+      yylval.number = make_unsized_dec(yytext);
+      return BASED_NUMBER;
+}
+\'[sS]?[dD][ \t]*[xzXZ?]_* {
+      yylval.number = make_undef_highz_dec(yytext);
+      return BASED_NUMBER;
+}
+\'[sS]?[bB][ \t]*[0-1xzXZ?][0-1xzXZ?_]* {
+      yylval.number = make_unsized_binary(yytext);
+      return BASED_NUMBER;
+}
+\'[sS]?[oO][ \t]*[0-7xzXZ?][0-7xzXZ?_]* {
+      yylval.number = make_unsized_octal(yytext);
+      return BASED_NUMBER;
+}
+\'[sS]?[hH][ \t]*[0-9a-fA-FxzXZ?][0-9a-fA-FxzXZ?_]* {
+      yylval.number = make_unsized_hex(yytext);
+      return BASED_NUMBER;
+}
+\'[01xzXZ] {
+      if (!gn_system_verilog()) {
+           cerr << yylloc.text << ":" << yylloc.first_line << ": warning: "
+                << "Using SystemVerilog 'N bit vector.  Use at least "
+                << "-g2005-sv to remove this warning." << endl;
+      }
+      generation_t generation_save = generation_flag;
+      generation_flag = GN_VER2005_SV;
+      yylval.number = make_unsized_binary(yytext);
+      generation_flag = generation_save;
+      return UNBASED_NUMBER; }
+
+  /* Decimal numbers are the usual. But watch out for the UDPTABLE
+     mode, where there are no decimal numbers. Reject the match if we
+     are in the UDPTABLE state. */
+[0-9][0-9_]* {
+      if (YY_START==UDPTABLE) {
+           REJECT;
+      } else {
+           yylval.number = make_unsized_dec(yytext);
+           based_size = yylval.number->as_ulong();
+           return DEC_NUMBER;
+      }
+}
+
+  /* This rule handles scaled time values for SystemVerilog. */
+[0-9][0-9_]*(\.[0-9][0-9_]*)?{TU}?s {
+      if (gn_system_verilog()) {
+           yylval.text = strdupnew(yytext);
+           return TIME_LITERAL;
+      } else REJECT; }
+
+  /* These rules handle the scaled real literals from Verilog-AMS. The
+     value is a number with a single letter scale factor. If
+     verilog-ams is not enabled, then reject this rule. If it is
+     enabled, then collect the scale and use it to scale the value. */
+[0-9][0-9_]*\.[0-9][0-9_]*/{S} {
+      if (!gn_verilog_ams_flag) REJECT;
+      BEGIN(REAL_SCALE);
+      yymore();  }
+
+[0-9][0-9_]*/{S} {
+      if (!gn_verilog_ams_flag) REJECT;
+      BEGIN(REAL_SCALE);
+      yymore();  }
+
+<REAL_SCALE>{S} {
+      size_t token_len = strlen(yytext);
+      char*tmp = new char[token_len + 5];
+      int scale = 0;
+      strcpy(tmp, yytext);
+      switch (tmp[token_len-1]) {
+         case 'a': scale = -18; break; /* atto- */
+         case 'f': scale = -15; break; /* femto- */
+         case 'p': scale = -12; break; /* pico- */
+         case 'n': scale = -9;  break; /* nano- */
+         case 'u': scale = -6;  break; /* micro- */
+         case 'm': scale = -3;  break; /* milli- */
+         case 'k': scale = 3;  break; /* kilo- */
+         case 'K': scale = 3;  break; /* kilo- */
+         case 'M': scale = 6;  break; /* mega- */
+         case 'G': scale = 9;  break; /* giga- */
+         case 'T': scale = 12; break; /* tera- */
+         default: assert(0); break;
+      }
+      snprintf(tmp+token_len-1, 5, "e%d", scale);
+      yylval.realtime = new verireal(tmp);
+      delete[]tmp;
+
+      BEGIN(0);
+      return REALTIME;  }
+
+[0-9][0-9_]*\.[0-9][0-9_]*([Ee][+-]?[0-9][0-9_]*)? {
+      yylval.realtime = new verireal(yytext);
+      return REALTIME; }
+
+[0-9][0-9_]*[Ee][+-]?[0-9][0-9_]* {
+      yylval.realtime = new verireal(yytext);
+      return REALTIME; }
+
+
+  /* Notice and handle the `timescale directive. */
+
+^{W}?`timescale { BEGIN(PPTIMESCALE); }
+<PPTIMESCALE>.* { process_timescale(yytext); }
+<PPTIMESCALE>\n {
+      if (in_module) {
+           cerr << yylloc.text << ":" << yylloc.first_line << ": error: "
+                   "`timescale directive can not be inside a module "
+                   "definition." << endl;
+           error_count += 1;
+      }
+      yylloc.first_line += 1;
+      BEGIN(0); }
+
+  /* Notice and handle the `celldefine and `endcelldefine directives. */
+
+^{W}?`celldefine{W}?    { in_celldefine = true; }
+^{W}?`endcelldefine{W}? { in_celldefine = false; }
+
+  /* Notice and handle the resetall directive. */
+
+^{W}?`resetall{W}? {
+      if (in_module) {
+           cerr << yylloc.text << ":" << yylloc.first_line << ": error: "
+                   "`resetall directive can not be inside a module "
+                   "definition." << endl;
+           error_count += 1;
+      } else if (in_UDP) {
+           cerr << yylloc.text << ":" << yylloc.first_line << ": error: "
+                   "`resetall directive can not be inside a UDP "
+                   "definition." << endl;
+           error_count += 1;
+      } else {
+           reset_all();
+      } }
+
+  /* Notice and handle the `unconnected_drive directive. */
+^{W}?`unconnected_drive { BEGIN(PPUCDRIVE); }
+<PPUCDRIVE>.* { process_ucdrive(yytext); }
+<PPUCDRIVE>\n {
+      if (in_module) {
+           cerr << yylloc.text << ":" << yylloc.first_line << ": error: "
+                   "`unconnected_drive directive can not be inside a "
+                   "module definition." << endl;
+           error_count += 1;
+      }
+      yylloc.first_line += 1;
+      BEGIN(0); }
+
+^{W}?`nounconnected_drive{W}? {
+      if (in_module) {
+           cerr << yylloc.text << ":" << yylloc.first_line << ": error: "
+                   "`nounconnected_drive directive can not be inside a "
+                   "module definition." << endl;
+           error_count += 1;
+      }
+      uc_drive = UCD_NONE; }
+
+  /* These are directives that I do not yet support. I think that IVL
+     should handle these, not an external preprocessor. */
+  /* From 1364-2005 Chapter 19. */
+^{W}?`pragme{W}?.*                  {  }
+
+  /* From 1364-2005 Annex D. */
+^{W}?`default_decay_time{W}?.*      {  }
+^{W}?`default_trireg_strength{W}?.* {  }
+^{W}?`delay_mode_distributed{W}?.*  {  }
+^{W}?`delay_mode_path{W}?.*         {  }
+^{W}?`delay_mode_unit{W}?.*         {  }
+^{W}?`delay_mode_zero{W}?.*         {  }
+
+  /* From other places. */
+^{W}?`disable_portfaults{W}?.*      {  }
+^{W}?`enable_portfaults{W}?.*       {  }
+`endprotect                         {  }
+^{W}?`nosuppress_faults{W}?.*       {  }
+`protect                            {  }
+^{W}?`suppress_faults{W}?.*         {  }
+^{W}?`uselib{W}?.*                  {  }
+
+^{W}?`begin_keywords{W}? { BEGIN(PPBEGIN_KEYWORDS); }
+
+<PPBEGIN_KEYWORDS>\"[a-zA-Z0-9 -\.]*\".* {
+      keyword_mask_stack.push_front(lexor_keyword_mask);
+
+      char*word = yytext+1;
+      char*tail = strchr(word, '"');
+      tail[0] = 0;
+      if (strcmp(word,"1364-1995") == 0) {
+           lexor_keyword_mask = GN_KEYWORDS_1364_1995;
+      } else if (strcmp(word,"1364-2001") == 0) {
+           lexor_keyword_mask = GN_KEYWORDS_1364_1995
+                               |GN_KEYWORDS_1364_2001
+                               |GN_KEYWORDS_1364_2001_CONFIG;
+      } else if (strcmp(word,"1364-2001-noconfig") == 0) {
+           lexor_keyword_mask = GN_KEYWORDS_1364_1995
+                               |GN_KEYWORDS_1364_2001;
+      } else if (strcmp(word,"1364-2005") == 0) {
+           lexor_keyword_mask = GN_KEYWORDS_1364_1995
+                               |GN_KEYWORDS_1364_2001
+                               |GN_KEYWORDS_1364_2001_CONFIG
+                               |GN_KEYWORDS_1364_2005;
+      } else if (strcmp(word,"1800-2005") == 0) {
+           lexor_keyword_mask = GN_KEYWORDS_1364_1995
+                               |GN_KEYWORDS_1364_2001
+                               |GN_KEYWORDS_1364_2001_CONFIG
+                               |GN_KEYWORDS_1364_2005
+                               |GN_KEYWORDS_1800_2005;
+      } else if (strcmp(word,"1800-2009") == 0) {
+           lexor_keyword_mask = GN_KEYWORDS_1364_1995
+                               |GN_KEYWORDS_1364_2001
+                               |GN_KEYWORDS_1364_2001_CONFIG
+                               |GN_KEYWORDS_1364_2005
+                               |GN_KEYWORDS_1800_2005
+                               |GN_KEYWORDS_1800_2009;
+      } else if (strcmp(word,"1800-2012") == 0) {
+           lexor_keyword_mask = GN_KEYWORDS_1364_1995
+                               |GN_KEYWORDS_1364_2001
+                               |GN_KEYWORDS_1364_2001_CONFIG
+                               |GN_KEYWORDS_1364_2005
+                               |GN_KEYWORDS_1800_2005
+                               |GN_KEYWORDS_1800_2009
+                               |GN_KEYWORDS_1800_2012;
+      } else if (strcmp(word,"VAMS-2.3") == 0) {
+           lexor_keyword_mask = GN_KEYWORDS_1364_1995
+                               |GN_KEYWORDS_1364_2001
+                               |GN_KEYWORDS_1364_2001_CONFIG
+                               |GN_KEYWORDS_1364_2005
+                               |GN_KEYWORDS_VAMS_2_3;
+      } else {
+           fprintf(stderr, "%s:%d: Ignoring unknown keywords string: %s\n",
+                   yylloc.text, yylloc.first_line, word);
+      }
+      BEGIN(0);
+ }
+
+<PPBEGIN_KEYWORDS>.* {
+      fprintf(stderr, "%s:%d: Malformed keywords specification: %s\n",
+             yylloc.text, yylloc.first_line, yytext);
+      BEGIN(0);
+ }
+
+^{W}?`end_keywords{W}?.* {
+      if (!keyword_mask_stack.empty()) {
+           lexor_keyword_mask = keyword_mask_stack.front();
+           keyword_mask_stack.pop_front();
+      } else {
+           fprintf(stderr, "%s:%d: Mismatched end_keywords directive\n",
+                   yylloc.text, yylloc.first_line);
+      }
+ }
+
+  /* Notice and handle the default_nettype directive. The lexor
+     detects the default_nettype keyword, and the second part of the
+     rule collects the rest of the line and processes it. We only need
+     to look for the first work, and interpret it. */
+
+`default_nettype{W}? { BEGIN(PPDEFAULT_NETTYPE); }
+<PPDEFAULT_NETTYPE>.* {
+      NetNet::Type net_type;
+      size_t wordlen = strcspn(yytext, " \t\f\r\n");
+      yytext[wordlen] = 0;
+  /* Add support for other wire types and better error detection. */
+      if (strcmp(yytext,"wire") == 0) {
+           net_type = NetNet::WIRE;
+
+      } else if (strcmp(yytext,"tri") == 0) {
+           net_type = NetNet::TRI;
+
+      } else if (strcmp(yytext,"tri0") == 0) {
+           net_type = NetNet::TRI0;
+
+      } else if (strcmp(yytext,"tri1") == 0) {
+           net_type = NetNet::TRI1;
+
+      } else if (strcmp(yytext,"wand") == 0) {
+           net_type = NetNet::WAND;
+
+      } else if (strcmp(yytext,"triand") == 0) {
+           net_type = NetNet::TRIAND;
+
+      } else if (strcmp(yytext,"wor") == 0) {
+           net_type = NetNet::WOR;
+
+      } else if (strcmp(yytext,"trior") == 0) {
+           net_type = NetNet::TRIOR;
+
+      } else if (strcmp(yytext,"none") == 0) {
+           net_type = NetNet::NONE;
+
+      } else {
+           cerr << yylloc.text << ":" << yylloc.first_line
+                << ": error: Net type " << yytext
+                << " is not a valid (or supported)"
+                << " default net type." << endl;
+           net_type = NetNet::WIRE;
+           error_count += 1;
+      }
+      pform_set_default_nettype(net_type, yylloc.text, yylloc.first_line);
+  }
+<PPDEFAULT_NETTYPE>\n {
+      yylloc.first_line += 1;
+      BEGIN(0); }
+
+
+  /* These are directives that are not supported by me and should have
+     been handled by an external preprocessor such as ivlpp. */
+
+^{W}?`define{W}?.* {
+      cerr << yylloc.text << ":" << yylloc.first_line <<
+           ": warning: `define not supported. Use an external preprocessor."
+          << endl;
+  }
+
+^{W}?`else{W}?.* {
+      cerr << yylloc.text << ":" << yylloc.first_line <<
+           ": warning: `else not supported. Use an external preprocessor."
+          << endl;
+  }
+
+^{W}?`elsif{W}?.* {
+      cerr << yylloc.text << ":" << yylloc.first_line <<
+           ": warning: `elsif not supported. Use an external preprocessor."
+          << endl;
+  }
+
+^{W}?`endif{W}?.* {
+      cerr << yylloc.text << ":" << yylloc.first_line <<
+           ": warning: `endif not supported. Use an external preprocessor."
+          << endl;
+  }
+
+^{W}?`ifdef{W}?.* {
+      cerr << yylloc.text << ":" << yylloc.first_line <<
+           ": warning: `ifdef not supported. Use an external preprocessor."
+          << endl;
+  }
+
+^{W}?`ifndef{W}?.* {
+      cerr << yylloc.text << ":" << yylloc.first_line <<
+           ": warning: `ifndef not supported. Use an external preprocessor."
+          << endl;
+  }
+
+^`include{W}?.* {
+      cerr << yylloc.text << ":" << yylloc.first_line <<
+           ": warning: `include not supported. Use an external preprocessor."
+          << endl;
+  }
+
+^`undef{W}?.* {
+      cerr << yylloc.text << ":" << yylloc.first_line <<
+           ": warning: `undef not supported. Use an external preprocessor."
+          << endl;
+  }
+
+
+`{W} { cerr << yylloc.text << ":" << yylloc.first_line << ": error: "
+           << "Stray tic (`) here. Perhaps you put white space" << endl;
+       cerr << yylloc.text << ":" << yylloc.first_line << ":      : "
+           << "between the tic and preprocessor directive?"
+           << endl;
+       error_count += 1; }
+
+. { return yytext[0]; }
+
+  /* Final catchall. something got lost or mishandled. */
+  /* XXX Should we tell the user something about the lexical state? */
+
+<*>.|\n {   cerr << yylloc.text << ":" << yylloc.first_line
+          << ": error: unmatched character (";
+      if (isprint(yytext[0]))
+           cerr << yytext[0];
+      else
+           cerr << "hex " << hex << ((unsigned char) yytext[0]);
+
+      cerr << ")" << endl;
+      error_count += 1; }
+
+%%
+
+/*
+ * The UDP state table needs some slightly different treatment by the
+ * lexor. The level characters are normally accepted as other things,
+ * so the parser needs to switch my mode when it believes in needs to.
+ */
+void lex_end_table()
+{
+      BEGIN(INITIAL);
+}
+
+static unsigned truncate_to_integer_width(verinum::V*bits, unsigned size)
+{
+      if (size <= integer_width) return size;
+
+      verinum::V pad = bits[size-1];
+      if (pad == verinum::V1) pad = verinum::V0;
+
+      for (unsigned idx = integer_width; idx < size; idx += 1) {
+           if (bits[idx] != pad) {
+                 yywarn(yylloc, "Unsized numeric constant truncated to integer width.");
+                 break;
+           }
+      }
+      return integer_width;
+}
+
+verinum*make_unsized_binary(const char*txt)
+{
+      bool sign_flag = false;
+      bool single_flag = false;
+      const char*ptr = txt;
+      assert(*ptr == '\'');
+      ptr += 1;
+
+      if (tolower(*ptr) == 's') {
+           sign_flag = true;
+           ptr += 1;
+      }
+
+      assert((tolower(*ptr) == 'b') || gn_system_verilog());
+      if (tolower(*ptr) == 'b') {
+           ptr += 1;
+      } else {
+           assert(sign_flag == false);
+           single_flag = true;
+      }
+
+      while (*ptr && ((*ptr == ' ') || (*ptr == '\t')))
+           ptr += 1;
+
+      unsigned size = 0;
+      for (const char*idx = ptr ;  *idx ;  idx += 1)
+           if (*idx != '_') size += 1;
+
+      if (size == 0) {
+           VLerror(yylloc, "Numeric literal has no digits in it.");
+           verinum*out = new verinum();
+           out->has_sign(sign_flag);
+           out->is_single(single_flag);
+           return out;
+      }
+
+      if ((based_size > 0) && (size > based_size)) yywarn(yylloc,
+          "extra digits given for sized binary constant.");
+
+      verinum::V*bits = new verinum::V[size];
+
+      unsigned idx = size;
+      while (*ptr) {
+           switch (ptr[0]) {
+               case '0':
+                 bits[--idx] = verinum::V0;
+                 break;
+               case '1':
+                 bits[--idx] = verinum::V1;
+                 break;
+               case 'z': case 'Z': case '?':
+                 bits[--idx] = verinum::Vz;
+                 break;
+               case 'x': case 'X':
+                 bits[--idx] = verinum::Vx;
+                 break;
+                 case '_':
+                 break;
+               default:
+                 fprintf(stderr, "%c\n", ptr[0]);
+                 assert(0);
+           }
+           ptr += 1;
+      }
+
+      if (gn_strict_expr_width_flag && (based_size == 0))
+           size = truncate_to_integer_width(bits, size);
+
+      verinum*out = new verinum(bits, size, false);
+      out->has_sign(sign_flag);
+      out->is_single(single_flag);
+      delete[]bits;
+      return out;
+}
+
+
+verinum*make_unsized_octal(const char*txt)
+{
+      bool sign_flag = false;
+      const char*ptr = txt;
+      assert(*ptr == '\'');
+      ptr += 1;
+
+      if (tolower(*ptr) == 's') {
+           sign_flag = true;
+           ptr += 1;
+      }
+
+      assert(tolower(*ptr) == 'o');
+      ptr += 1;
+
+      while (*ptr && ((*ptr == ' ') || (*ptr == '\t')))
+           ptr += 1;
+
+      unsigned size = 0;
+      for (const char*idx = ptr ;  *idx ;  idx += 1)
+           if (*idx != '_') size += 3;
+
+      if (based_size > 0) {
+            int rem = based_size % 3;
+           if (rem != 0) based_size += 3 - rem;
+           if (size > based_size) yywarn(yylloc,
+               "extra digits given for sized octal constant.");
+      }
+
+      verinum::V*bits = new verinum::V[size];
+
+      unsigned idx = size;
+      while (*ptr) {
+           unsigned val;
+           switch (ptr[0]) {
+               case '0': case '1': case '2': case '3':
+               case '4': case '5': case '6': case '7':
+                 val = *ptr - '0';
+                 bits[--idx] = (val&4) ? verinum::V1 : verinum::V0;
+                 bits[--idx] = (val&2) ? verinum::V1 : verinum::V0;
+                 bits[--idx] = (val&1) ? verinum::V1 : verinum::V0;
+                 break;
+               case 'x': case 'X':
+                 bits[--idx] = verinum::Vx;
+                 bits[--idx] = verinum::Vx;
+                 bits[--idx] = verinum::Vx;
+                 break;
+               case 'z': case 'Z': case '?':
+                 bits[--idx] = verinum::Vz;
+                 bits[--idx] = verinum::Vz;
+                 bits[--idx] = verinum::Vz;
+                 break;
+               case '_':
+                 break;
+               default:
+                 assert(0);
+           }
+           ptr += 1;
+      }
+
+      if (gn_strict_expr_width_flag && (based_size == 0))
+           size = truncate_to_integer_width(bits, size);
+
+      verinum*out = new verinum(bits, size, false);
+      out->has_sign(sign_flag);
+      delete[]bits;
+      return out;
+}
+
+
+verinum*make_unsized_hex(const char*txt)
+{
+      bool sign_flag = false;
+      const char*ptr = txt;
+      assert(*ptr == '\'');
+      ptr += 1;
+
+      if (tolower(*ptr) == 's') {
+           sign_flag = true;
+           ptr += 1;
+      }
+      assert(tolower(*ptr) == 'h');
+
+      ptr += 1;
+      while (*ptr && ((*ptr == ' ') || (*ptr == '\t')))
+           ptr += 1;
+
+      unsigned size = 0;
+      for (const char*idx = ptr ;  *idx ;  idx += 1)
+           if (*idx != '_') size += 4;
+
+      if (based_size > 0) {
+            int rem = based_size % 4;
+           if (rem != 0) based_size += 4 - rem;
+           if (size > based_size) yywarn(yylloc,
+               "extra digits given for sized hex constant.");
+      }
+
+      verinum::V*bits = new verinum::V[size];
+
+      unsigned idx = size;
+      while (*ptr) {
+           unsigned val;
+           switch (ptr[0]) {
+               case '0': case '1': case '2': case '3': case '4':
+               case '5': case '6': case '7': case '8': case '9':
+                 val = *ptr - '0';
+                 bits[--idx] = (val&8) ? verinum::V1 : verinum::V0;
+                 bits[--idx] = (val&4) ? verinum::V1 : verinum::V0;
+                 bits[--idx] = (val&2) ? verinum::V1 : verinum::V0;
+                 bits[--idx] = (val&1) ? verinum::V1 : verinum::V0;
+                 break;
+               case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
+               case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
+                 val = tolower(*ptr) - 'a' + 10;
+                 bits[--idx] = (val&8) ? verinum::V1 : verinum::V0;
+                 bits[--idx] = (val&4) ? verinum::V1 : verinum::V0;
+                 bits[--idx] = (val&2) ? verinum::V1 : verinum::V0;
+                 bits[--idx] = (val&1) ? verinum::V1 : verinum::V0;
+                 break;
+               case 'x': case 'X':
+                 bits[--idx] = verinum::Vx;
+                 bits[--idx] = verinum::Vx;
+                 bits[--idx] = verinum::Vx;
+                 bits[--idx] = verinum::Vx;
+                 break;
+               case 'z': case 'Z': case '?':
+                 bits[--idx] = verinum::Vz;
+                 bits[--idx] = verinum::Vz;
+                 bits[--idx] = verinum::Vz;
+                 bits[--idx] = verinum::Vz;
+                 break;
+               case '_':
+                 break;
+               default:
+                 assert(0);
+           }
+           ptr += 1;
+      }
+
+      if (gn_strict_expr_width_flag && (based_size == 0))
+           size = truncate_to_integer_width(bits, size);
+
+      verinum*out = new verinum(bits, size, false);
+      out->has_sign(sign_flag);
+      delete[]bits;
+      return out;
+}
+
+
+/* Divide the integer given by the string by 2. Return the remainder bit. */
+static int dec_buf_div2(char *buf)
+{
+    int partial;
+    int len = strlen(buf);
+    char *dst_ptr;
+    int pos;
+
+    partial = 0;
+    pos = 0;
+
+    /* dst_ptr overwrites buf, but all characters that are overwritten
+       were already used by the reader. */
+    dst_ptr = buf;
+
+    while(buf[pos] == '0')
+       ++pos;
+
+    for(; pos<len; ++pos){
+       if (buf[pos]=='_')
+           continue;
+
+       assert(isdigit(buf[pos]));
+
+       partial= partial*10 + (buf[pos]-'0');
+
+       if (partial >= 2){
+           *dst_ptr = partial/2 + '0';
+           partial = partial & 1;
+
+           ++dst_ptr;
+       }
+       else{
+           *dst_ptr = '0';
+           ++dst_ptr;
+       }
+    }
+
+    // If result of division was zero string, it should remain that way.
+    // Don't eat the last zero...
+    if (dst_ptr == buf){
+       *dst_ptr = '0';
+       ++dst_ptr;
+    }
+    *dst_ptr = 0;
+
+    return partial;
+}
+
+/* Support a single x, z or ? as a decimal constant (from 1364-2005). */
+verinum* make_undef_highz_dec(const char* ptr)
+{
+      bool signed_flag = false;
+
+      assert(*ptr == '\'');
+      /* The number may have decorations of the form 'sd<code>,
+         possibly with space between the d and the <code>.
+         Also, the 's' is optional, and marks the number as signed. */
+      ptr += 1;
+
+      if (tolower(*ptr) == 's') {
+         signed_flag = true;
+         ptr += 1;
+      }
+
+      assert(tolower(*ptr) == 'd');
+      ptr += 1;
+
+      while (*ptr && ((*ptr == ' ') || (*ptr == '\t')))
+         ptr += 1;
+
+       /* Process the code. */
+      verinum::V* bits = new verinum::V[1];
+      switch (*ptr) {
+         case 'x':
+         case 'X':
+           bits[0] = verinum::Vx;
+           break;
+         case 'z':
+         case 'Z':
+         case '?':
+           bits[0] = verinum::Vz;
+           break;
+         default:
+           assert(0);
+      }
+      ptr += 1;
+      while (*ptr == '_') ptr += 1;
+      assert(*ptr == 0);
+
+      verinum*out = new verinum(bits, 1, false);
+      out->has_sign(signed_flag);
+      delete[]bits;
+      return out;
+}
+
+/*
+ * Making a decimal number is much easier than the other base numbers
+ * because there are no z or x values to worry about. It is much
+ * harder than other base numbers because the width needed in bits is
+ * hard to calculate.
+ */
+
+verinum*make_unsized_dec(const char*ptr)
+{
+      char buf[4096];
+      bool signed_flag = false;
+      unsigned idx;
+
+      if (ptr[0] == '\'') {
+             /* The number has decorations of the form 'sd<digits>,
+                possibly with space between the d and the <digits>.
+                Also, the 's' is optional, and marks the number as
+                signed. */
+           ptr += 1;
+
+           if (tolower(*ptr) == 's') {
+                 signed_flag = true;
+                 ptr += 1;
+           }
+
+           assert(tolower(*ptr) == 'd');
+           ptr += 1;
+
+           while (*ptr && ((*ptr == ' ') || (*ptr == '\t')))
+                 ptr += 1;
+
+      } else {
+             /* ... or an undecorated decimal number is passed
+                it. These numbers are treated as signed decimal. */
+           assert(isdigit(*ptr));
+           signed_flag = true;
+      }
+
+
+       /* Copy the digits into a buffer that I can use to do in-place
+          decimal divides. */
+      idx = 0;
+      while ((idx < sizeof buf) && (*ptr != 0)) {
+           if (*ptr == '_') {
+                 ptr += 1;
+                 continue;
+           }
+
+           buf[idx++] = *ptr++;
+      }
+
+      if (idx == sizeof buf) {
+           fprintf(stderr, "Ridiculously long"
+                   " decimal constant will be truncated!\n");
+           idx -= 1;
+      }
+
+      buf[idx] = 0;
+      unsigned tmp_size = idx * 4 + 1;
+      verinum::V *bits = new verinum::V[tmp_size];
+
+      idx = 0;
+      while (idx < tmp_size) {
+           int rem = dec_buf_div2(buf);
+           bits[idx++] = (rem == 1) ? verinum::V1 : verinum::V0;
+      }
+
+      assert(strcmp(buf, "0") == 0);
+
+       /* Now calculate the minimum number of bits needed to
+          represent this unsigned number. */
+      unsigned size = tmp_size;
+      while ((size > 1) && (bits[size-1] == verinum::V0))
+           size -= 1;
+
+       /* Now account for the signedness. Don't leave a 1 in the high
+          bit if this is a signed number. */
+      if (signed_flag && (bits[size-1] == verinum::V1)) {
+           size += 1;
+           assert(size <= tmp_size);
+      }
+
+        /* Since we never have the real number of bits that a decimal
+           number represents we do not check for extra bits. */
+//      if (based_size > 0) { }
+
+      if (gn_strict_expr_width_flag && (based_size == 0))
+           size = truncate_to_integer_width(bits, size);
+
+      verinum*res = new verinum(bits, size, false);
+      res->has_sign(signed_flag);
+
+      delete[]bits;
+      return res;
+}
+
+/*
+ * Convert the string to a time unit or precision.
+ * Returns true on failure.
+ */
+static bool get_timescale_const(const char *&cp, int &res, bool is_unit)
+{
+       /* Check for the 1 digit. */
+      if (*cp != '1') {
+           if (is_unit) {
+                 VLerror(yylloc, "Invalid `timescale unit constant "
+                                 "(1st digit)");
+           } else {
+                 VLerror(yylloc, "Invalid `timescale precision constant "
+                                 "(1st digit)");
+           }
+           return true;
+      }
+      cp += 1;
+
+       /* Check the number of zeros after the 1. */
+      res = strspn(cp, "0");
+      if (res > 2) {
+           if (is_unit) {
+                 VLerror(yylloc, "Invalid `timescale unit constant "
+                                 "(number of zeros)");
+           } else {
+                 VLerror(yylloc, "Invalid `timescale precision constant "
+                                 "(number of zeros)");
+           }
+           return true;
+      }
+      cp += res;
+
+       /* Skip any space between the digits and the scaling string. */
+      cp += strspn(cp, " \t");
+
+       /* Now process the scaling string. */
+      if (strncmp("s", cp, 1) == 0) {
+           res -= 0;
+           cp += 1;
+           return false;
+
+      } else if (strncmp("ms", cp, 2) == 0) {
+           res -= 3;
+           cp += 2;
+           return false;
+
+      } else if (strncmp("us", cp, 2) == 0) {
+           res -= 6;
+           cp += 2;
+           return false;
+
+      } else if (strncmp("ns", cp, 2) == 0) {
+           res -= 9;
+           cp += 2;
+           return false;
+
+      } else if (strncmp("ps", cp, 2) == 0) {
+           res -= 12;
+           cp += 2;
+           return false;
+
+      } else if (strncmp("fs", cp, 2) == 0) {
+           res -= 15;
+           cp += 2;
+           return false;
+
+      }
+
+      if (is_unit) {
+           VLerror(yylloc, "Invalid `timescale unit scale");
+      } else {
+           VLerror(yylloc, "Invalid `timescale precision scale");
+      }
+      return true;
+}
+
+
+/*
+ * process either a pull0 or a pull1.
+ */
+static void process_ucdrive(const char*txt)
+{
+      UCDriveType ucd = UCD_NONE;
+      const char*cp = txt + strspn(txt, " \t");
+
+       /* Skip the space after the `unconnected_drive directive. */
+      if (cp == txt) {
+           VLerror(yylloc, "Space required after `unconnected_drive "
+                           "directive.");
+           return;
+      }
+
+       /* Check for the pull keyword. */
+      if (strncmp("pull", cp, 4) != 0) {
+           VLerror(yylloc, "pull required for `unconnected_drive "
+                           "directive.");
+           return;
+      }
+      cp += 4;
+      if (*cp == '0') ucd = UCD_PULL0;
+      else if (*cp == '1') ucd = UCD_PULL1;
+      else {
+           cerr << yylloc.text << ":" << yylloc.first_line << ": error: "
+                   "`unconnected_drive does not support 'pull" << *cp
+                << "'." << endl;
+           error_count += 1;
+           return;
+      }
+      cp += 1;
+
+       /* Verify that only space and/or a single line comment is left. */
+      cp += strspn(cp, " \t");
+      if (strncmp(cp, "//", 2) != 0 &&
+          (size_t)(cp-yytext) != strlen(yytext)) {
+           VLerror(yylloc, "Invalid `unconnected_drive directive (extra "
+                           "garbage after precision).");
+           return;
+      }
+
+      uc_drive = ucd;
+}
+
+/*
+ * The timescale parameter has the form:
+ *      " <num> xs / <num> xs"
+ */
+static void process_timescale(const char*txt)
+{
+      const char*cp = txt + strspn(txt, " \t");
+
+       /* Skip the space after the `timescale directive. */
+      if (cp == txt) {
+           VLerror(yylloc, "Space required after `timescale directive.");
+           return;
+      }
+
+      int unit = 0;
+      int prec = 0;
+
+       /* Get the time units. */
+      if (get_timescale_const(cp, unit, true)) return;
+
+       /* Skip any space after the time units, the '/' and any
+        * space after the '/'. */
+      cp += strspn(cp, " \t");
+      if (*cp != '/') {
+           VLerror(yylloc, "`timescale separator '/' appears to be missing.");
+           return;
+      }
+      cp += 1;
+      cp += strspn(cp, " \t");
+
+       /* Get the time precision. */
+      if (get_timescale_const(cp, prec, false)) return;
+
+       /* Verify that only space and/or a single line comment is left. */
+      cp += strspn(cp, " \t");
+      if (strncmp(cp, "//", 2) != 0 &&
+          (size_t)(cp-yytext) != strlen(yytext)) {
+           VLerror(yylloc, "Invalid `timescale directive (extra garbage "
+                           "after precision).");
+           return;
+      }
+
+       /* The time unit must be greater than or equal to the precision. */
+      if (unit < prec) {
+           VLerror(yylloc, "error: `timescale unit must not be less than "
+                           "the precision.");
+           return;
+      }
+
+      pform_set_timescale(unit, prec, yylloc.text, yylloc.first_line);
+}
+
+int yywrap()
+{
+      return 1;
+}
+
+/*
+ * The line directive matches lines of the form #line "foo" N and
+ * calls this function. Here I parse out the file name and line
+ * number, and change the yylloc to suite.
+ */
+static void line_directive()
+{
+      char *cpr;
+       /* Skip any leading space. */
+      char *cp = strchr(yytext, '#');
+       /* Skip the #line directive. */
+      assert(strncmp(cp, "#line", 5) == 0);
+      cp += 5;
+       /* Skip the space after the #line directive. */
+      cp += strspn(cp, " \t");
+
+       /* Find the starting " and skip it. */
+      char*fn_start = strchr(cp, '"');
+      if (cp != fn_start) {
+           VLerror(yylloc, "Invalid #line directive (file name start).");
+           return;
+      }
+      fn_start += 1;
+
+       /* Find the last ". */
+      char*fn_end = strrchr(fn_start, '"');
+      if (!fn_end) {
+           VLerror(yylloc, "Invalid #line directive (file name end).");
+           return;
+      }
+
+       /* Copy the file name and assign it to yylloc. */
+      char*buf = new char[fn_end-fn_start+1];
+      strncpy(buf, fn_start, fn_end-fn_start);
+      buf[fn_end-fn_start] = 0;
+
+       /* Skip the space after the file name. */
+      cp = fn_end;
+      cp += 1;
+      cpr = cp;
+      cpr += strspn(cp, " \t");
+      if (cp == cpr) {
+           VLerror(yylloc, "Invalid #line directive (missing space after "
+                           "file name).");
+           delete[] buf;
+           return;
+      }
+      cp = cpr;
+
+       /* Get the line number and verify that it is correct. */
+      unsigned long lineno = strtoul(cp, &cpr, 10);
+      if (cp == cpr) {
+           VLerror(yylloc, "Invalid line number for #line directive.");
+           delete[] buf;
+           return;
+      }
+      cp = cpr;
+
+       /* Verify that only space is left. */
+      cpr += strspn(cp, " \t");
+      if ((size_t)(cpr-yytext) != strlen(yytext)) {
+           VLerror(yylloc, "Invalid #line directive (extra garbage after "
+                           "line number).");
+           delete[] buf;
+           return;
+      }
+
+       /* Now we can assign the new values to yyloc. */
+      yylloc.text = set_file_name(buf);
+      yylloc.first_line = lineno;
+}
+
+/*
+ * The line directive matches lines of the form `line N "foo" M and
+ * calls this function. Here I parse out the file name and line
+ * number, and change the yylloc to suite. M is ignored.
+ */
+static void line_directive2()
+{
+      char *cpr;
+       /* Skip any leading space. */
+      char *cp = strchr(yytext, '`');
+       /* Skip the `line directive. */
+      assert(strncmp(cp, "`line", 5) == 0);
+      cp += 5;
+
+       /* strtoul skips leading space. */
+      unsigned long lineno = strtoul(cp, &cpr, 10);
+      if (cp == cpr) {
+           VLerror(yylloc, "Invalid line number for `line directive.");
+           return;
+      }
+      lineno -= 1;
+      cp = cpr;
+
+       /* Skip the space between the line number and the file name. */
+      cpr += strspn(cp, " \t");
+      if (cp == cpr) {
+           VLerror(yylloc, "Invalid `line directive (missing space after "
+                           "line number).");
+           return;
+      }
+      cp = cpr;
+
+       /* Find the starting " and skip it. */
+      char*fn_start = strchr(cp, '"');
+      if (cp != fn_start) {
+           VLerror(yylloc, "Invalid `line directive (file name start).");
+           return;
+      }
+      fn_start += 1;
+
+       /* Find the last ". */
+      char*fn_end = strrchr(fn_start, '"');
+      if (!fn_end) {
+           VLerror(yylloc, "Invalid `line directive (file name end).");
+           return;
+      }
+
+       /* Skip the space after the file name. */
+      cp = fn_end + 1;
+      cpr = cp;
+      cpr += strspn(cp, " \t");
+      if (cp == cpr) {
+           VLerror(yylloc, "Invalid `line directive (missing space after "
+                           "file name).");
+           return;
+      }
+      cp = cpr;
+
+       /* Check that the level is correct, we do not need the level. */
+      if (strspn(cp, "012") != 1) {
+           VLerror(yylloc, "Invalid level for `line directive.");
+           return;
+      }
+      cp += 1;
+
+       /* Verify that only space and/or a single line comment is left. */
+      cp += strspn(cp, " \t");
+      if (strncmp(cp, "//", 2) != 0 &&
+          (size_t)(cp-yytext) != strlen(yytext)) {
+           VLerror(yylloc, "Invalid `line directive (extra garbage after "
+                           "level).");
+           return;
+      }
+
+       /* Copy the file name and assign it and the line number to yylloc. */
+      char*buf = new char[fn_end-fn_start+1];
+      strncpy(buf, fn_start, fn_end-fn_start);
+      buf[fn_end-fn_start] = 0;
+
+      yylloc.text = set_file_name(buf);
+      yylloc.first_line = lineno;
+}
+
+/*
+ * Reset all compiler directives. This will be called when a `resetall
+ * directive is encountered or when a new compilation unit is started.
+ */
+static void reset_all()
+{
+      pform_set_default_nettype(NetNet::WIRE, yylloc.text, yylloc.first_line);
+      in_celldefine = false;
+      uc_drive = UCD_NONE;
+      pform_set_timescale(def_ts_units, def_ts_prec, 0, 0);
+}
+
+extern FILE*vl_input;
+void reset_lexor()
+{
+      yyrestart(vl_input);
+      yylloc.first_line = 1;
+
+       /* Announce the first file name. */
+      yylloc.text = set_file_name(strdupnew(vl_file.c_str()));
+
+      if (separate_compilation) {
+           reset_all();
+           if (!keyword_mask_stack.empty()) {
+                 lexor_keyword_mask = keyword_mask_stack.back();
+                 keyword_mask_stack.clear();
+           }
+      }
+}
+
+/*
+ * Modern version of flex (>=2.5.9) can clean up the scanner data.
+ */
+void destroy_lexor()
+{
+# ifdef FLEX_SCANNER
+#   if YY_FLEX_MAJOR_VERSION >= 2 && YY_FLEX_MINOR_VERSION >= 5
+#     if YY_FLEX_MINOR_VERSION > 5 || defined(YY_FLEX_SUBMINOR_VERSION) && YY_FLEX_SUBMINOR_VERSION >= 9
+    yylex_destroy();
+#     endif
+#   endif
+# endif
+}
diff --git a/lexor.py b/lexor.py
new file mode 100644 (file)
index 0000000..d19aa3f
--- /dev/null
+++ b/lexor.py
@@ -0,0 +1,2002 @@
+"""
+%{
+/*
+ * Copyright (c) 1998-2017 Stephen Williams (steve@icarus.com)
+ *
+ *    This source code is free software; you can redistribute it
+ *    and/or modify it in source code form under the terms of the GNU
+ *    General Public License as published by the Free Software
+ *    Foundation; either version 2 of the License, or (at your option)
+ *    any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program; if not, write to the Free Software
+ *    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+"""
+
+from ply import lex
+
+"""
+%x CCOMMENT
+%x PCOMMENT
+%x LCOMMENT
+%x CSTRING
+%s UDPTABLE
+%x PPTIMESCALE
+%x PPUCDRIVE
+%x PPDEFAULT_NETTYPE
+%x PPBEGIN_KEYWORDS
+%s EDGES
+%x REAL_SCALE
+
+# for timescales (regex subst patterns)
+W = r'[ \t\b\f\r]+'
+S = r'[afpnumkKMGT]'
+TU r'[munpf]'
+
+%%
+
+  /* Recognize the various line directives. */
+^"#line"[ \t]+.+ { line_directive(); }
+^[ \t]?"`line"[ \t]+.+ { line_directive2(); }
+
+[ \t\b\f\r] { ; }
+\n { yylloc.first_line += 1; }
+
+  /* C++ style comments start with / / and run to the end of the
+     current line. These are very easy to handle. The meta-comments
+     format is a little more tricky to handle, but do what we can. */
+
+  /* The lexor detects "// synthesis translate_on/off" meta-comments,
+     we handle them here by turning on/off a flag. The pform uses
+     that flag to attach implicit attributes to "initial" and
+     "always" statements. */
+
+"//"{W}*"synthesis"{W}+"translate_on"{W}*\n { pform_mc_translate_on(true); }
+"//"{W}*"synthesis"{W}+"translate_off"{W}*\n { pform_mc_translate_on(false); }
+"//" { comment_enter = YY_START; BEGIN(LCOMMENT); }
+<LCOMMENT>.    { yymore(); }
+<LCOMMENT>\n   { yylloc.first_line += 1; BEGIN(comment_enter); }
+
+
+  /* The contents of C-style comments are ignored, like white space. */
+
+"/*" { comment_enter = YY_START; BEGIN(CCOMMENT); }
+<CCOMMENT>.    { ; }
+<CCOMMENT>\n   { yylloc.first_line += 1; }
+<CCOMMENT>"*/" { BEGIN(comment_enter); }
+"""
+
+states = (#('module', 'exclusive'),
+          ('timescale', 'exclusive'),)
+
+from parse_tokens import tokens
+tokens += ['timescale', 'LITERAL', 'IDENTIFIER', 'DEC_NUMBER', 'BASED_NUMBER',
+           'UNBASED_NUMBER']
+
+def t_ccomment(t):
+    r'/\*(.|\n)*?\*/'
+    t.lexer.lineno += t.value.count('\n')
+
+t_ignore_cppcomment = r'//.*'
+
+t_ignore = ' \t\n'
+
+t_K_PSTAR = r"\(\*"
+t_K_STARP = r"\*\)"
+t_K_DOTSTAR = r"\.\*"
+t_K_LS = r"(<<|<<<)"
+t_K_RS = r">>" 
+t_K_RSS = r">>>"
+t_K_POW = r"\*\*"
+t_K_LE = r"<="
+t_K_GE = r">="
+t_K_EG = r"=>"
+"""
+"+=>"|"-=>"    {
+                       /*
+                        * Resolve the ambiguity between the += assignment
+                        * operator and +=> polarity edge path operator
+                        *
+                        * +=> should be treated as two separate tokens '+' and
+                        * '=>' (K_EG), therefore we only consume the first
+                        * character of the matched pattern i.e. either + or -
+                        * and push back the rest of the matches text (=>) in
+                        * the input stream.
+                        */
+                       yyless(1);
+                       return yytext[0];
+               }
+"""
+t_K_SG = r"\*>"
+t_K_EQ = r"=="
+t_K_NE = r"!="
+t_K_CEQ = r"==="
+t_K_CNE = r"!=="
+t_K_WEQ = r"==\?"
+t_K_WNE = r"!=\?"
+t_K_LOR = r"\|\|"
+t_K_LAND = r"\&\&"
+t_K_TAND = r"\&\&\&"
+t_K_NOR = r"\~\|"
+t_K_NXOR = r"(\~\^|\^\~)"
+t_K_NAND = r"\~\&"
+t_K_TRIGGER = r"\->"
+t_K_PO_POS = r"\+:"
+t_K_PO_NEG = r"\-:"
+t_K_CONTRIBUTE = r"<\+"
+t_K_PLUS_EQ = r"\+="
+t_K_MINUS_EQ = r"\-="
+t_K_MUL_EQ = r"\*="
+t_K_DIV_EQ = r"\/="
+t_K_MOD_EQ = r"\%="
+t_K_AND_EQ = r"\&="
+t_K_OR_EQ = r"\|="
+t_K_XOR_EQ = r"\^="
+t_K_LS_EQ = r"(<<=|<<<=)"
+t_K_RS_EQ = r">>="
+t_K_RSS_EQ = r">>>="
+t_K_INCR = r"\+\+"
+t_K_DECR = r"\\--"
+t_K_LP = r"\'\{"
+t_K_SCOPE_RES = r"::"
+
+tokens += [ 'K_PSTAR', 'K_STARP', 'K_DOTSTAR', 'K_LS', 
+    'K_RS', 'K_RSS', 'K_POW', 'K_LE', 'K_GE', 'K_EG', 'K_SG',
+    'K_EQ', 'K_NE', 'K_CEQ', 'K_CNE', 'K_WEQ', 'K_WNE',
+    'K_LOR', 'K_LAND', 'K_TAND', 'K_NOR', 'K_NXOR', 
+    'K_NAND', 'K_TRIGGER', 'K_PO_POS', 'K_PO_NEG', 'K_CONTRIBUTE',
+    'K_PLUS_EQ', 'K_MINUS_EQ', 'K_MUL_EQ', 'K_DIV_EQ', 'K_MOD_EQ',
+    'K_AND_EQ', 'K_OR_EQ', 'K_XOR_EQ', 'K_LS_EQ', 'K_RS_EQ',
+    'K_RSS_EQ', 'K_INCR', 'K_DECR', 'K_LP',
+    'K_SCOPE_RES'
+        ]
+
+lexor_keyword_code = {
+    "above"                                    : 'K_above',
+    "abs"                                      : 'K_abs',
+    "absdelay"                         : 'K_absdelay',
+    "abstol"                                   : 'K_abstol',
+    "accept_on"                                : 'K_accept_on',
+    "access"                                   : 'K_access',
+    "acos"                                     : 'K_acos',
+    "acosh"                                    : 'K_acosh',
+    "ac_stim"                          : 'K_ac_stim',
+    "alias"                                    : 'K_alias',
+    "aliasparam"                               : 'K_aliasparam',
+    "always"                                   : 'K_always',
+    "always_comb"                              : 'K_always_comb',
+    "always_ff"                                : 'K_always_ff',
+    "always_latch"                             : 'K_always_latch',
+    "analog"                                   : 'K_analog',
+    "analysis"                         : 'K_analysis',
+    "and"                                      : 'K_and',
+    "asin"                                     : 'K_asin',
+    "asinh"                                    : 'K_asinh',
+    "assert"           : 'K_assert',
+    "assign"                                   : 'K_assign',
+    "assume"                                   : 'K_assume',
+    "atan"                                     : 'K_atan',
+    "atan2"                                    : 'K_atan2',
+    "atanh"                                    : 'K_atanh',
+    "automatic"                                : 'K_automatic',
+    "before"                                   : 'K_before',
+    "begin"                                    : 'K_begin',
+    "bind"                                     : 'K_bind',
+    "bins"                                     : 'K_bins',
+    "binsof"                                   : 'K_binsof',
+    "bit"                                      : 'K_bit',
+    "branch"                                   : 'K_branch',
+    "break"                                    : 'K_break',
+    "bool"                                     : 'K_bool',
+    "buf"                                      : 'K_buf',
+    "bufif0"                                   : 'K_bufif0',
+    "bufif1"                                   : 'K_bufif1',
+    "byte"                                     : 'K_byte',
+    "case"                                     : 'K_case',
+    "casex"                                    : 'K_casex',
+    "casez"                                    : 'K_casez',
+    "ceil"                                     : 'K_ceil',
+    "cell"                             : 'K_cell',
+    "chandle"                          : 'K_chandle',
+    "checker"                          : 'K_checker',
+    "class"                                    : 'K_class',
+    "clocking"                         : 'K_clocking',
+    "cmos"                                     : 'K_cmos',
+    "config"                           : 'K_config',
+    "connect"                          : 'K_connect',
+    "connectmodule"                            : 'K_connectmodule',
+    "connectrules"                             : 'K_connectrules',
+    "const"                                    : 'K_const',
+    "constraint"                               : 'K_constraint',
+    "context"                          : 'K_context',
+    "continue"                         : 'K_continue',
+    "continuous"                               : 'K_continuous',
+    "cos"                                      : 'K_cos',
+    "cosh"                                     : 'K_cosh',
+    "cover"                                    : 'K_cover',
+    "covergroup"                               : 'K_covergroup',
+    "coverpoint"                               : 'K_coverpoint',
+    "cross"                                    : 'K_cross',
+    "ddt"                                      : 'K_ddt',
+    "ddt_nature"                               : 'K_ddt_nature',
+    "ddx"                                      : 'K_ddx',
+    "deassign"                         : 'K_deassign',
+    "default"                          : 'K_default',
+    "defparam"                         : 'K_defparam',
+    "design"                           : 'K_design',
+    "disable"                          : 'K_disable',
+    "discipline"                               : 'K_discipline',
+    "discrete"                         : 'K_discrete',
+    "dist"                                     : 'K_dist',
+    "do"                                       : 'K_do',
+    "domain"                                   : 'K_domain',
+    "driver_update"                            : 'K_driver_update',
+    "edge"                                     : 'K_edge',
+    "else"                                     : 'K_else',
+    "end"                                      : 'K_end',
+    "endcase"                          : 'K_endcase',
+    "endchecker"                               : 'K_endchecker',
+    "endconfig"                        : 'K_endconfig',
+    "endclass"                         : 'K_endclass',
+    "endclocking"                              : 'K_endclocking',
+    "endconnectrules"                  : 'K_endconnectrules',
+    "enddiscipline"                            : 'K_enddiscipline',
+    "endfunction"                              : 'K_endfunction',
+    "endgenerate"                              : 'K_endgenerate',
+    "endgroup"                         : 'K_endgroup',
+    "endinterface"                             : 'K_endinterface',
+    "endmodule"                                : 'K_endmodule',
+    "endnature"                                : 'K_endnature',
+    "endpackage"                               : 'K_endpackage',
+    "endparamset"                              : 'K_endparamset',
+    "endprimitive"                             : 'K_endprimitive',
+    "endprogram"                               : 'K_endprogram',
+    "endproperty"                              : 'K_endproperty',
+    "endspecify"                               : 'K_endspecify',
+    "endsequence"                              : 'K_endsequence',
+    "endtable"                         : 'K_endtable',
+    "endtask"                          : 'K_endtask',
+    "enum"                                     : 'K_enum',
+    "event"                                    : 'K_event',
+    "eventually"                               : 'K_eventually',
+    "exclude"                          : 'K_exclude',
+    "exp"                                      : 'K_exp',
+    "expect"                                   : 'K_expect',
+    "export"                                   : 'K_export',
+    "extends"                          : 'K_extends',
+    "extern"                                   : 'K_extern',
+    "final"                                    : 'K_final',
+    "final_step"                               : 'K_final_step',
+    "first_match"                              : 'K_first_match',
+    "flicker_noise"                            : 'K_flicker_noise',
+    "floor"                                    : 'K_floor',
+    "flow"                                     : 'K_flow',
+    "for"                                      : 'K_for',
+    "foreach"                          : 'K_foreach',
+    "force"                                    : 'K_force',
+    "forever"                          : 'K_forever',
+    "fork"                                     : 'K_fork',
+    "forkjoin"                         : 'K_forkjoin',
+    "from"                                     : 'K_from',
+    "function"                         : 'K_function',
+    "generate"                         : 'K_generate',
+    "genvar"                                   : 'K_genvar',
+    "global"                                   : 'K_global',
+    "ground"                                   : 'K_ground',
+    "highz0"                                   : 'K_highz0',
+    "highz1"                                   : 'K_highz1',
+    "hypot"                                    : 'K_hypot',
+    "idt"                                      : 'K_idt',
+    "idtmod"                                   : 'K_idtmod',
+    "idt_nature"                               : 'K_idt_nature',
+    "if"                                       : 'K_if',
+    "iff"                                      : 'K_iff',
+    "ifnone"                                   : 'K_ifnone',
+    "ignore_bins"                              : 'K_ignore_bins',
+    "illegal_bins"                             : 'K_illegal_bins',
+    "implies"                          : 'K_implies',
+    "implements"                               : 'K_implements',
+    "import"                                   : 'K_import',
+    "incdir"                           : 'K_incdir',
+    "include"                  : 'K_include',
+    "inf"                                      : 'K_inf',
+    "initial"                          : 'K_initial',
+    "initial_step"                             : 'K_initial_step',
+    "inout"                                    : 'K_inout',
+    "input"                                    : 'K_input',
+    "inside"                                   : 'K_inside',
+    "instance"                 : 'K_instance',
+    "int"                                      : 'K_int',
+    "integer"                          : 'K_integer',
+    "interconnect"                             : 'K_interconnect',
+    "interface"                                : 'K_interface',
+    "intersect"                                : 'K_intersect',
+    "join"                                     : 'K_join',
+    "join_any"                         : 'K_join_any',
+    "join_none"                                : 'K_join_none',
+    "laplace_nd"                               : 'K_laplace_nd',
+    "laplace_np"                               : 'K_laplace_np',
+    "laplace_zd"                               : 'K_laplace_zd',
+    "laplace_zp"                               : 'K_laplace_zp',
+    "large"                                    : 'K_large',
+    "last_crossing"                            : 'K_last_crossing',
+    "let"                                      : 'K_let',
+    "liblist"                  : 'K_liblist',
+    "library"                  : 'K_library',
+    "limexp"                                   : 'K_limexp',
+    "ln"                                       : 'K_ln',
+    "local"                                    : 'K_local',
+    "localparam"                               : 'K_localparam',
+    "log"                                      : 'K_log',
+    # This is defined by SystemVerilog 1800-2005 and as an Icarus extension.'
+    "logic"            : 'K_logic',
+    "longint"                          : 'K_longint',
+    "macromodule"                              : 'K_macromodule',
+    "matches"                          : 'K_matches',
+    "max"                                      : 'K_max',
+    "medium"                                   : 'K_medium',
+    "merged"                                   : 'K_merged',
+    "min"                                      : 'K_min',
+    "modport"                          : 'K_modport',
+    "module"                                   : 'K_module',
+    "nand"                                     : 'K_nand',
+    "nature"                                   : 'K_nature',
+    "negedge"                          : 'K_negedge',
+    "net_resolution"                           : 'K_net_resolution',
+    "nettype"                          : 'K_nettype',
+    "new"                                      : 'K_new',
+    "nexttime"                         : 'K_nexttime',
+    "nmos"                                     : 'K_nmos',
+    "noise_table"                              : 'K_noise_table',
+    "nor"                                      : 'K_nor',
+    "noshowcancelled"                  : 'K_noshowcancelled',
+    "not"                                      : 'K_not',
+    "notif0"                                   : 'K_notif0',
+    "notif1"                                   : 'K_notif1',
+    "null"                                     : 'K_null',
+    "or"                                       : 'K_or',
+    "output"                                   : 'K_output',
+    "package"                          : 'K_package',
+    "packed"                                   : 'K_packed',
+    "parameter"                                : 'K_parameter',
+    "paramset"                         : 'K_paramset',
+    "pmos"                                     : 'K_pmos',
+    "posedge"                          : 'K_posedge',
+    "potential"                                : 'K_potential',
+    "pow"                                      : 'K_pow',
+    "primitive"                                : 'K_primitive',
+    "priority"                         : 'K_priority',
+    "program"                          : 'K_program',
+    "property"                         : 'K_property',
+    "protected"                                : 'K_protected',
+    "pull0"                                    : 'K_pull0',
+    "pull1"                                    : 'K_pull1',
+    "pulldown"                         : 'K_pulldown',
+    "pullup"                                   : 'K_pullup',
+    "pulsestyle_onevent"                       : 'K_pulsestyle_onevent',
+    "pulsestyle_ondetect"                      : 'K_pulsestyle_ondetect',
+    "pure"                                     : 'K_pure',
+    "rand"                                     : 'K_rand',
+    "randc"                                    : 'K_randc',
+    "randcase"                         : 'K_randcase',
+    "randsequence"                             : 'K_randsequence',
+    "rcmos"                                    : 'K_rcmos',
+    "real"                                     : 'K_real',
+    "realtime"                         : 'K_realtime',
+    "ref"                                      : 'K_ref',
+    "reg"                                      : 'K_reg',
+    "reject_on"                                : 'K_reject_on',
+    "release"                          : 'K_release',
+    "repeat"                                   : 'K_repeat',
+    "resolveto"                                : 'K_resolveto',
+    "restrict"                         : 'K_restrict',
+    "return"                                   : 'K_return',
+    "rnmos"                                    : 'K_rnmos',
+    "rpmos"                                    : 'K_rpmos',
+    "rtran"                                    : 'K_rtran',
+    "rtranif0"                         : 'K_rtranif0',
+    "rtranif1"                         : 'K_rtranif1',
+    "s_always"                         : 'K_s_always',
+    "s_eventually"                             : 'K_s_eventually',
+    "s_nexttime"                               : 'K_s_nexttime',
+    "s_until"                          : 'K_s_until',
+    "s_until_with"                             : 'K_s_until_with',
+    "scalared"                         : 'K_scalared',
+    "sequence"                         : 'K_sequence',
+    "shortint"                         : 'K_shortint',
+    "shortreal"                                : 'K_shortreal',
+    "showcancelled"                            : 'K_showcancelled',
+    "signed"                                   : 'K_signed',
+    "sin"                                      : 'K_sin',
+    "sinh"                                     : 'K_sinh',
+    "slew"                                     : 'K_slew',
+    "small"                                    : 'K_small',
+    "soft"                                     : 'K_soft',
+    "solve"                                    : 'K_solve',
+    "specify"                          : 'K_specify',
+    "specparam"                                : 'K_specparam',
+    "split"                                    : 'K_split',
+    "sqrt"                                     : 'K_sqrt',
+    "static"                                   : 'K_static',
+    # This is defined by both SystemVerilog 1800-2005 and Verilog-AMS 2.3',
+    "string"           : 'K_string',
+    "strong"                                   : 'K_strong',
+    "strong0"                          : 'K_strong0',
+    "strong1"                          : 'K_strong1',
+    "struct"                                   : 'K_struct',
+    "super"                                    : 'K_super',
+    "supply0"                          : 'K_supply0',
+    "supply1"                          : 'K_supply1',
+    "sync_accept_on"                           : 'K_sync_accept_on',
+    "sync_reject_on"                           : 'K_sync_reject_on',
+    "table"                                    : 'K_table',
+    "tagged"                                   : 'K_tagged',
+    "tan"                                      : 'K_tan',
+    "tanh"                                     : 'K_tanh',
+    "task"                                     : 'K_task',
+    "this"                                     : 'K_this',
+    "throughout"                               : 'K_throughout',
+    "time"                                     : 'K_time',
+    "timeprecision"                            : 'K_timeprecision',
+    "timer"                                    : 'K_timer',
+    "timeunit"                         : 'K_timeunit',
+    "tran"                                     : 'K_tran',
+    "tranif0"                          : 'K_tranif0',
+    "tranif1"                          : 'K_tranif1',
+    "transition"                               : 'K_transition',
+    "tri"                                      : 'K_tri',
+    "tri0"                                     : 'K_tri0',
+    "tri1"                                     : 'K_tri1',
+    "triand"                                   : 'K_triand',
+    "trior"                                    : 'K_trior',
+    "trireg"                                   : 'K_trireg',
+    "type"                                     : 'K_type',
+    "typedef"                          : 'K_typedef',
+    "union"                                    : 'K_union',
+    "unique"                                   : 'K_unique',
+    "unique0"                          : 'K_unique',
+    "units"                                    : 'K_units',
+    # Reserved for future use!',
+    "unsigned"                         : 'K_unsigned',
+    "until"                                    : 'K_until',
+    "until_with"                               : 'K_until_with',
+    "untyped"                          : 'K_untyped',
+    "use"                              : 'K_use',
+    "uwire"                                    : 'K_uwire',
+    "var"                                      : 'K_var',
+    "vectored"                         : 'K_vectored',
+    "virtual"                          : 'K_virtual',
+    "void"                                     : 'K_void',
+    "wait"                                     : 'K_wait',
+    "wait_order"                               : 'K_wait_order',
+    "wand"                                     : 'K_wand',
+    "weak"                                     : 'K_weak',
+    "weak0"                                    : 'K_weak0',
+    "weak1"                                    : 'K_weak1',
+    "while"                                    : 'K_while',
+    "white_noise"                              : 'K_white_noise',
+    "wildcard"                         : 'K_wildcard',
+    "wire"                                     : 'K_wire',
+    "with"                                     : 'K_with',
+    "within"                                   : 'K_within',
+    # This is the name originally proposed for uwire and is deprecated!',
+    "wone"                                     : 'K_wone',
+    "wor"                                      : 'K_wor',
+    # This is defined by Verilog-AMS 2.3 and as an Icarus extension.',
+    "wreal"            : 'K_wreal',
+    "xnor"                                     : 'K_xnor',
+    "xor"                                      : 'K_xor',
+    "zi_nd"                                    : 'K_zi_nd',
+    "zi_np"                                    : 'K_zi_np',
+    "zi_zd"                                    : 'K_zi_zd',
+    "zi_zp"                                    : 'K_zi_zp',
+}
+
+literals = [ '[', '}', '{', ';', ':', '[', ']', ',', '(', ')',
+            '#', '=', '.', '@', '&', '!', '?', '<', '>', '%', 
+            '|', '^', '~', '+', '*', '/', '-']
+
+"""
+  /* Watch out for the tricky case of (*). Cannot parse this as "(*"
+     and ")", but since I know that this is really ( * ), replace it
+     with "*" and return that. */
+"("{W}*"*"{W}*")" { return '*'; }
+
+<EDGES>"]" { BEGIN(0); return yytext[0]; }
+[}{;:\[\],()#=.@&!?<>%|^~+*/-] { return yytext[0]; }
+
+\"            { BEGIN(CSTRING); }
+<CSTRING>\\\\ { yymore(); /* Catch \\, which is a \ escaping itself */ }
+<CSTRING>\\\" { yymore(); /* Catch \", which is an escaped quote */ }
+<CSTRING>\n   { BEGIN(0);
+                yylval.text = strdupnew(yytext);
+               VLerror(yylloc, "Missing close quote of string.");
+               yylloc.first_line += 1;
+               return STRING; }
+<CSTRING>\"   { BEGIN(0);
+                yylval.text = strdupnew(yytext);
+               yylval.text[strlen(yytext)-1] = 0;
+               return STRING; }
+<CSTRING>.    { yymore(); }
+
+  /* The UDP Table is a unique lexical environment. These are most
+     tokens that we can expect in a table. */
+<UDPTABLE>\(\?0\)    { return '_'; }
+<UDPTABLE>\(\?1\)    { return '+'; }
+<UDPTABLE>\(\?[xX]\) { return '%'; }
+<UDPTABLE>\(\?\?\)  { return '*'; }
+<UDPTABLE>\(01\)    { return 'r'; }
+<UDPTABLE>\(0[xX]\) { return 'Q'; }
+<UDPTABLE>\(b[xX]\) { return 'q'; }
+<UDPTABLE>\(b0\)    { return 'f'; /* b0 is 10|00, but only 10 is meaningful */}
+<UDPTABLE>\(b1\)    { return 'r'; /* b1 is 11|01, but only 01 is meaningful */}
+<UDPTABLE>\(0\?\)   { return 'P'; }
+<UDPTABLE>\(10\)    { return 'f'; }
+<UDPTABLE>\(1[xX]\) { return 'M'; }
+<UDPTABLE>\(1\?\)   { return 'N'; }
+<UDPTABLE>\([xX]0\) { return 'F'; }
+<UDPTABLE>\([xX]1\) { return 'R'; }
+<UDPTABLE>\([xX]\?\) { return 'B'; }
+<UDPTABLE>[bB]     { return 'b'; }
+<UDPTABLE>[lL]     { return 'l'; /* IVL extension */ }
+<UDPTABLE>[hH]     { return 'h'; /* IVL extension */ }
+<UDPTABLE>[fF]     { return 'f'; }
+<UDPTABLE>[rR]     { return 'r'; }
+<UDPTABLE>[xX]     { return 'x'; }
+<UDPTABLE>[nN]     { return 'n'; }
+<UDPTABLE>[pP]     { return 'p'; }
+<UDPTABLE>[01\?\*\-:;] { return yytext[0]; }
+
+<EDGES>"01" { return K_edge_descriptor; }
+<EDGES>"0x" { return K_edge_descriptor; }
+<EDGES>"0z" { return K_edge_descriptor; }
+<EDGES>"10" { return K_edge_descriptor; }
+<EDGES>"1x" { return K_edge_descriptor; }
+<EDGES>"1z" { return K_edge_descriptor; }
+<EDGES>"x0" { return K_edge_descriptor; }
+<EDGES>"x1" { return K_edge_descriptor; }
+<EDGES>"z0" { return K_edge_descriptor; }
+<EDGES>"z1" { return K_edge_descriptor; }
+"""
+
+"""
+def t_module_end(t):
+    r'endmodule'
+    code = t.lexer.lexdata[t.modulestart:t.lexpos]
+    t.type = 'INITIAL'
+    t.value = code
+    t.lexer.lineno += t.value.count('\n')
+    return t
+
+t_module_ignore = ' \t'
+"""
+
+def t_LITERAL(t):
+    r'[a-zA-Z_][a-zA-Z0-9$_]*'
+    word = t.value
+    print ("literal", word)
+    keyword = lexor_keyword_code.get(t.value, 'IDENTIFIER')
+    #if keyword in ['K_module', 'K_macromodule']:
+    #    t.lexer.modulestart = t.lexpos+len(t.value)
+    #    t.lexer.begin('module')
+    if keyword == 'IDENTIFIER':
+        t.type = 'IDENTIFIER'
+        t.value = keyword
+        return t
+    t.type = keyword
+    return t
+
+"""
+      switch (rc) {
+         case IDENTIFIER:
+           yylval.text = strdupnew(yytext);
+           if (strncmp(yylval.text,"PATHPULSE$", 10) == 0)
+                 rc = PATHPULSE_IDENTIFIER;
+           break;
+
+         case K_edge:
+           BEGIN(EDGES);
+           break;
+
+         case K_primitive:
+           in_UDP = true;
+           break;
+
+         case K_endprimitive:
+           in_UDP = false;
+           break;
+
+         case K_table:
+           BEGIN(UDPTABLE);
+           break;
+
+         default:
+           yylval.text = 0;
+           break;
+      }
+
+       /* Special case: If this is part of a scoped name, then check
+          the package for identifier details. For example, if the
+          source file is  foo::bar, the parse.y will note the
+          PACKAGE_IDENTIFIER and "::" token and mark the
+          "in_package_scope" variable. Then this lexor will see the
+          identifier here and interpret it in the package scope. */
+      if (in_package_scope) {
+           if (rc == IDENTIFIER) {
+                 if (data_type_t*type = pform_test_type_identifier(in_package_scope, yylval.text)) {
+                       yylval.type_identifier.text = yylval.text;
+                       yylval.type_identifier.type = type;
+                       rc = TYPE_IDENTIFIER;
+                 }
+           }
+           in_package_scope = 0;
+           return rc;
+      }
+
+       /* If this identifier names a discipline, then return this as
+          a DISCIPLINE_IDENTIFIER and return the discipline as the
+          value instead. */
+      if (rc == IDENTIFIER && gn_verilog_ams_flag) {
+           perm_string tmp = lex_strings.make(yylval.text);
+           map<perm_string,ivl_discipline_t>::iterator cur = disciplines.find(tmp);
+           if (cur != disciplines.end()) {
+                 delete[]yylval.text;
+                 yylval.discipline = (*cur).second;
+                 rc = DISCIPLINE_IDENTIFIER;
+           }
+      }
+
+       /* If this identifier names a previously declared package, then
+          return this as a PACKAGE_IDENTIFIER instead. */
+      if (rc == IDENTIFIER && gn_system_verilog()) {
+           if (PPackage*pkg = pform_test_package_identifier(yylval.text)) {
+                 delete[]yylval.text;
+                 yylval.package = pkg;
+                 rc = PACKAGE_IDENTIFIER;
+           }
+      }
+
+       /* If this identifier names a previously declared type, then
+          return this as a TYPE_IDENTIFIER instead. */
+      if (rc == IDENTIFIER && gn_system_verilog()) {
+           if (data_type_t*type = pform_test_type_identifier(yylval.text)) {
+                 yylval.type_identifier.text = yylval.text;
+                 yylval.type_identifier.type = type;
+                 rc = TYPE_IDENTIFIER;
+           }
+      }
+
+      return rc;
+  }
+"""
+
+"""
+\\[^ \t\b\f\r\n]+         {
+      yylval.text = strdupnew(yytext+1);
+      if (gn_system_verilog()) {
+           if (PPackage*pkg = pform_test_package_identifier(yylval.text)) {
+                 delete[]yylval.text;
+                 yylval.package = pkg;
+                 return PACKAGE_IDENTIFIER;
+           }
+      }
+      if (gn_system_verilog()) {
+           if (data_type_t*type = pform_test_type_identifier(yylval.text)) {
+                 yylval.type_identifier.text = yylval.text;
+                 yylval.type_identifier.type = type;
+                 return TYPE_IDENTIFIER;
+           }
+      }
+      return IDENTIFIER;
+  }
+
+\$([a-zA-Z0-9$_]+)        {
+       /* The 1364-1995 timing checks. */
+      if (strcmp(yytext,"$hold") == 0)
+           return K_Shold;
+      if (strcmp(yytext,"$nochange") == 0)
+           return K_Snochange;
+      if (strcmp(yytext,"$period") == 0)
+           return K_Speriod;
+      if (strcmp(yytext,"$recovery") == 0)
+           return K_Srecovery;
+      if (strcmp(yytext,"$setup") == 0)
+           return K_Ssetup;
+      if (strcmp(yytext,"$setuphold") == 0)
+           return K_Ssetuphold;
+      if (strcmp(yytext,"$skew") == 0)
+           return K_Sskew;
+      if (strcmp(yytext,"$width") == 0)
+           return K_Swidth;
+       /* The new 1364-2001 timing checks. */
+      if (strcmp(yytext,"$fullskew") == 0)
+           return K_Sfullskew;
+      if (strcmp(yytext,"$recrem") == 0)
+           return K_Srecrem;
+      if (strcmp(yytext,"$removal") == 0)
+           return K_Sremoval;
+      if (strcmp(yytext,"$timeskew") == 0)
+           return K_Stimeskew;
+
+      if (strcmp(yytext,"$attribute") == 0)
+           return KK_attribute;
+
+      if (gn_system_verilog() && strcmp(yytext,"$unit") == 0) {
+           yylval.package = pform_units.back();
+           return PACKAGE_IDENTIFIER;
+      }
+
+      yylval.text = strdupnew(yytext);
+      return SYSTEM_IDENTIFIER; }
+"""
+
+def t_dec_number(t):
+    r'\'[sS]?[dD][ \t]*[0-9][0-9_]*'
+    t.type = 'BASED_NUMBER'
+    #t.value = word # make_unsized_dec(yytext);
+    return t
+
+def t_undef_highz_dec(t):
+    r'\'[sS]?[dD][ \t]*[xzXZ?]_*'
+    t.type = 'BASED_NUMBER'
+    #t.value = word # make_undef_highz_dec(yytext);
+    return t
+
+def t_based_make_unsized_binary(t):
+    r'\'[sS]?[bB][ \t]*[0-1xzXZ?][0-1xzXZ?_]*'
+    t.type = 'BASED_NUMBER'
+    #t.value = word # make_unsized_binary(yytext);
+    return t
+
+def t_make_unsized_octal(t):
+    r'\'[sS]?[oO][ \t]*[0-7xzXZ?][0-7xzXZ?_]*'
+    t.type = 'BASED_NUMBER'
+    #t.value = word # make_unsized_octal(yytext);
+    return t
+
+def t_make_unsized_hex(t):
+    r'\'[sS]?[hH][ \t]*[0-9a-fA-FxzXZ?][0-9a-fA-FxzXZ?_]*'
+    t.type = 'BASED_NUMBER'
+    #t.value = word # make_unsized_hex(yytext);
+    return t
+
+def t_unbased_make_unsized_binary(t):
+    r'\'[01xzXZ]'
+    t.type = 'UNBASED_NUMBER'
+    #t.value = word # make_unsized_binary(yytext);
+    return t
+
+"""
+  /* Decimal numbers are the usual. But watch out for the UDPTABLE
+     mode, where there are no decimal numbers. Reject the match if we
+     are in the UDPTABLE state. */
+"""
+"""
+      if (YY_START==UDPTABLE) {
+           REJECT;
+      } else {
+"""
+def t_make_unsized_dec(t):
+    r'[0-9][0-9_]*'
+    t.type = 'DEC_NUMBER'
+    #t.value = word # make_unsized_dec(yytext);
+    #based_size = yylval.number->as_ulong();
+    return t
+
+"""
+  /* Notice and handle the `timescale directive. */
+"""
+
+def t_timescale(t):
+    #r'^{W}?`timescale'
+    r'`timescale'
+    t.lexer.timestart = t.lexpos+len(t.value)
+    t.lexer.push_state('timescale')
+
+#t_timescale_ignore_toeol = r'.+\n'
+t_timescale_ignore = ' \t'
+#t_timescale_ignore_whitespace = r'\s+'
+#t_code_ignore = ""
+
+def t_timescale_end(t):
+    r'.+\n'
+    code = t.lexer.lexdata[t.lexer.timestart:t.lexpos]
+    t.type = 'timescale'
+    t.value = code
+    t.lexer.pop_state()
+    print "match", code
+    return t
+
+"""
+<PPTIMESCALE>.* { process_timescale(yytext); }
+<PPTIMESCALE>\n {
+      if (in_module) {
+           cerr << yylloc.text << ":" << yylloc.first_line << ": error: "
+                   "`timescale directive can not be inside a module "
+                   "definition." << endl;
+           error_count += 1;
+      }
+      yylloc.first_line += 1;
+      BEGIN(0); }
+"""
+
+"""
+
+  /* This rule handles scaled time values for SystemVerilog. */
+[0-9][0-9_]*(\.[0-9][0-9_]*)?{TU}?s {
+      if (gn_system_verilog()) {
+           yylval.text = strdupnew(yytext);
+           return TIME_LITERAL;
+      } else REJECT; }
+
+  /* These rules handle the scaled real literals from Verilog-AMS. The
+     value is a number with a single letter scale factor. If
+     verilog-ams is not enabled, then reject this rule. If it is
+     enabled, then collect the scale and use it to scale the value. */
+[0-9][0-9_]*\.[0-9][0-9_]*/{S} {
+      if (!gn_verilog_ams_flag) REJECT;
+      BEGIN(REAL_SCALE);
+      yymore();  }
+
+[0-9][0-9_]*/{S} {
+      if (!gn_verilog_ams_flag) REJECT;
+      BEGIN(REAL_SCALE);
+      yymore();  }
+
+<REAL_SCALE>{S} {
+      size_t token_len = strlen(yytext);
+      char*tmp = new char[token_len + 5];
+      int scale = 0;
+      strcpy(tmp, yytext);
+      switch (tmp[token_len-1]) {
+         case 'a': scale = -18; break; /* atto- */
+         case 'f': scale = -15; break; /* femto- */
+         case 'p': scale = -12; break; /* pico- */
+         case 'n': scale = -9;  break; /* nano- */
+         case 'u': scale = -6;  break; /* micro- */
+         case 'm': scale = -3;  break; /* milli- */
+         case 'k': scale = 3;  break; /* kilo- */
+         case 'K': scale = 3;  break; /* kilo- */
+         case 'M': scale = 6;  break; /* mega- */
+         case 'G': scale = 9;  break; /* giga- */
+         case 'T': scale = 12; break; /* tera- */
+         default: assert(0); break;
+      }
+      snprintf(tmp+token_len-1, 5, "e%d", scale);
+      yylval.realtime = new verireal(tmp);
+      delete[]tmp;
+
+      BEGIN(0);
+      return REALTIME;  }
+
+[0-9][0-9_]*\.[0-9][0-9_]*([Ee][+-]?[0-9][0-9_]*)? {
+      yylval.realtime = new verireal(yytext);
+      return REALTIME; }
+
+[0-9][0-9_]*[Ee][+-]?[0-9][0-9_]* {
+      yylval.realtime = new verireal(yytext);
+      return REALTIME; }
+
+
+  /* Notice and handle the `celldefine and `endcelldefine directives. */
+
+^{W}?`celldefine{W}?    { in_celldefine = true; }
+^{W}?`endcelldefine{W}? { in_celldefine = false; }
+
+  /* Notice and handle the resetall directive. */
+
+^{W}?`resetall{W}? {
+      if (in_module) {
+           cerr << yylloc.text << ":" << yylloc.first_line << ": error: "
+                   "`resetall directive can not be inside a module "
+                   "definition." << endl;
+           error_count += 1;
+      } else if (in_UDP) {
+           cerr << yylloc.text << ":" << yylloc.first_line << ": error: "
+                   "`resetall directive can not be inside a UDP "
+                   "definition." << endl;
+           error_count += 1;
+      } else {
+           reset_all();
+      } }
+
+  /* Notice and handle the `unconnected_drive directive. */
+^{W}?`unconnected_drive { BEGIN(PPUCDRIVE); }
+<PPUCDRIVE>.* { process_ucdrive(yytext); }
+<PPUCDRIVE>\n {
+      if (in_module) {
+           cerr << yylloc.text << ":" << yylloc.first_line << ": error: "
+                   "`unconnected_drive directive can not be inside a "
+                   "module definition." << endl;
+           error_count += 1;
+      }
+      yylloc.first_line += 1;
+      BEGIN(0); }
+
+^{W}?`nounconnected_drive{W}? {
+      if (in_module) {
+           cerr << yylloc.text << ":" << yylloc.first_line << ": error: "
+                   "`nounconnected_drive directive can not be inside a "
+                   "module definition." << endl;
+           error_count += 1;
+      }
+      uc_drive = UCD_NONE; }
+
+  /* These are directives that I do not yet support. I think that IVL
+     should handle these, not an external preprocessor. */
+  /* From 1364-2005 Chapter 19. */
+^{W}?`pragme{W}?.*                  {  }
+
+  /* From 1364-2005 Annex D. */
+^{W}?`default_decay_time{W}?.*      {  }
+^{W}?`default_trireg_strength{W}?.* {  }
+^{W}?`delay_mode_distributed{W}?.*  {  }
+^{W}?`delay_mode_path{W}?.*         {  }
+^{W}?`delay_mode_unit{W}?.*         {  }
+^{W}?`delay_mode_zero{W}?.*         {  }
+
+  /* From other places. */
+^{W}?`disable_portfaults{W}?.*      {  }
+^{W}?`enable_portfaults{W}?.*       {  }
+`endprotect                         {  }
+^{W}?`nosuppress_faults{W}?.*       {  }
+`protect                            {  }
+^{W}?`suppress_faults{W}?.*         {  }
+^{W}?`uselib{W}?.*                  {  }
+
+^{W}?`begin_keywords{W}? { BEGIN(PPBEGIN_KEYWORDS); }
+
+<PPBEGIN_KEYWORDS>\"[a-zA-Z0-9 -\.]*\".* {
+      keyword_mask_stack.push_front(lexor_keyword_mask);
+
+      char*word = yytext+1;
+      char*tail = strchr(word, '"');
+      tail[0] = 0;
+      if (strcmp(word,"1364-1995") == 0) {
+           lexor_keyword_mask = GN_KEYWORDS_1364_1995;
+      } else if (strcmp(word,"1364-2001") == 0) {
+           lexor_keyword_mask = GN_KEYWORDS_1364_1995
+                               |GN_KEYWORDS_1364_2001
+                               |GN_KEYWORDS_1364_2001_CONFIG;
+      } else if (strcmp(word,"1364-2001-noconfig") == 0) {
+           lexor_keyword_mask = GN_KEYWORDS_1364_1995
+                               |GN_KEYWORDS_1364_2001;
+      } else if (strcmp(word,"1364-2005") == 0) {
+           lexor_keyword_mask = GN_KEYWORDS_1364_1995
+                               |GN_KEYWORDS_1364_2001
+                               |GN_KEYWORDS_1364_2001_CONFIG
+                               |GN_KEYWORDS_1364_2005;
+      } else if (strcmp(word,"1800-2005") == 0) {
+           lexor_keyword_mask = GN_KEYWORDS_1364_1995
+                               |GN_KEYWORDS_1364_2001
+                               |GN_KEYWORDS_1364_2001_CONFIG
+                               |GN_KEYWORDS_1364_2005
+                               |GN_KEYWORDS_1800_2005;
+      } else if (strcmp(word,"1800-2009") == 0) {
+           lexor_keyword_mask = GN_KEYWORDS_1364_1995
+                               |GN_KEYWORDS_1364_2001
+                               |GN_KEYWORDS_1364_2001_CONFIG
+                               |GN_KEYWORDS_1364_2005
+                               |GN_KEYWORDS_1800_2005
+                               |GN_KEYWORDS_1800_2009;
+      } else if (strcmp(word,"1800-2012") == 0) {
+           lexor_keyword_mask = GN_KEYWORDS_1364_1995
+                               |GN_KEYWORDS_1364_2001
+                               |GN_KEYWORDS_1364_2001_CONFIG
+                               |GN_KEYWORDS_1364_2005
+                               |GN_KEYWORDS_1800_2005
+                               |GN_KEYWORDS_1800_2009
+                               |GN_KEYWORDS_1800_2012;
+      } else if (strcmp(word,"VAMS-2.3") == 0) {
+           lexor_keyword_mask = GN_KEYWORDS_1364_1995
+                               |GN_KEYWORDS_1364_2001
+                               |GN_KEYWORDS_1364_2001_CONFIG
+                               |GN_KEYWORDS_1364_2005
+                               |GN_KEYWORDS_VAMS_2_3;
+      } else {
+           fprintf(stderr, "%s:%d: Ignoring unknown keywords string: %s\n",
+                   yylloc.text, yylloc.first_line, word);
+      }
+      BEGIN(0);
+ }
+
+<PPBEGIN_KEYWORDS>.* {
+      fprintf(stderr, "%s:%d: Malformed keywords specification: %s\n",
+             yylloc.text, yylloc.first_line, yytext);
+      BEGIN(0);
+ }
+
+^{W}?`end_keywords{W}?.* {
+      if (!keyword_mask_stack.empty()) {
+           lexor_keyword_mask = keyword_mask_stack.front();
+           keyword_mask_stack.pop_front();
+      } else {
+           fprintf(stderr, "%s:%d: Mismatched end_keywords directive\n",
+                   yylloc.text, yylloc.first_line);
+      }
+ }
+
+  /* Notice and handle the default_nettype directive. The lexor
+     detects the default_nettype keyword, and the second part of the
+     rule collects the rest of the line and processes it. We only need
+     to look for the first work, and interpret it. */
+
+`default_nettype{W}? { BEGIN(PPDEFAULT_NETTYPE); }
+<PPDEFAULT_NETTYPE>.* {
+      NetNet::Type net_type;
+      size_t wordlen = strcspn(yytext, " \t\f\r\n");
+      yytext[wordlen] = 0;
+  /* Add support for other wire types and better error detection. */
+      if (strcmp(yytext,"wire") == 0) {
+           net_type = NetNet::WIRE;
+
+      } else if (strcmp(yytext,"tri") == 0) {
+           net_type = NetNet::TRI;
+
+      } else if (strcmp(yytext,"tri0") == 0) {
+           net_type = NetNet::TRI0;
+
+      } else if (strcmp(yytext,"tri1") == 0) {
+           net_type = NetNet::TRI1;
+
+      } else if (strcmp(yytext,"wand") == 0) {
+           net_type = NetNet::WAND;
+
+      } else if (strcmp(yytext,"triand") == 0) {
+           net_type = NetNet::TRIAND;
+
+      } else if (strcmp(yytext,"wor") == 0) {
+           net_type = NetNet::WOR;
+
+      } else if (strcmp(yytext,"trior") == 0) {
+           net_type = NetNet::TRIOR;
+
+      } else if (strcmp(yytext,"none") == 0) {
+           net_type = NetNet::NONE;
+
+      } else {
+           cerr << yylloc.text << ":" << yylloc.first_line
+                << ": error: Net type " << yytext
+                << " is not a valid (or supported)"
+                << " default net type." << endl;
+           net_type = NetNet::WIRE;
+           error_count += 1;
+      }
+      pform_set_default_nettype(net_type, yylloc.text, yylloc.first_line);
+  }
+<PPDEFAULT_NETTYPE>\n {
+      yylloc.first_line += 1;
+      BEGIN(0); }
+
+
+  /* These are directives that are not supported by me and should have
+     been handled by an external preprocessor such as ivlpp. */
+
+^{W}?`define{W}?.* {
+      cerr << yylloc.text << ":" << yylloc.first_line <<
+           ": warning: `define not supported. Use an external preprocessor."
+          << endl;
+  }
+
+^{W}?`else{W}?.* {
+      cerr << yylloc.text << ":" << yylloc.first_line <<
+           ": warning: `else not supported. Use an external preprocessor."
+          << endl;
+  }
+
+^{W}?`elsif{W}?.* {
+      cerr << yylloc.text << ":" << yylloc.first_line <<
+           ": warning: `elsif not supported. Use an external preprocessor."
+          << endl;
+  }
+
+^{W}?`endif{W}?.* {
+      cerr << yylloc.text << ":" << yylloc.first_line <<
+           ": warning: `endif not supported. Use an external preprocessor."
+          << endl;
+  }
+
+^{W}?`ifdef{W}?.* {
+      cerr << yylloc.text << ":" << yylloc.first_line <<
+           ": warning: `ifdef not supported. Use an external preprocessor."
+          << endl;
+  }
+
+^{W}?`ifndef{W}?.* {
+      cerr << yylloc.text << ":" << yylloc.first_line <<
+           ": warning: `ifndef not supported. Use an external preprocessor."
+          << endl;
+  }
+
+^`include{W}?.* {
+      cerr << yylloc.text << ":" << yylloc.first_line <<
+           ": warning: `include not supported. Use an external preprocessor."
+          << endl;
+  }
+
+^`undef{W}?.* {
+      cerr << yylloc.text << ":" << yylloc.first_line <<
+           ": warning: `undef not supported. Use an external preprocessor."
+          << endl;
+  }
+
+
+`{W} { cerr << yylloc.text << ":" << yylloc.first_line << ": error: "
+           << "Stray tic (`) here. Perhaps you put white space" << endl;
+       cerr << yylloc.text << ":" << yylloc.first_line << ":      : "
+           << "between the tic and preprocessor directive?"
+           << endl;
+       error_count += 1; }
+
+. { return yytext[0]; }
+
+  /* Final catchall. something got lost or mishandled. */
+  /* XXX Should we tell the user something about the lexical state? */
+
+<*>.|\n {   cerr << yylloc.text << ":" << yylloc.first_line
+          << ": error: unmatched character (";
+      if (isprint(yytext[0]))
+           cerr << yytext[0];
+      else
+           cerr << "hex " << hex << ((unsigned char) yytext[0]);
+
+      cerr << ")" << endl;
+      error_count += 1; }
+
+%%
+
+/*
+ * The UDP state table needs some slightly different treatment by the
+ * lexor. The level characters are normally accepted as other things,
+ * so the parser needs to switch my mode when it believes in needs to.
+ */
+void lex_end_table()
+{
+      BEGIN(INITIAL);
+}
+
+static unsigned truncate_to_integer_width(verinum::V*bits, unsigned size)
+{
+      if (size <= integer_width) return size;
+
+      verinum::V pad = bits[size-1];
+      if (pad == verinum::V1) pad = verinum::V0;
+
+      for (unsigned idx = integer_width; idx < size; idx += 1) {
+           if (bits[idx] != pad) {
+                 yywarn(yylloc, "Unsized numeric constant truncated to integer width.");
+                 break;
+           }
+      }
+      return integer_width;
+}
+
+verinum*make_unsized_binary(const char*txt)
+{
+      bool sign_flag = false;
+      bool single_flag = false;
+      const char*ptr = txt;
+      assert(*ptr == '\'');
+      ptr += 1;
+
+      if (tolower(*ptr) == 's') {
+           sign_flag = true;
+           ptr += 1;
+      }
+
+      assert((tolower(*ptr) == 'b') || gn_system_verilog());
+      if (tolower(*ptr) == 'b') {
+           ptr += 1;
+      } else {
+           assert(sign_flag == false);
+           single_flag = true;
+      }
+
+      while (*ptr && ((*ptr == ' ') || (*ptr == '\t')))
+           ptr += 1;
+
+      unsigned size = 0;
+      for (const char*idx = ptr ;  *idx ;  idx += 1)
+           if (*idx != '_') size += 1;
+
+      if (size == 0) {
+           VLerror(yylloc, "Numeric literal has no digits in it.");
+           verinum*out = new verinum();
+           out->has_sign(sign_flag);
+           out->is_single(single_flag);
+           return out;
+      }
+
+      if ((based_size > 0) && (size > based_size)) yywarn(yylloc,
+          "extra digits given for sized binary constant.");
+
+      verinum::V*bits = new verinum::V[size];
+
+      unsigned idx = size;
+      while (*ptr) {
+           switch (ptr[0]) {
+               case '0':
+                 bits[--idx] = verinum::V0;
+                 break;
+               case '1':
+                 bits[--idx] = verinum::V1;
+                 break;
+               case 'z': case 'Z': case '?':
+                 bits[--idx] = verinum::Vz;
+                 break;
+               case 'x': case 'X':
+                 bits[--idx] = verinum::Vx;
+                 break;
+                 case '_':
+                 break;
+               default:
+                 fprintf(stderr, "%c\n", ptr[0]);
+                 assert(0);
+           }
+           ptr += 1;
+      }
+
+      if (gn_strict_expr_width_flag && (based_size == 0))
+           size = truncate_to_integer_width(bits, size);
+
+      verinum*out = new verinum(bits, size, false);
+      out->has_sign(sign_flag);
+      out->is_single(single_flag);
+      delete[]bits;
+      return out;
+}
+
+
+verinum*make_unsized_octal(const char*txt)
+{
+      bool sign_flag = false;
+      const char*ptr = txt;
+      assert(*ptr == '\'');
+      ptr += 1;
+
+      if (tolower(*ptr) == 's') {
+           sign_flag = true;
+           ptr += 1;
+      }
+
+      assert(tolower(*ptr) == 'o');
+      ptr += 1;
+
+      while (*ptr && ((*ptr == ' ') || (*ptr == '\t')))
+           ptr += 1;
+
+      unsigned size = 0;
+      for (const char*idx = ptr ;  *idx ;  idx += 1)
+           if (*idx != '_') size += 3;
+
+      if (based_size > 0) {
+            int rem = based_size % 3;
+           if (rem != 0) based_size += 3 - rem;
+           if (size > based_size) yywarn(yylloc,
+               "extra digits given for sized octal constant.");
+      }
+
+      verinum::V*bits = new verinum::V[size];
+
+      unsigned idx = size;
+      while (*ptr) {
+           unsigned val;
+           switch (ptr[0]) {
+               case '0': case '1': case '2': case '3':
+               case '4': case '5': case '6': case '7':
+                 val = *ptr - '0';
+                 bits[--idx] = (val&4) ? verinum::V1 : verinum::V0;
+                 bits[--idx] = (val&2) ? verinum::V1 : verinum::V0;
+                 bits[--idx] = (val&1) ? verinum::V1 : verinum::V0;
+                 break;
+               case 'x': case 'X':
+                 bits[--idx] = verinum::Vx;
+                 bits[--idx] = verinum::Vx;
+                 bits[--idx] = verinum::Vx;
+                 break;
+               case 'z': case 'Z': case '?':
+                 bits[--idx] = verinum::Vz;
+                 bits[--idx] = verinum::Vz;
+                 bits[--idx] = verinum::Vz;
+                 break;
+               case '_':
+                 break;
+               default:
+                 assert(0);
+           }
+           ptr += 1;
+      }
+
+      if (gn_strict_expr_width_flag && (based_size == 0))
+           size = truncate_to_integer_width(bits, size);
+
+      verinum*out = new verinum(bits, size, false);
+      out->has_sign(sign_flag);
+      delete[]bits;
+      return out;
+}
+
+
+verinum*make_unsized_hex(const char*txt)
+{
+      bool sign_flag = false;
+      const char*ptr = txt;
+      assert(*ptr == '\'');
+      ptr += 1;
+
+      if (tolower(*ptr) == 's') {
+           sign_flag = true;
+           ptr += 1;
+      }
+      assert(tolower(*ptr) == 'h');
+
+      ptr += 1;
+      while (*ptr && ((*ptr == ' ') || (*ptr == '\t')))
+           ptr += 1;
+
+      unsigned size = 0;
+      for (const char*idx = ptr ;  *idx ;  idx += 1)
+           if (*idx != '_') size += 4;
+
+      if (based_size > 0) {
+            int rem = based_size % 4;
+           if (rem != 0) based_size += 4 - rem;
+           if (size > based_size) yywarn(yylloc,
+               "extra digits given for sized hex constant.");
+      }
+
+      verinum::V*bits = new verinum::V[size];
+
+      unsigned idx = size;
+      while (*ptr) {
+           unsigned val;
+           switch (ptr[0]) {
+               case '0': case '1': case '2': case '3': case '4':
+               case '5': case '6': case '7': case '8': case '9':
+                 val = *ptr - '0';
+                 bits[--idx] = (val&8) ? verinum::V1 : verinum::V0;
+                 bits[--idx] = (val&4) ? verinum::V1 : verinum::V0;
+                 bits[--idx] = (val&2) ? verinum::V1 : verinum::V0;
+                 bits[--idx] = (val&1) ? verinum::V1 : verinum::V0;
+                 break;
+               case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
+               case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
+                 val = tolower(*ptr) - 'a' + 10;
+                 bits[--idx] = (val&8) ? verinum::V1 : verinum::V0;
+                 bits[--idx] = (val&4) ? verinum::V1 : verinum::V0;
+                 bits[--idx] = (val&2) ? verinum::V1 : verinum::V0;
+                 bits[--idx] = (val&1) ? verinum::V1 : verinum::V0;
+                 break;
+               case 'x': case 'X':
+                 bits[--idx] = verinum::Vx;
+                 bits[--idx] = verinum::Vx;
+                 bits[--idx] = verinum::Vx;
+                 bits[--idx] = verinum::Vx;
+                 break;
+               case 'z': case 'Z': case '?':
+                 bits[--idx] = verinum::Vz;
+                 bits[--idx] = verinum::Vz;
+                 bits[--idx] = verinum::Vz;
+                 bits[--idx] = verinum::Vz;
+                 break;
+               case '_':
+                 break;
+               default:
+                 assert(0);
+           }
+           ptr += 1;
+      }
+
+      if (gn_strict_expr_width_flag && (based_size == 0))
+           size = truncate_to_integer_width(bits, size);
+
+      verinum*out = new verinum(bits, size, false);
+      out->has_sign(sign_flag);
+      delete[]bits;
+      return out;
+}
+
+
+/* Divide the integer given by the string by 2. Return the remainder bit. */
+static int dec_buf_div2(char *buf)
+{
+    int partial;
+    int len = strlen(buf);
+    char *dst_ptr;
+    int pos;
+
+    partial = 0;
+    pos = 0;
+
+    /* dst_ptr overwrites buf, but all characters that are overwritten
+       were already used by the reader. */
+    dst_ptr = buf;
+
+    while(buf[pos] == '0')
+       ++pos;
+
+    for(; pos<len; ++pos){
+       if (buf[pos]=='_')
+           continue;
+
+       assert(isdigit(buf[pos]));
+
+       partial= partial*10 + (buf[pos]-'0');
+
+       if (partial >= 2){
+           *dst_ptr = partial/2 + '0';
+           partial = partial & 1;
+
+           ++dst_ptr;
+       }
+       else{
+           *dst_ptr = '0';
+           ++dst_ptr;
+       }
+    }
+
+    // If result of division was zero string, it should remain that way.
+    // Don't eat the last zero...
+    if (dst_ptr == buf){
+       *dst_ptr = '0';
+       ++dst_ptr;
+    }
+    *dst_ptr = 0;
+
+    return partial;
+}
+
+/* Support a single x, z or ? as a decimal constant (from 1364-2005). */
+verinum* make_undef_highz_dec(const char* ptr)
+{
+      bool signed_flag = false;
+
+      assert(*ptr == '\'');
+      /* The number may have decorations of the form 'sd<code>,
+         possibly with space between the d and the <code>.
+         Also, the 's' is optional, and marks the number as signed. */
+      ptr += 1;
+
+      if (tolower(*ptr) == 's') {
+         signed_flag = true;
+         ptr += 1;
+      }
+
+      assert(tolower(*ptr) == 'd');
+      ptr += 1;
+
+      while (*ptr && ((*ptr == ' ') || (*ptr == '\t')))
+         ptr += 1;
+
+       /* Process the code. */
+      verinum::V* bits = new verinum::V[1];
+      switch (*ptr) {
+         case 'x':
+         case 'X':
+           bits[0] = verinum::Vx;
+           break;
+         case 'z':
+         case 'Z':
+         case '?':
+           bits[0] = verinum::Vz;
+           break;
+         default:
+           assert(0);
+      }
+      ptr += 1;
+      while (*ptr == '_') ptr += 1;
+      assert(*ptr == 0);
+
+      verinum*out = new verinum(bits, 1, false);
+      out->has_sign(signed_flag);
+      delete[]bits;
+      return out;
+}
+
+/*
+ * Making a decimal number is much easier than the other base numbers
+ * because there are no z or x values to worry about. It is much
+ * harder than other base numbers because the width needed in bits is
+ * hard to calculate.
+ */
+
+verinum*make_unsized_dec(const char*ptr)
+{
+      char buf[4096];
+      bool signed_flag = false;
+      unsigned idx;
+
+      if (ptr[0] == '\'') {
+             /* The number has decorations of the form 'sd<digits>,
+                possibly with space between the d and the <digits>.
+                Also, the 's' is optional, and marks the number as
+                signed. */
+           ptr += 1;
+
+           if (tolower(*ptr) == 's') {
+                 signed_flag = true;
+                 ptr += 1;
+           }
+
+           assert(tolower(*ptr) == 'd');
+           ptr += 1;
+
+           while (*ptr && ((*ptr == ' ') || (*ptr == '\t')))
+                 ptr += 1;
+
+      } else {
+             /* ... or an undecorated decimal number is passed
+                it. These numbers are treated as signed decimal. */
+           assert(isdigit(*ptr));
+           signed_flag = true;
+      }
+
+
+       /* Copy the digits into a buffer that I can use to do in-place
+          decimal divides. */
+      idx = 0;
+      while ((idx < sizeof buf) && (*ptr != 0)) {
+           if (*ptr == '_') {
+                 ptr += 1;
+                 continue;
+           }
+
+           buf[idx++] = *ptr++;
+      }
+
+      if (idx == sizeof buf) {
+           fprintf(stderr, "Ridiculously long"
+                   " decimal constant will be truncated!\n");
+           idx -= 1;
+      }
+
+      buf[idx] = 0;
+      unsigned tmp_size = idx * 4 + 1;
+      verinum::V *bits = new verinum::V[tmp_size];
+
+      idx = 0;
+      while (idx < tmp_size) {
+           int rem = dec_buf_div2(buf);
+           bits[idx++] = (rem == 1) ? verinum::V1 : verinum::V0;
+      }
+
+      assert(strcmp(buf, "0") == 0);
+
+       /* Now calculate the minimum number of bits needed to
+          represent this unsigned number. */
+      unsigned size = tmp_size;
+      while ((size > 1) && (bits[size-1] == verinum::V0))
+           size -= 1;
+
+       /* Now account for the signedness. Don't leave a 1 in the high
+          bit if this is a signed number. */
+      if (signed_flag && (bits[size-1] == verinum::V1)) {
+           size += 1;
+           assert(size <= tmp_size);
+      }
+
+        /* Since we never have the real number of bits that a decimal
+           number represents we do not check for extra bits. */
+//      if (based_size > 0) { }
+
+      if (gn_strict_expr_width_flag && (based_size == 0))
+           size = truncate_to_integer_width(bits, size);
+
+      verinum*res = new verinum(bits, size, false);
+      res->has_sign(signed_flag);
+
+      delete[]bits;
+      return res;
+}
+
+/*
+ * Convert the string to a time unit or precision.
+ * Returns true on failure.
+ */
+static bool get_timescale_const(const char *&cp, int &res, bool is_unit)
+{
+       /* Check for the 1 digit. */
+      if (*cp != '1') {
+           if (is_unit) {
+                 VLerror(yylloc, "Invalid `timescale unit constant "
+                                 "(1st digit)");
+           } else {
+                 VLerror(yylloc, "Invalid `timescale precision constant "
+                                 "(1st digit)");
+           }
+           return true;
+      }
+      cp += 1;
+
+       /* Check the number of zeros after the 1. */
+      res = strspn(cp, "0");
+      if (res > 2) {
+           if (is_unit) {
+                 VLerror(yylloc, "Invalid `timescale unit constant "
+                                 "(number of zeros)");
+           } else {
+                 VLerror(yylloc, "Invalid `timescale precision constant "
+                                 "(number of zeros)");
+           }
+           return true;
+      }
+      cp += res;
+
+       /* Skip any space between the digits and the scaling string. */
+      cp += strspn(cp, " \t");
+
+       /* Now process the scaling string. */
+      if (strncmp("s", cp, 1) == 0) {
+           res -= 0;
+           cp += 1;
+           return false;
+
+      } else if (strncmp("ms", cp, 2) == 0) {
+           res -= 3;
+           cp += 2;
+           return false;
+
+      } else if (strncmp("us", cp, 2) == 0) {
+           res -= 6;
+           cp += 2;
+           return false;
+
+      } else if (strncmp("ns", cp, 2) == 0) {
+           res -= 9;
+           cp += 2;
+           return false;
+
+      } else if (strncmp("ps", cp, 2) == 0) {
+           res -= 12;
+           cp += 2;
+           return false;
+
+      } else if (strncmp("fs", cp, 2) == 0) {
+           res -= 15;
+           cp += 2;
+           return false;
+
+      }
+
+      if (is_unit) {
+           VLerror(yylloc, "Invalid `timescale unit scale");
+      } else {
+           VLerror(yylloc, "Invalid `timescale precision scale");
+      }
+      return true;
+}
+
+
+/*
+ * process either a pull0 or a pull1.
+ */
+static void process_ucdrive(const char*txt)
+{
+      UCDriveType ucd = UCD_NONE;
+      const char*cp = txt + strspn(txt, " \t");
+
+       /* Skip the space after the `unconnected_drive directive. */
+      if (cp == txt) {
+           VLerror(yylloc, "Space required after `unconnected_drive "
+                           "directive.");
+           return;
+      }
+
+       /* Check for the pull keyword. */
+      if (strncmp("pull", cp, 4) != 0) {
+           VLerror(yylloc, "pull required for `unconnected_drive "
+                           "directive.");
+           return;
+      }
+      cp += 4;
+      if (*cp == '0') ucd = UCD_PULL0;
+      else if (*cp == '1') ucd = UCD_PULL1;
+      else {
+           cerr << yylloc.text << ":" << yylloc.first_line << ": error: "
+                   "`unconnected_drive does not support 'pull" << *cp
+                << "'." << endl;
+           error_count += 1;
+           return;
+      }
+      cp += 1;
+
+       /* Verify that only space and/or a single line comment is left. */
+      cp += strspn(cp, " \t");
+      if (strncmp(cp, "//", 2) != 0 &&
+          (size_t)(cp-yytext) != strlen(yytext)) {
+           VLerror(yylloc, "Invalid `unconnected_drive directive (extra "
+                           "garbage after precision).");
+           return;
+      }
+
+      uc_drive = ucd;
+}
+
+/*
+ * The timescale parameter has the form:
+ *      " <num> xs / <num> xs"
+ */
+static void process_timescale(const char*txt)
+{
+      const char*cp = txt + strspn(txt, " \t");
+
+       /* Skip the space after the `timescale directive. */
+      if (cp == txt) {
+           VLerror(yylloc, "Space required after `timescale directive.");
+           return;
+      }
+
+      int unit = 0;
+      int prec = 0;
+
+       /* Get the time units. */
+      if (get_timescale_const(cp, unit, true)) return;
+
+       /* Skip any space after the time units, the '/' and any
+        * space after the '/'. */
+      cp += strspn(cp, " \t");
+      if (*cp != '/') {
+           VLerror(yylloc, "`timescale separator '/' appears to be missing.");
+           return;
+      }
+      cp += 1;
+      cp += strspn(cp, " \t");
+
+       /* Get the time precision. */
+      if (get_timescale_const(cp, prec, false)) return;
+
+       /* Verify that only space and/or a single line comment is left. */
+      cp += strspn(cp, " \t");
+      if (strncmp(cp, "//", 2) != 0 &&
+          (size_t)(cp-yytext) != strlen(yytext)) {
+           VLerror(yylloc, "Invalid `timescale directive (extra garbage "
+                           "after precision).");
+           return;
+      }
+
+       /* The time unit must be greater than or equal to the precision. */
+      if (unit < prec) {
+           VLerror(yylloc, "error: `timescale unit must not be less than "
+                           "the precision.");
+           return;
+      }
+
+      pform_set_timescale(unit, prec, yylloc.text, yylloc.first_line);
+}
+
+int yywrap()
+{
+      return 1;
+}
+
+/*
+ * The line directive matches lines of the form #line "foo" N and
+ * calls this function. Here I parse out the file name and line
+ * number, and change the yylloc to suite.
+ */
+static void line_directive()
+{
+      char *cpr;
+       /* Skip any leading space. */
+      char *cp = strchr(yytext, '#');
+       /* Skip the #line directive. */
+      assert(strncmp(cp, "#line", 5) == 0);
+      cp += 5;
+       /* Skip the space after the #line directive. */
+      cp += strspn(cp, " \t");
+
+       /* Find the starting " and skip it. */
+      char*fn_start = strchr(cp, '"');
+      if (cp != fn_start) {
+           VLerror(yylloc, "Invalid #line directive (file name start).");
+           return;
+      }
+      fn_start += 1;
+
+       /* Find the last ". */
+      char*fn_end = strrchr(fn_start, '"');
+      if (!fn_end) {
+           VLerror(yylloc, "Invalid #line directive (file name end).");
+           return;
+      }
+
+       /* Copy the file name and assign it to yylloc. */
+      char*buf = new char[fn_end-fn_start+1];
+      strncpy(buf, fn_start, fn_end-fn_start);
+      buf[fn_end-fn_start] = 0;
+
+       /* Skip the space after the file name. */
+      cp = fn_end;
+      cp += 1;
+      cpr = cp;
+      cpr += strspn(cp, " \t");
+      if (cp == cpr) {
+           VLerror(yylloc, "Invalid #line directive (missing space after "
+                           "file name).");
+           delete[] buf;
+           return;
+      }
+      cp = cpr;
+
+       /* Get the line number and verify that it is correct. */
+      unsigned long lineno = strtoul(cp, &cpr, 10);
+      if (cp == cpr) {
+           VLerror(yylloc, "Invalid line number for #line directive.");
+           delete[] buf;
+           return;
+      }
+      cp = cpr;
+
+       /* Verify that only space is left. */
+      cpr += strspn(cp, " \t");
+      if ((size_t)(cpr-yytext) != strlen(yytext)) {
+           VLerror(yylloc, "Invalid #line directive (extra garbage after "
+                           "line number).");
+           delete[] buf;
+           return;
+      }
+
+       /* Now we can assign the new values to yyloc. */
+      yylloc.text = set_file_name(buf);
+      yylloc.first_line = lineno;
+}
+
+/*
+ * The line directive matches lines of the form `line N "foo" M and
+ * calls this function. Here I parse out the file name and line
+ * number, and change the yylloc to suite. M is ignored.
+ */
+static void line_directive2()
+{
+      char *cpr;
+       /* Skip any leading space. */
+      char *cp = strchr(yytext, '`');
+       /* Skip the `line directive. */
+      assert(strncmp(cp, "`line", 5) == 0);
+      cp += 5;
+
+       /* strtoul skips leading space. */
+      unsigned long lineno = strtoul(cp, &cpr, 10);
+      if (cp == cpr) {
+           VLerror(yylloc, "Invalid line number for `line directive.");
+           return;
+      }
+      lineno -= 1;
+      cp = cpr;
+
+       /* Skip the space between the line number and the file name. */
+      cpr += strspn(cp, " \t");
+      if (cp == cpr) {
+           VLerror(yylloc, "Invalid `line directive (missing space after "
+                           "line number).");
+           return;
+      }
+      cp = cpr;
+
+       /* Find the starting " and skip it. */
+      char*fn_start = strchr(cp, '"');
+      if (cp != fn_start) {
+           VLerror(yylloc, "Invalid `line directive (file name start).");
+           return;
+      }
+      fn_start += 1;
+
+       /* Find the last ". */
+      char*fn_end = strrchr(fn_start, '"');
+      if (!fn_end) {
+           VLerror(yylloc, "Invalid `line directive (file name end).");
+           return;
+      }
+
+       /* Skip the space after the file name. */
+      cp = fn_end + 1;
+      cpr = cp;
+      cpr += strspn(cp, " \t");
+      if (cp == cpr) {
+           VLerror(yylloc, "Invalid `line directive (missing space after "
+                           "file name).");
+           return;
+      }
+      cp = cpr;
+
+       /* Check that the level is correct, we do not need the level. */
+      if (strspn(cp, "012") != 1) {
+           VLerror(yylloc, "Invalid level for `line directive.");
+           return;
+      }
+      cp += 1;
+
+       /* Verify that only space and/or a single line comment is left. */
+      cp += strspn(cp, " \t");
+      if (strncmp(cp, "//", 2) != 0 &&
+          (size_t)(cp-yytext) != strlen(yytext)) {
+           VLerror(yylloc, "Invalid `line directive (extra garbage after "
+                           "level).");
+           return;
+      }
+
+       /* Copy the file name and assign it and the line number to yylloc. */
+      char*buf = new char[fn_end-fn_start+1];
+      strncpy(buf, fn_start, fn_end-fn_start);
+      buf[fn_end-fn_start] = 0;
+
+      yylloc.text = set_file_name(buf);
+      yylloc.first_line = lineno;
+}
+
+/*
+ * Reset all compiler directives. This will be called when a `resetall
+ * directive is encountered or when a new compilation unit is started.
+ */
+static void reset_all()
+{
+      pform_set_default_nettype(NetNet::WIRE, yylloc.text, yylloc.first_line);
+      in_celldefine = false;
+      uc_drive = UCD_NONE;
+      pform_set_timescale(def_ts_units, def_ts_prec, 0, 0);
+}
+
+extern FILE*vl_input;
+void reset_lexor()
+{
+      yyrestart(vl_input);
+      yylloc.first_line = 1;
+
+       /* Announce the first file name. */
+      yylloc.text = set_file_name(strdupnew(vl_file.c_str()));
+
+      if (separate_compilation) {
+           reset_all();
+           if (!keyword_mask_stack.empty()) {
+                 lexor_keyword_mask = keyword_mask_stack.back();
+                 keyword_mask_stack.clear();
+           }
+      }
+}
+
+/*
+ * Modern version of flex (>=2.5.9) can clean up the scanner data.
+ */
+void destroy_lexor()
+{
+# ifdef FLEX_SCANNER
+#   if YY_FLEX_MAJOR_VERSION >= 2 && YY_FLEX_MINOR_VERSION >= 5
+#     if YY_FLEX_MINOR_VERSION > 5 || defined(YY_FLEX_SUBMINOR_VERSION) && YY_FLEX_SUBMINOR_VERSION >= 9
+    yylex_destroy();
+#     endif
+#   endif
+# endif
+}
+"""
+
+def t_timescale_error(t):
+    print("%d: Timescale error '%s'" % (t.lexer.lineno, t.value[0]))
+    print(t.value)
+    raise RuntimeError
+
+"""
+def t_module_error(t):
+    print("%d: Module error '%s'" % (t.lexer.lineno, t.value[0]))
+    print(t.value)
+    raise RuntimeError
+"""
+
+def t_error(t):
+    print("%d: Illegal character '%s'" % (t.lexer.lineno, t.value[0]))
+    print(t.value)
+    t.lexer.skip(1)
+
+tokens = list(set(tokens))
+
+lex.lex()
+
+if __name__ == '__main__':
+    lex.runmain()
+
diff --git a/parse.py b/parse.py
new file mode 100644 (file)
index 0000000..e7b86cf
--- /dev/null
+++ b/parse.py
@@ -0,0 +1,1491 @@
+# %{
+# /*
+#  * Copyright (c) 1998-2017 Stephen Williams (steve@icarus.com)
+#  * Copyright CERN 2012-2013 / Stephen Williams (steve@icarus.com)
+#  *
+#  *    This source code is free software; you can redistribute it
+#  *    and/or modify it in source code form under the terms of the GNU
+#  *    General Public License as published by the Free Software
+#  *    Foundation; either version 2 of the License, or (at your option)
+#  *    any later version.
+#  *
+#  *    This program is distributed in the hope that it will be useful,
+#  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  *    GNU General Public License for more details.
+#  *
+#  *    You should have received a copy of the GNU General Public License
+#  *    along with this program; if not, write to the Free Software
+#  *    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#  */
+# 
+# # include "config.h"
+# 
+# # include  "parse_misc.h"
+# # include  "compiler.h"
+# # include  "pform.h"
+# # include  "Statement.h"
+# # include  "PSpec.h"
+# # include  <stack>
+# # include  <cstring>
+# # include  <sstream>
+# 
+# class PSpecPath;
+# 
+# extern void lex_end_table();
+# 
+# static list<pform_range_t>* param_active_range = 0;
+# static bool param_active_signed = false;
+# static ivl_variable_type_t param_active_type = IVL_VT_LOGIC;
+# 
+# /* Port declaration lists use this structure for context. */
+# static struct {
+#       NetNet::Type port_net_type;
+#       NetNet::PortType port_type;
+#       data_type_t* data_type;
+# } port_declaration_context = {NetNet::NONE, NetNet::NOT_A_PORT, 0};
+# 
+# /* Modport port declaration lists use this structure for context. */
+# enum modport_port_type_t { MP_NONE, MP_SIMPLE, MP_TF, MP_CLOCKING };
+# static struct {
+#       modport_port_type_t type;
+#       union {
+#          NetNet::PortType direction;
+#          bool is_import;
+#       };
+# } last_modport_port = { MP_NONE, {NetNet::NOT_A_PORT}};
+# 
+# /* The task and function rules need to briefly hold the pointer to the
+#    task/function that is currently in progress. */
+# static PTask* current_task = 0;
+# static PFunction* current_function = 0;
+# static stack<PBlock*> current_block_stack;
+# 
+# /* The variable declaration rules need to know if a lifetime has been
+#    specified. */
+# static LexicalScope::lifetime_t var_lifetime;
+# 
+# static pform_name_t* pform_create_this(void)
+# {
+#       name_component_t name (perm_string::literal("@"));
+#       pform_name_t*res = new pform_name_t;
+#       res->push_back(name);
+#       return res;
+# }
+# 
+# static pform_name_t* pform_create_super(void)
+# {
+#       name_component_t name (perm_string::literal("#"));
+#       pform_name_t*res = new pform_name_t;
+#       res->push_back(name);
+#       return res;
+# }
+# 
+# /* This is used to keep track of the extra arguments after the notifier
+#  * in the $setuphold and $recrem timing checks. This allows us to print
+#  * a warning message that the delayed signals will not be created. We
+#  * need to do this since not driving these signals creates real
+#  * simulation issues. */
+# static unsigned args_after_notifier;
+# 
+# /* The rules sometimes push attributes into a global context where
+#    sub-rules may grab them. This makes parser rules a little easier to
+#    write in some cases. */
+# static list<named_pexpr_t>*attributes_in_context = 0;
+# 
+# /* Later version of bison (including 1.35) will not compile in stack
+#    extension if the output is compiled with C++ and either the YYSTYPE
+#    or YYLTYPE are provided by the source code. However, I can get the
+#    old behavior back by defining these symbols. */
+# # define YYSTYPE_IS_TRIVIAL 1
+# # define YYLTYPE_IS_TRIVIAL 1
+# 
+# /* Recent version of bison expect that the user supply a
+#    YYLLOC_DEFAULT macro that makes up a yylloc value from existing
+#    values. I need to supply an explicit version to account for the
+#    text field, that otherwise won't be copied.
+# 
+#    The YYLLOC_DEFAULT blends the file range for the tokens of Rhs
+#    rule, which has N tokens.
+# */
+# # define YYLLOC_DEFAULT(Current, Rhs, N)  do {                               \
+#       if (N) {                                                               \
+#          (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;      \
+#          (Current).first_column = YYRHSLOC (Rhs, 1).first_column;    \
+#          (Current).last_line    = YYRHSLOC (Rhs, N).last_line;       \
+#          (Current).last_column  = YYRHSLOC (Rhs, N).last_column;     \
+#          (Current).text         = YYRHSLOC (Rhs, 1).text;            \
+#       } else {                                                               \
+#          (Current).first_line   = YYRHSLOC (Rhs, 0).last_line;       \
+#          (Current).first_column = YYRHSLOC (Rhs, 0).last_column;     \
+#          (Current).last_line    = YYRHSLOC (Rhs, 0).last_line;       \
+#          (Current).last_column  = YYRHSLOC (Rhs, 0).last_column;     \
+#          (Current).text         = YYRHSLOC (Rhs, 0).text;            \
+#       }                                                                      \
+#    } while (0)
+# 
+# /*
+#  * These are some common strength pairs that are used as defaults when
+#  * the user is not otherwise specific.
+#  */
+# static const struct str_pair_t pull_strength = { IVL_DR_PULL,  IVL_DR_PULL };
+# static const struct str_pair_t str_strength = { IVL_DR_STRONG, IVL_DR_STRONG };
+# 
+# static list<pform_port_t>* make_port_list(char*id, list<pform_range_t>*udims, PExpr*expr)
+# {
+#       list<pform_port_t>*tmp = new list<pform_port_t>;
+#       tmp->push_back(pform_port_t(lex_strings.make(id), udims, expr));
+#       delete[]id;
+#       return tmp;
+# }
+# static list<pform_port_t>* make_port_list(list<pform_port_t>*tmp,
+#                                           char*id, list<pform_range_t>*udims, PExpr*expr)
+# {
+#       tmp->push_back(pform_port_t(lex_strings.make(id), udims, expr));
+#       delete[]id;
+#       return tmp;
+# }
+# 
+# list<pform_range_t>* make_range_from_width(uint64_t wid)
+# {
+#       pform_range_t range;
+#       range.first  = new PENumber(new verinum(wid-1, integer_width));
+#       range.second = new PENumber(new verinum((uint64_t)0, integer_width));
+# 
+#       list<pform_range_t>*rlist = new list<pform_range_t>;
+#       rlist->push_back(range);
+#       return rlist;
+# }
+# 
+# static list<perm_string>* list_from_identifier(char*id)
+# {
+#       list<perm_string>*tmp = new list<perm_string>;
+#       tmp->push_back(lex_strings.make(id));
+#       delete[]id;
+#       return tmp;
+# }
+# 
+# static list<perm_string>* list_from_identifier(list<perm_string>*tmp, char*id)
+# {
+#       tmp->push_back(lex_strings.make(id));
+#       delete[]id;
+#       return tmp;
+# }
+# 
+# list<pform_range_t>* copy_range(list<pform_range_t>* orig)
+# {
+#       list<pform_range_t>*copy = 0;
+# 
+#       if (orig)
+#          copy = new list<pform_range_t> (*orig);
+# 
+#       return copy;
+# }
+# 
+# template <class T> void append(vector<T>&out, const vector<T>&in)
+# {
+#       for (size_t idx = 0 ; idx < in.size() ; idx += 1)
+#          out.push_back(in[idx]);
+# }
+# 
+# /*
+#  * Look at the list and pull null pointers off the end.
+#  */
+# static void strip_tail_items(list<PExpr*>*lst)
+# {
+#       while (! lst->empty()) {
+#          if (lst->back() != 0)
+#                return;
+#          lst->pop_back();
+#       }
+# }
+# 
+# /*
+#  * This is a shorthand for making a PECallFunction that takes a single
+#  * arg. This is used by some of the code that detects built-ins.
+#  */
+# static PECallFunction*make_call_function(perm_string tn, PExpr*arg)
+# {
+#       vector<PExpr*> parms(1);
+#       parms[0] = arg;
+#       PECallFunction*tmp = new PECallFunction(tn, parms);
+#       return tmp;
+# }
+# 
+# static PECallFunction*make_call_function(perm_string tn, PExpr*arg1, PExpr*arg2)
+# {
+#       vector<PExpr*> parms(2);
+#       parms[0] = arg1;
+#       parms[1] = arg2;
+#       PECallFunction*tmp = new PECallFunction(tn, parms);
+#       return tmp;
+# }
+# 
+# static list<named_pexpr_t>* make_named_numbers(perm_string name, long first, long last, PExpr*val =0)
+# {
+#       list<named_pexpr_t>*lst = new list<named_pexpr_t>;
+#       named_pexpr_t tmp;
+#      // We are counting up.
+#       if (first <= last) {
+#          for (long idx = first ; idx <= last ; idx += 1) {
+#                ostringstream buf;
+#                buf << name.str() << idx << ends;
+#                tmp.name = lex_strings.make(buf.str());
+#                tmp.parm = val;
+#                val = 0;
+#                lst->push_back(tmp);
+#          }
+#      // We are counting down.
+#       } else {
+#          for (long idx = first ; idx >= last ; idx -= 1) {
+#                ostringstream buf;
+#                buf << name.str() << idx << ends;
+#                tmp.name = lex_strings.make(buf.str());
+#                tmp.parm = val;
+#                val = 0;
+#                lst->push_back(tmp);
+#          }
+#       }
+#       return lst;
+# }
+# 
+# static list<named_pexpr_t>* make_named_number(perm_string name, PExpr*val =0)
+# {
+#       list<named_pexpr_t>*lst = new list<named_pexpr_t>;
+#       named_pexpr_t tmp;
+#       tmp.name = name;
+#       tmp.parm = val;
+#       lst->push_back(tmp);
+#       return lst;
+# }
+# 
+# static long check_enum_seq_value(const YYLTYPE&loc, verinum *arg, bool zero_ok)
+# {
+#       long value = 1;
+#      // We can never have an undefined value in an enumeration name
+#      // declaration sequence.
+#       if (! arg->is_defined()) {
+#          yyerror(loc, "error: undefined value used in enum name sequence.");
+#      // We can never have a negative value in an enumeration name
+#      // declaration sequence.
+#       } else if (arg->is_negative()) {
+#          yyerror(loc, "error: negative value used in enum name sequence.");
+#       } else {
+#          value = arg->as_ulong();
+#            // We cannot have a zero enumeration name declaration count.
+#          if (! zero_ok && (value == 0)) {
+#                yyerror(loc, "error: zero count used in enum name sequence.");
+#                value = 1;
+#          }
+#       }
+#       return value;
+# }
+# 
+# static void current_task_set_statement(const YYLTYPE&loc, vector<Statement*>*s)
+# {
+#       if (s == 0) {
+#            /* if the statement list is null, then the parser
+#               detected the case that there are no statements in the
+#               task. If this is SystemVerilog, handle it as an
+#               an empty block. */
+#          if (!gn_system_verilog()) {
+#                yyerror(loc, "error: Support for empty tasks requires SystemVerilog.");
+#          }
+#          PBlock*tmp = new PBlock(PBlock::BL_SEQ);
+#          FILE_NAME(tmp, loc);
+#          current_task->set_statement(tmp);
+#          return;
+#       }
+#       assert(s);
+# 
+#         /* An empty vector represents one or more null statements. Handle
+#            this as a simple null statement. */
+#       if (s->empty())
+#             return;
+# 
+#      /* A vector of 1 is handled as a simple statement. */
+#       if (s->size() == 1) {
+#          current_task->set_statement((*s)[0]);
+#          return;
+#       }
+# 
+#       if (!gn_system_verilog()) {
+#          yyerror(loc, "error: Task body with multiple statements requires SystemVerilog.");
+#       }
+# 
+#       PBlock*tmp = new PBlock(PBlock::BL_SEQ);
+#       FILE_NAME(tmp, loc);
+#       tmp->set_statement(*s);
+#       current_task->set_statement(tmp);
+# }
+# 
+# static void current_function_set_statement(const YYLTYPE&loc, vector<Statement*>*s)
+# {
+#       if (s == 0) {
+#            /* if the statement list is null, then the parser
+#               detected the case that there are no statements in the
+#               task. If this is SystemVerilog, handle it as an
+#               an empty block. */
+#          if (!gn_system_verilog()) {
+#                yyerror(loc, "error: Support for empty functions requires SystemVerilog.");
+#          }
+#          PBlock*tmp = new PBlock(PBlock::BL_SEQ);
+#          FILE_NAME(tmp, loc);
+#          current_function->set_statement(tmp);
+#          return;
+#       }
+#       assert(s);
+# 
+#         /* An empty vector represents one or more null statements. Handle
+#            this as a simple null statement. */
+#       if (s->empty())
+#             return;
+# 
+#      /* A vector of 1 is handled as a simple statement. */
+#       if (s->size() == 1) {
+#          current_function->set_statement((*s)[0]);
+#          return;
+#       }
+# 
+#       if (!gn_system_verilog()) {
+#          yyerror(loc, "error: Function body with multiple statements requires SystemVerilog.");
+#       }
+# 
+#       PBlock*tmp = new PBlock(PBlock::BL_SEQ);
+#       FILE_NAME(tmp, loc);
+#       tmp->set_statement(*s);
+#       current_function->set_statement(tmp);
+# }
+# 
+# %}
+('tokens = ', "['IDENTIFIER', 'SYSTEM_IDENTIFIER', 'STRING', 'TIME_LITERAL', 'TYPE_IDENTIFIER', 'PACKAGE_IDENTIFIER', 'DISCIPLINE_IDENTIFIER', 'PATHPULSE_IDENTIFIER', 'BASED_NUMBER', 'DEC_NUMBER', 'UNBASED_NUMBER', 'REALTIME', 'K_PLUS_EQ', 'K_MINUS_EQ', 'K_INCR', 'K_DECR', 'K_LE', 'K_GE', 'K_EG', 'K_EQ', 'K_NE', 'K_CEQ', 'K_CNE', 'K_WEQ', 'K_WNE', 'K_LP', 'K_LS', 'K_RS', 'K_RSS', 'K_SG', 'K_CONTRIBUTE', 'K_PO_POS', 'K_PO_NEG', 'K_POW', 'K_PSTAR', 'K_STARP', 'K_DOTSTAR', 'K_LOR', 'K_LAND', 'K_NAND', 'K_NOR', 'K_NXOR', 'K_TRIGGER', 'K_SCOPE_RES', 'K_edge_descriptor', 'K_always', 'K_and', 'K_assign', 'K_begin', 'K_buf', 'K_bufif0', 'K_bufif1', 'K_case', 'K_casex', 'K_casez', 'K_cmos', 'K_deassign', 'K_default', 'K_defparam', 'K_disable', 'K_edge', 'K_else', 'K_end', 'K_endcase', 'K_endfunction', 'K_endmodule', 'K_endprimitive', 'K_endspecify', 'K_endtable', 'K_endtask', 'K_event', 'K_for', 'K_force', 'K_forever', 'K_fork', 'K_function', 'K_highz0', 'K_highz1', 'K_if', 'K_ifnone', 'K_initial', 'K_inout', 'K_input', 'K_integer', 'K_join', 'K_large', 'K_macromodule', 'K_medium', 'K_module', 'K_nand', 'K_negedge', 'K_nmos', 'K_nor', 'K_not', 'K_notif0', 'K_notif1', 'K_or', 'K_output', 'K_parameter', 'K_pmos', 'K_posedge', 'K_primitive', 'K_pull0', 'K_pull1', 'K_pulldown', 'K_pullup', 'K_rcmos', 'K_real', 'K_realtime', 'K_reg', 'K_release', 'K_repeat', 'K_rnmos', 'K_rpmos', 'K_rtran', 'K_rtranif0', 'K_rtranif1', 'K_scalared', 'K_small', 'K_specify', 'K_specparam', 'K_strong0', 'K_strong1', 'K_supply0', 'K_supply1', 'K_table', 'K_task', 'K_time', 'K_tran', 'K_tranif0', 'K_tranif1', 'K_tri', 'K_tri0', 'K_tri1', 'K_triand', 'K_trior', 'K_trireg', 'K_vectored', 'K_wait', 'K_wand', 'K_weak0', 'K_weak1', 'K_while', 'K_wire', 'K_wor', 'K_xnor', 'K_xor', 'K_Shold', 'K_Snochange', 'K_Speriod', 'K_Srecovery', 'K_Ssetup', 'K_Ssetuphold', 'K_Sskew', 'K_Swidth', 'KK_attribute', 'K_bool', 'K_logic', 'K_automatic', 'K_endgenerate', 'K_generate', 'K_genvar', 'K_localparam', 'K_noshowcancelled', 'K_pulsestyle_onevent', 'K_pulsestyle_ondetect', 'K_showcancelled', 'K_signed', 'K_unsigned', 'K_Sfullskew', 'K_Srecrem', 'K_Sremoval', 'K_Stimeskew', 'K_cell', 'K_config', 'K_design', 'K_endconfig', 'K_incdir', 'K_include', 'K_instance', 'K_liblist', 'K_library', 'K_use', 'K_wone', 'K_uwire', 'K_alias', 'K_always_comb', 'K_always_ff', 'K_always_latch', 'K_assert', 'K_assume', 'K_before', 'K_bind', 'K_bins', 'K_binsof', 'K_bit', 'K_break', 'K_byte', 'K_chandle', 'K_class', 'K_clocking', 'K_const', 'K_constraint', 'K_context', 'K_continue', 'K_cover', 'K_covergroup', 'K_coverpoint', 'K_cross', 'K_dist', 'K_do', 'K_endclass', 'K_endclocking', 'K_endgroup', 'K_endinterface', 'K_endpackage', 'K_endprogram', 'K_endproperty', 'K_endsequence', 'K_enum', 'K_expect', 'K_export', 'K_extends', 'K_extern', 'K_final', 'K_first_match', 'K_foreach', 'K_forkjoin', 'K_iff', 'K_ignore_bins', 'K_illegal_bins', 'K_import', 'K_inside', 'K_int', 'K_interface', 'K_intersect', 'K_join_any', 'K_join_none', 'K_local', 'K_longint', 'K_matches', 'K_modport', 'K_new', 'K_null', 'K_package', 'K_packed', 'K_priority', 'K_program', 'K_property', 'K_protected', 'K_pure', 'K_rand', 'K_randc', 'K_randcase', 'K_randsequence', 'K_ref', 'K_return', 'K_sequence', 'K_shortint', 'K_shortreal', 'K_solve', 'K_static', 'K_string', 'K_struct', 'K_super', 'K_tagged', 'K_this', 'K_throughout', 'K_timeprecision', 'K_timeunit', 'K_type', 'K_typedef', 'K_union', 'K_unique', 'K_var', 'K_virtual', 'K_void', 'K_wait_order', 'K_wildcard', 'K_with', 'K_within', 'K_accept_on', 'K_checker', 'K_endchecker', 'K_eventually', 'K_global', 'K_implies', 'K_let', 'K_nexttime', 'K_reject_on', 'K_restrict', 'K_s_always', 'K_s_eventually', 'K_s_nexttime', 'K_s_until', 'K_s_until_with', 'K_strong', 'K_sync_accept_on', 'K_sync_reject_on', 'K_unique0', 'K_until', 'K_until_with', 'K_untyped', 'K_weak', 'K_implements', 'K_interconnect', 'K_nettype', 'K_soft', 'K_above', 'K_abs', 'K_absdelay', 'K_abstol', 'K_access', 'K_acos', 'K_acosh', 'K_ac_stim', 'K_aliasparam', 'K_analog', 'K_analysis', 'K_asin', 'K_asinh', 'K_atan', 'K_atan2', 'K_atanh', 'K_branch', 'K_ceil', 'K_connect', 'K_connectmodule', 'K_connectrules', 'K_continuous', 'K_cos', 'K_cosh', 'K_ddt', 'K_ddt_nature', 'K_ddx', 'K_discipline', 'K_discrete', 'K_domain', 'K_driver_update', 'K_endconnectrules', 'K_enddiscipline', 'K_endnature', 'K_endparamset', 'K_exclude', 'K_exp', 'K_final_step', 'K_flicker_noise', 'K_floor', 'K_flow', 'K_from', 'K_ground', 'K_hypot', 'K_idt', 'K_idtmod', 'K_idt_nature', 'K_inf', 'K_initial_step', 'K_laplace_nd', 'K_laplace_np', 'K_laplace_zd', 'K_laplace_zp', 'K_last_crossing', 'K_limexp', 'K_ln', 'K_log', 'K_max', 'K_merged', 'K_min', 'K_nature', 'K_net_resolution', 'K_noise_table', 'K_paramset', 'K_potential', 'K_pow', 'K_resolveto', 'K_sin', 'K_sinh', 'K_slew', 'K_split', 'K_sqrt', 'K_tan', 'K_tanh', 'K_timer', 'K_transition', 'K_units', 'K_white_noise', 'K_wreal', 'K_zi_nd', 'K_zi_np', 'K_zi_zd', 'K_zi_zp', 'K_TAND', 'K_PLUS_EQ', 'K_MINUS_EQ', 'K_MUL_EQ', 'K_DIV_EQ', 'K_MOD_EQ', 'K_AND_EQ', 'K_OR_EQ', 'K_XOR_EQ', 'K_LS_EQ', 'K_RS_EQ', 'K_RSS_EQ', 'K_inside', 'K_LOR', 'K_LAND', 'K_NXOR', 'K_NOR', 'K_NAND', 'K_EQ', 'K_NE', 'K_CEQ', 'K_CNE', 'K_WEQ', 'K_WNE', 'K_GE', 'K_LE', 'K_LS', 'K_RS', 'K_RSS', 'K_POW', 'UNARY_PREC', 'less_than_K_else', 'K_else', 'K_exclude', 'no_timeunits_declaration', 'one_timeunits_declaration', 'K_timeunit', 'K_timeprecision']")
+()
+('precedence = ', '[(\'right\', \'K_PLUS_EQ\', \'K_MINUS_EQ\', \'K_MUL_EQ\', \'K_DIV_EQ\', \'K_MOD_EQ\', \'K_AND_EQ\', \'K_OR_EQ\'), (\'right\', \'K_XOR_EQ\', \'K_LS_EQ\', \'K_RS_EQ\', \'K_RSS_EQ\'), (\'right\', "\'?\'", "\':\'", \'K_inside\'), (\'left\', \'K_LOR\'), (\'left\', \'K_LAND\'), (\'left\', "\'|\'"), (\'left\', "\'^\'", \'K_NXOR\', \'K_NOR\'), (\'left\', "\'&\'", \'K_NAND\'), (\'left\', \'K_EQ\', \'K_NE\', \'K_CEQ\', \'K_CNE\', \'K_WEQ\', \'K_WNE\'), (\'left\', \'K_GE\', \'K_LE\', "\'<\'", "\'>\'"), (\'left\', \'K_LS\', \'K_RS\', \'K_RSS\'), (\'left\', "\'+\'", "\'-\'"), (\'left\', "\'*\'", "\'/\'", "\'%\'"), (\'left\', \'K_POW\'), (\'left\', \'UNARY_PREC\'), (\'nonassoc\', \'less_than_K_else\'), (\'nonassoc\', \'K_else\'), (\'nonassoc\', "\'(\'"), (\'nonassoc\', \'K_exclude\'), (\'nonassoc\', \'no_timeunits_declaration\'), (\'nonassoc\', \'one_timeunits_declaration\'), (\'nonassoc\', \'K_timeunit\', \'K_timeprecision\')]')
+()
+# -------------- RULES ----------------
+()
+def p_source_text_1(p):
+    '''source_text : timeunits_declaration_opt _embed0_source_text description_list '''
+    print(p)
+()
+def p_source_text_2(p):
+    '''source_text :  '''
+    print(p)
+()
+def p__embed0_source_text(p):
+    '''_embed0_source_text : '''
+    # { pform_set_scope_timescale(yyloc); }
+()
+def p_assertion_item_1(p):
+    '''assertion_item : concurrent_assertion_item '''
+    print(p)
+()
+def p_assignment_pattern_1(p):
+    '''assignment_pattern : K_LP expression_list_proper '}' '''
+    print(p)
+    # { PEAssignPattern*tmp = new PEAssignPattern(*$2);
+    #  FILE_NAME(tmp, @1);
+    #  delete $2;
+    #  $$ = tmp;
+    #       }
+()
+def p_assignment_pattern_2(p):
+    '''assignment_pattern : K_LP '}' '''
+    print(p)
+    # { PEAssignPattern*tmp = new PEAssignPattern;
+    #  FILE_NAME(tmp, @1);
+    #  $$ = tmp;
+    #       }
+()
+def p_block_identifier_opt_1(p):
+    '''block_identifier_opt : IDENTIFIER ':' '''
+    print(p)
+()
+def p_block_identifier_opt_2(p):
+    '''block_identifier_opt :  '''
+    print(p)
+()
+def p_class_declaration_1(p):
+    '''class_declaration : K_virtual_opt K_class lifetime_opt class_identifier class_declaration_extends_opt ';' _embed0_class_declaration class_items_opt K_endclass _embed1_class_declaration class_declaration_endlabel_opt '''
+    print(p)
+    # { // Wrap up the class.
+    #  if ($11 && $4 && $4->name != $11) {
+    #        yyerror(@11, "error: Class end label doesn't match class name.");
+    #        delete[]$11;
+    #  }
+    #       }
+()
+def p__embed0_class_declaration(p):
+    '''_embed0_class_declaration : '''
+    # { pform_start_class_declaration(@2, $4, $5.type, $5.exprs, $3); }
+()
+def p__embed1_class_declaration(p):
+    '''_embed1_class_declaration : '''
+    # { // Process a class.
+    #  pform_end_class_declaration(@9);
+    #       }
+()
+def p_class_constraint_1(p):
+    '''class_constraint : constraint_prototype '''
+    print(p)
+()
+def p_class_constraint_2(p):
+    '''class_constraint : constraint_declaration '''
+    print(p)
+()
+def p_class_identifier_1(p):
+    '''class_identifier : IDENTIFIER '''
+    print(p)
+    # { // Create a synthetic typedef for the class name so that the
+    #  // lexor detects the name as a type.
+    #  perm_string name = lex_strings.make($1);
+    #  class_type_t*tmp = new class_type_t(name);
+    #  FILE_NAME(tmp, @1);
+    #  pform_set_typedef(name, tmp, NULL);
+    #  delete[]$1;
+    #  $$ = tmp;
+    #       }
+()
+def p_class_identifier_2(p):
+    '''class_identifier : TYPE_IDENTIFIER '''
+    print(p)
+    # { class_type_t*tmp = dynamic_cast<class_type_t*>($1.type);
+    #  if (tmp == 0) {
+    #        yyerror(@1, "Type name \"%s\"is not a predeclared class name.", $1.text);
+    #  }
+    #  delete[]$1.text;
+    #  $$ = tmp;
+    #       }
+()
+def p_class_declaration_endlabel_opt_1(p):
+    '''class_declaration_endlabel_opt : ':' TYPE_IDENTIFIER '''
+    print(p)
+    # { class_type_t*tmp = dynamic_cast<class_type_t*> ($2.type);
+    #  if (tmp == 0) {
+    #        yyerror(@2, "error: class declaration endlabel \"%s\" is not a class name\n", $2.text);
+    #        $$ = 0;
+    #  } else {
+    #        $$ = strdupnew(tmp->name.str());
+    #  }
+    #  delete[]$2.text;
+    #       }
+()
+def p_class_declaration_endlabel_opt_2(p):
+    '''class_declaration_endlabel_opt : ':' IDENTIFIER '''
+    print(p)
+    # { $$ = $2; }
+()
+def p_class_declaration_endlabel_opt_3(p):
+    '''class_declaration_endlabel_opt :  '''
+    print(p)
+    # { $$ = 0; }
+()
+def p_class_declaration_extends_opt_1(p):
+    '''class_declaration_extends_opt : K_extends TYPE_IDENTIFIER '''
+    print(p)
+    # { $$.type = $2.type;
+    #  $$.exprs= 0;
+    #  delete[]$2.text;
+    #       }
+()
+def p_class_declaration_extends_opt_2(p):
+    '''class_declaration_extends_opt : K_extends TYPE_IDENTIFIER '(' expression_list_with_nuls ')' '''
+    print(p)
+    # { $$.type  = $2.type;
+    #  $$.exprs = $4;
+    #  delete[]$2.text;
+    #       }
+()
+def p_class_declaration_extends_opt_3(p):
+    '''class_declaration_extends_opt :  '''
+    print(p)
+    # { $$.type = 0; $$.exprs = 0; }
+()
+def p_class_items_opt_1(p):
+    '''class_items_opt : class_items '''
+    print(p)
+()
+def p_class_items_opt_2(p):
+    '''class_items_opt :  '''
+    print(p)
+()
+def p_class_items_1(p):
+    '''class_items : class_items class_item '''
+    print(p)
+()
+def p_class_items_2(p):
+    '''class_items : class_item '''
+    print(p)
+()
+def p_class_item_1(p):
+    '''class_item : method_qualifier_opt K_function K_new _embed0_class_item '(' tf_port_list_opt ')' ';' function_item_list_opt statement_or_null_list_opt K_endfunction endnew_opt '''
+    print(p)
+    # { current_function->set_ports($6);
+    #  pform_set_constructor_return(current_function);
+    #  pform_set_this_class(@3, current_function);
+    #  current_function_set_statement(@3, $10);
+    #  pform_pop_scope();
+    #  current_function = 0;
+    #       }
+()
+def p_class_item_2(p):
+    '''class_item : property_qualifier_opt data_type list_of_variable_decl_assignments ';' '''
+    print(p)
+    # { pform_class_property(@2, $1, $2, $3); }
+()
+def p_class_item_3(p):
+    '''class_item : K_const class_item_qualifier_opt data_type list_of_variable_decl_assignments ';' '''
+    print(p)
+    # { pform_class_property(@1, $2 | property_qualifier_t::make_const(), $3, $4); }
+()
+def p_class_item_4(p):
+    '''class_item : method_qualifier_opt task_declaration '''
+    print(p)
+    # { /* The task_declaration rule puts this into the class */ }
+()
+def p_class_item_5(p):
+    '''class_item : method_qualifier_opt function_declaration '''
+    print(p)
+    # { /* The function_declaration rule puts this into the class */ }
+()
+def p_class_item_6(p):
+    '''class_item : K_extern method_qualifier_opt K_function K_new ';' '''
+    print(p)
+    # { yyerror(@1, "sorry: External constructors are not yet supported."); }
+()
+def p_class_item_7(p):
+    '''class_item : K_extern method_qualifier_opt K_function K_new '(' tf_port_list_opt ')' ';' '''
+    print(p)
+    # { yyerror(@1, "sorry: External constructors are not yet supported."); }
+()
+def p_class_item_8(p):
+    '''class_item : K_extern method_qualifier_opt K_function data_type_or_implicit_or_void IDENTIFIER ';' '''
+    print(p)
+    # { yyerror(@1, "sorry: External methods are not yet supported.");
+    #  delete[] $5;
+    #       }
+()
+def p_class_item_9(p):
+    '''class_item : K_extern method_qualifier_opt K_function data_type_or_implicit_or_void IDENTIFIER '(' tf_port_list_opt ')' ';' '''
+    print(p)
+    # { yyerror(@1, "sorry: External methods are not yet supported.");
+    #  delete[] $5;
+    #       }
+()
+def p_class_item_10(p):
+    '''class_item : K_extern method_qualifier_opt K_task IDENTIFIER ';' '''
+    print(p)
+    # { yyerror(@1, "sorry: External methods are not yet supported.");
+    #  delete[] $4;
+    #       }
+()
+def p_class_item_11(p):
+    '''class_item : K_extern method_qualifier_opt K_task IDENTIFIER '(' tf_port_list_opt ')' ';' '''
+    print(p)
+    # { yyerror(@1, "sorry: External methods are not yet supported.");
+    #  delete[] $4;
+    #       }
+()
+def p_class_item_12(p):
+    '''class_item : class_constraint '''
+    print(p)
+()
+def p_class_item_13(p):
+    '''class_item : property_qualifier_opt data_type error ';' '''
+    print(p)
+    # { yyerror(@3, "error: Errors in variable names after data type.");
+    #  yyerrok;
+    #       }
+()
+def p_class_item_14(p):
+    '''class_item : property_qualifier_opt IDENTIFIER error ';' '''
+    print(p)
+    # { yyerror(@3, "error: %s doesn't name a type.", $2);
+    #  yyerrok;
+    #       }
+()
+def p_class_item_15(p):
+    '''class_item : method_qualifier_opt K_function K_new error K_endfunction endnew_opt '''
+    print(p)
+    # { yyerror(@1, "error: I give up on this class constructor declaration.");
+    #  yyerrok;
+    #       }
+()
+def p_class_item_16(p):
+    '''class_item : error ';' '''
+    print(p)
+    # { yyerror(@2, "error: invalid class item.");
+    #  yyerrok;
+    #       }
+()
+def p__embed0_class_item(p):
+    '''_embed0_class_item : '''
+    # { assert(current_function==0);
+    #  current_function = pform_push_constructor_scope(@3);
+    #       }
+()
+def p_class_item_qualifier_1(p):
+    '''class_item_qualifier : K_static '''
+    print(p)
+    # { $$ = property_qualifier_t::make_static(); }
+()
+def p_class_item_qualifier_2(p):
+    '''class_item_qualifier : K_protected '''
+    print(p)
+    # { $$ = property_qualifier_t::make_protected(); }
+()
+def p_class_item_qualifier_3(p):
+    '''class_item_qualifier : K_local '''
+    print(p)
+    # { $$ = property_qualifier_t::make_local(); }
+()
+def p_class_item_qualifier_list_1(p):
+    '''class_item_qualifier_list : class_item_qualifier_list class_item_qualifier '''
+    print(p)
+    # { $$ = $1 | $2; }
+()
+def p_class_item_qualifier_list_2(p):
+    '''class_item_qualifier_list : class_item_qualifier '''
+    print(p)
+    # { $$ = $1; }
+()
+def p_class_item_qualifier_opt_1(p):
+    '''class_item_qualifier_opt : class_item_qualifier_list '''
+    print(p)
+    # { $$ = $1; }
+()
+def p_class_item_qualifier_opt_2(p):
+    '''class_item_qualifier_opt :  '''
+    print(p)
+    # { $$ = property_qualifier_t::make_none(); }
+()
+def p_class_new_1(p):
+    '''class_new : K_new '(' expression_list_with_nuls ')' '''
+    print(p)
+    # { list<PExpr*>*expr_list = $3;
+    #  strip_tail_items(expr_list);
+    #  PENewClass*tmp = new PENewClass(*expr_list);
+    #  FILE_NAME(tmp, @1);
+    #  delete $3;
+    #  $$ = tmp;
+    #       }
+()
+def p_class_new_2(p):
+    '''class_new : K_new hierarchy_identifier '''
+    print(p)
+    # { PEIdent*tmpi = new PEIdent(*$2);
+    #  FILE_NAME(tmpi, @2);
+    #  PENewCopy*tmp = new PENewCopy(tmpi);
+    #  FILE_NAME(tmp, @1);
+    #  delete $2;
+    #  $$ = tmp;
+    #       }
+()
+def p_class_new_3(p):
+    '''class_new : K_new '''
+    print(p)
+    # { PENewClass*tmp = new PENewClass;
+    #  FILE_NAME(tmp, @1);
+    #  $$ = tmp;
+    #       }
+()
+def p_concurrent_assertion_item_1(p):
+    '''concurrent_assertion_item : block_identifier_opt K_assert K_property '(' property_spec ')' statement_or_null '''
+    print(p)
+    # { /* */
+    #  if (gn_assertions_flag) {
+    #        yyerror(@2, "sorry: concurrent_assertion_item not supported."
+    #                " Try -gno-assertion to turn this message off.");
+    #  }
+    #       }
+()
+def p_concurrent_assertion_item_2(p):
+    '''concurrent_assertion_item : block_identifier_opt K_assert K_property '(' error ')' statement_or_null '''
+    print(p)
+    # { yyerrok;
+    #         yyerror(@2, "error: Error in property_spec of concurrent assertion item.");
+    #       }
+()
+def p_constraint_block_item_1(p):
+    '''constraint_block_item : constraint_expression '''
+    print(p)
+()
+def p_constraint_block_item_list_1(p):
+    '''constraint_block_item_list : constraint_block_item_list constraint_block_item '''
+    print(p)
+()
+def p_constraint_block_item_list_2(p):
+    '''constraint_block_item_list : constraint_block_item '''
+    print(p)
+()
+def p_constraint_block_item_list_opt_1(p):
+    '''constraint_block_item_list_opt :  '''
+    print(p)
+()
+def p_constraint_block_item_list_opt_2(p):
+    '''constraint_block_item_list_opt : constraint_block_item_list '''
+    print(p)
+()
+def p_constraint_declaration_1(p):
+    '''constraint_declaration : K_static_opt K_constraint IDENTIFIER '{' constraint_block_item_list_opt '}' '''
+    print(p)
+    # { yyerror(@2, "sorry: Constraint declarations not supported."); }
+()
+def p_constraint_declaration_2(p):
+    '''constraint_declaration : K_static_opt K_constraint IDENTIFIER '{' error '}' '''
+    print(p)
+    # { yyerror(@4, "error: Errors in the constraint block item list."); }
+()
+def p_constraint_expression_1(p):
+    '''constraint_expression : expression ';' '''
+    print(p)
+()
+def p_constraint_expression_2(p):
+    '''constraint_expression : expression K_dist '{' '}' ';' '''
+    print(p)
+()
+def p_constraint_expression_3(p):
+    '''constraint_expression : expression K_TRIGGER constraint_set '''
+    print(p)
+()
+def p_constraint_expression_4(p):
+    '''constraint_expression : K_if '(' expression ')' constraint_set %prec less_than_K_else '''
+    print(p)
+()
+def p_constraint_expression_5(p):
+    '''constraint_expression : K_if '(' expression ')' constraint_set K_else constraint_set '''
+    print(p)
+()
+def p_constraint_expression_6(p):
+    '''constraint_expression : K_foreach '(' IDENTIFIER '[' loop_variables ']' ')' constraint_set '''
+    print(p)
+()
+def p_constraint_expression_list_1(p):
+    '''constraint_expression_list : constraint_expression_list constraint_expression '''
+    print(p)
+()
+def p_constraint_expression_list_2(p):
+    '''constraint_expression_list : constraint_expression '''
+    print(p)
+()
+def p_constraint_prototype_1(p):
+    '''constraint_prototype : K_static_opt K_constraint IDENTIFIER ';' '''
+    print(p)
+    # { yyerror(@2, "sorry: Constraint prototypes not supported."); }
+()
+def p_constraint_set_1(p):
+    '''constraint_set : constraint_expression '''
+    print(p)
+()
+def p_constraint_set_2(p):
+    '''constraint_set : '{' constraint_expression_list '}' '''
+    print(p)
+()
+def p_data_declaration_1(p):
+    '''data_declaration : attribute_list_opt data_type_or_implicit list_of_variable_decl_assignments ';' '''
+    print(p)
+    # { data_type_t*data_type = $2;
+    #  if (data_type == 0) {
+    #        data_type = new vector_type_t(IVL_VT_LOGIC, false, 0);
+    #        FILE_NAME(data_type, @2);
+    #  }
+    #  pform_makewire(@2, 0, str_strength, $3, NetNet::IMPLICIT_REG, data_type);
+    #       }
+()
+def p_data_type_1(p):
+    '''data_type : integer_vector_type unsigned_signed_opt dimensions_opt '''
+    print(p)
+    # { ivl_variable_type_t use_vtype = $1;
+    #  bool reg_flag = false;
+    #  if (use_vtype == IVL_VT_NO_TYPE) {
+    #        use_vtype = IVL_VT_LOGIC;
+    #        reg_flag = true;
+    #  }
+    #  vector_type_t*tmp = new vector_type_t(use_vtype, $2, $3);
+    #  tmp->reg_flag = reg_flag;
+    #  FILE_NAME(tmp, @1);
+    #  $$ = tmp;
+    #       }
+()
+def p_data_type_2(p):
+    '''data_type : non_integer_type '''
+    print(p)
+    # { real_type_t*tmp = new real_type_t($1);
+    #  FILE_NAME(tmp, @1);
+    #  $$ = tmp;
+    #       }
+()
+def p_data_type_3(p):
+    '''data_type : struct_data_type '''
+    print(p)
+    # { if (!$1->packed_flag) {
+    #        yyerror(@1, "sorry: Unpacked structs not supported.");
+    #  }
+    #  $$ = $1;
+    #       }
+()
+def p_data_type_4(p):
+    '''data_type : enum_data_type '''
+    print(p)
+    # { $$ = $1; }
+()
+def p_data_type_5(p):
+    '''data_type : atom2_type signed_unsigned_opt '''
+    print(p)
+    # { atom2_type_t*tmp = new atom2_type_t($1, $2);
+    #  FILE_NAME(tmp, @1);
+    #  $$ = tmp;
+    #       }
+()
+def p_data_type_6(p):
+    '''data_type : K_integer signed_unsigned_opt '''
+    print(p)
+    # { list<pform_range_t>*pd = make_range_from_width(integer_width);
+    #  vector_type_t*tmp = new vector_type_t(IVL_VT_LOGIC, $2, pd);
+    #  tmp->reg_flag = true;
+    #  tmp->integer_flag = true;
+    #  $$ = tmp;
+    #       }
+()
+def p_data_type_7(p):
+    '''data_type : K_time '''
+    print(p)
+    # { list<pform_range_t>*pd = make_range_from_width(64);
+    #  vector_type_t*tmp = new vector_type_t(IVL_VT_LOGIC, false, pd);
+    #  tmp->reg_flag = !gn_system_verilog();
+    #  $$ = tmp;
+    #       }
+()
+def p_data_type_8(p):
+    '''data_type : TYPE_IDENTIFIER dimensions_opt '''
+    print(p)
+    # { if ($2) {
+    #        parray_type_t*tmp = new parray_type_t($1.type, $2);
+    #        FILE_NAME(tmp, @1);
+    #        $$ = tmp;
+    #  } else $$ = $1.type;
+    #  delete[]$1.text;
+    #       }
+()
+def p_data_type_9(p):
+    '''data_type : PACKAGE_IDENTIFIER K_SCOPE_RES _embed0_data_type TYPE_IDENTIFIER '''
+    print(p)
+    # { lex_in_package_scope(0);
+    #  $$ = $4.type;
+    #  delete[]$4.text;
+    #       }
+()
+def p_data_type_10(p):
+    '''data_type : K_string '''
+    print(p)
+    # { string_type_t*tmp = new string_type_t;
+    #  FILE_NAME(tmp, @1);
+    #  $$ = tmp;
+    #       }
+()
+def p__embed0_data_type(p):
+    '''_embed0_data_type : '''
+    # { lex_in_package_scope($1); }
+()
+def p_data_type_or_implicit_1(p):
+    '''data_type_or_implicit : data_type '''
+    print(p)
+    # { $$ = $1; }
+()
+def p_data_type_or_implicit_2(p):
+    '''data_type_or_implicit : signing dimensions_opt '''
+    print(p)
+    # { vector_type_t*tmp = new vector_type_t(IVL_VT_LOGIC, $1, $2);
+    #  tmp->implicit_flag = true;
+    #  FILE_NAME(tmp, @1);
+    #  $$ = tmp;
+    #       }
+()
+def p_data_type_or_implicit_3(p):
+    '''data_type_or_implicit : dimensions '''
+    print(p)
+    # { vector_type_t*tmp = new vector_type_t(IVL_VT_LOGIC, false, $1);
+    #  tmp->implicit_flag = true;
+    #  FILE_NAME(tmp, @1);
+    #  $$ = tmp;
+    #       }
+()
+def p_data_type_or_implicit_4(p):
+    '''data_type_or_implicit :  '''
+    print(p)
+    # { $$ = 0; }
+()
+def p_data_type_or_implicit_or_void_1(p):
+    '''data_type_or_implicit_or_void : data_type_or_implicit '''
+    print(p)
+    # { $$ = $1; }
+()
+def p_data_type_or_implicit_or_void_2(p):
+    '''data_type_or_implicit_or_void : K_void '''
+    print(p)
+    # { void_type_t*tmp = new void_type_t;
+    #  FILE_NAME(tmp, @1);
+    #  $$ = tmp;
+    #       }
+()
+def p_description_1(p):
+    '''description : module '''
+    print(p)
+()
+def p_description_2(p):
+    '''description : udp_primitive '''
+    print(p)
+()
+def p_description_3(p):
+    '''description : config_declaration '''
+    print(p)
+()
+def p_description_4(p):
+    '''description : nature_declaration '''
+    print(p)
+()
+def p_description_5(p):
+    '''description : package_declaration '''
+    print(p)
+()
+def p_description_6(p):
+    '''description : discipline_declaration '''
+    print(p)
+()
+def p_description_7(p):
+    '''description : package_item '''
+    print(p)
+()
+def p_description_8(p):
+    '''description : KK_attribute '(' IDENTIFIER ',' STRING ',' STRING ')' '''
+    print(p)
+    # { perm_string tmp3 = lex_strings.make($3);
+    #  pform_set_type_attrib(tmp3, $5, $7);
+    #  delete[] $3;
+    #  delete[] $5;
+    #       }
+()
+def p_description_list_1(p):
+    '''description_list : description '''
+    print(p)
+()
+def p_description_list_2(p):
+    '''description_list : description_list description '''
+    print(p)
+()
+def p_endnew_opt_1(p):
+    '''endnew_opt : ':' K_new '''
+    print(p)
+()
+def p_endnew_opt_2(p):
+    '''endnew_opt :  '''
+    print(p)
+()
+def p_dynamic_array_new_1(p):
+    '''dynamic_array_new : K_new '[' expression ']' '''
+    print(p)
+    # { $$ = new PENewArray($3, 0);
+    #  FILE_NAME($$, @1);
+    #       }
+()
+def p_dynamic_array_new_2(p):
+    '''dynamic_array_new : K_new '[' expression ']' '(' expression ')' '''
+    print(p)
+    # { $$ = new PENewArray($3, $6);
+    #  FILE_NAME($$, @1);
+    #       }
+()
+def p_for_step_1(p):
+    '''for_step : lpvalue '=' expression '''
+    print(p)
+    # { PAssign*tmp = new PAssign($1,$3);
+    #  FILE_NAME(tmp, @1);
+    #  $$ = tmp;
+    #       }
+()
+def p_for_step_2(p):
+    '''for_step : inc_or_dec_expression '''
+    print(p)
+    # { $$ = pform_compressed_assign_from_inc_dec(@1, $1); }
+()
+def p_for_step_3(p):
+    '''for_step : compressed_statement '''
+    print(p)
+    # { $$ = $1; }
+()
+def p_function_declaration_1(p):
+    '''function_declaration : K_function lifetime_opt data_type_or_implicit_or_void IDENTIFIER ';' _embed0_function_declaration function_item_list statement_or_null_list_opt K_endfunction _embed1_function_declaration endlabel_opt '''
+    print(p)
+    # { // Last step: check any closing name.
+    #  if ($11) {
+    #        if (strcmp($4,$11) != 0) {
+    #              yyerror(@11, "error: End label doesn't match "
+    #                           "function name");
+    #        }
+    #        if (! gn_system_verilog()) {
+    #              yyerror(@11, "error: Function end labels require "
+    #                           "SystemVerilog.");
+    #        }
+    #        delete[]$11;
+    #  }
+    #  delete[]$4;
+    #       }
+()
+def p_function_declaration_2(p):
+    '''function_declaration : K_function lifetime_opt data_type_or_implicit_or_void IDENTIFIER _embed2_function_declaration '(' tf_port_list_opt ')' ';' block_item_decls_opt statement_or_null_list_opt K_endfunction _embed3_function_declaration endlabel_opt '''
+    print(p)
+    # { // Last step: check any closing name.
+    #  if ($14) {
+    #        if (strcmp($4,$14) != 0) {
+    #              yyerror(@14, "error: End label doesn't match "
+    #                           "function name");
+    #        }
+    #        if (! gn_system_verilog()) {
+    #              yyerror(@14, "error: Function end labels require "
+    #                           "SystemVerilog.");
+    #        }
+    #        delete[]$14;
+    #  }
+    #  delete[]$4;
+    #       }
+()
+def p_function_declaration_3(p):
+    '''function_declaration : K_function lifetime_opt data_type_or_implicit_or_void IDENTIFIER error K_endfunction _embed4_function_declaration endlabel_opt '''
+    print(p)
+    # { // Last step: check any closing name.
+    #  if ($8) {
+    #        if (strcmp($4,$8) != 0) {
+    #              yyerror(@8, "error: End label doesn't match function name");
+    #        }
+    #        if (! gn_system_verilog()) {
+    #              yyerror(@8, "error: Function end labels require "
+    #                           "SystemVerilog.");
+    #        }
+    #        delete[]$8;
+    #  }
+    #  delete[]$4;
+    #       }
+()
+def p__embed0_function_declaration(p):
+    '''_embed0_function_declaration : '''
+    # { assert(current_function == 0);
+    #  current_function = pform_push_function_scope(@1, $4, $2);
+    #       }
+()
+def p__embed1_function_declaration(p):
+    '''_embed1_function_declaration : '''
+    # { current_function->set_ports($7);
+    #  current_function->set_return($3);
+    #  current_function_set_statement($8? @8 : @4, $8);
+    #  pform_set_this_class(@4, current_function);
+    #  pform_pop_scope();
+    #  current_function = 0;
+    #       }
+()
+def p__embed2_function_declaration(p):
+    '''_embed2_function_declaration : '''
+    # { assert(current_function == 0);
+    #  current_function = pform_push_function_scope(@1, $4, $2);
+    #       }
+()
+def p__embed3_function_declaration(p):
+    '''_embed3_function_declaration : '''
+    # { current_function->set_ports($7);
+    #  current_function->set_return($3);
+    #  current_function_set_statement($11? @11 : @4, $11);
+    #  pform_set_this_class(@4, current_function);
+    #  pform_pop_scope();
+    #  current_function = 0;
+    #  if ($7==0 && !gn_system_verilog()) {
+    #        yyerror(@4, "error: Empty parenthesis syntax requires SystemVerilog.");
+    #  }
+    #       }
+()
+def p__embed4_function_declaration(p):
+    '''_embed4_function_declaration : '''
+    # { /* */
+    #  if (current_function) {
+    #        pform_pop_scope();
+    #        current_function = 0;
+    #  }
+    #  assert(current_function == 0);
+    #  yyerror(@1, "error: Syntax error defining function.");
+    #  yyerrok;
+    #       }
+()
+def p_import_export_1(p):
+    '''import_export : K_import '''
+    print(p)
+    # { $$ = true; }
+()
+def p_import_export_2(p):
+    '''import_export : K_export '''
+    print(p)
+    # { $$ = false; }
+()
+def p_implicit_class_handle_1(p):
+    '''implicit_class_handle : K_this '''
+    print(p)
+    # { $$ = pform_create_this(); }
+()
+def p_implicit_class_handle_2(p):
+    '''implicit_class_handle : K_super '''
+    print(p)
+    # { $$ = pform_create_super(); }
+()
+def p_inc_or_dec_expression_1(p):
+    '''inc_or_dec_expression : K_INCR lpvalue %prec UNARY_PREC '''
+    print(p)
+    # { PEUnary*tmp = new PEUnary('I', $2);
+    #  FILE_NAME(tmp, @2);
+    #  $$ = tmp;
+    #       }
+()
+def p_inc_or_dec_expression_2(p):
+    '''inc_or_dec_expression : lpvalue K_INCR %prec UNARY_PREC '''
+    print(p)
+    # { PEUnary*tmp = new PEUnary('i', $1);
+    #  FILE_NAME(tmp, @1);
+    #  $$ = tmp;
+    #       }
+()
+def p_inc_or_dec_expression_3(p):
+    '''inc_or_dec_expression : K_DECR lpvalue %prec UNARY_PREC '''
+    print(p)
+    # { PEUnary*tmp = new PEUnary('D', $2);
+    #  FILE_NAME(tmp, @2);
+    #  $$ = tmp;
+    #       }
+()
+def p_inc_or_dec_expression_4(p):
+    '''inc_or_dec_expression : lpvalue K_DECR %prec UNARY_PREC '''
+    print(p)
+    # { PEUnary*tmp = new PEUnary('d', $1);
+    #  FILE_NAME(tmp, @1);
+    #  $$ = tmp;
+    #       }
+()
+def p_inside_expression_1(p):
+    '''inside_expression : expression K_inside '{' open_range_list '}' '''
+    print(p)
+    # { yyerror(@2, "sorry: \"inside\" expressions not supported yet.");
+    #  $$ = 0;
+    #       }
+()
+def p_integer_vector_type_1(p):
+    '''integer_vector_type : K_reg '''
+    print(p)
+    # { $$ = IVL_VT_NO_TYPE; }
+()
+def p_integer_vector_type_2(p):
+    '''integer_vector_type : K_bit '''
+    print(p)
+    # { $$ = IVL_VT_BOOL; }
+()
+def p_integer_vector_type_3(p):
+    '''integer_vector_type : K_logic '''
+    print(p)
+    # { $$ = IVL_VT_LOGIC; }
+()
+def p_integer_vector_type_4(p):
+    '''integer_vector_type : K_bool '''
+    print(p)
+    # { $$ = IVL_VT_BOOL; }
+()
+def p_join_keyword_1(p):
+    '''join_keyword : K_join '''
+    print(p)
+    # { $$ = PBlock::BL_PAR; }
+()
+def p_join_keyword_2(p):
+    '''join_keyword : K_join_none '''
+    print(p)
+    # { $$ = PBlock::BL_JOIN_NONE; }
+()
+def p_join_keyword_3(p):
+    '''join_keyword : K_join_any '''
+    print(p)
+    # { $$ = PBlock::BL_JOIN_ANY; }
+()
+def p_jump_statement_1(p):
+    '''jump_statement : K_break ';' '''
+    print(p)
+    # { yyerror(@1, "sorry: break statements not supported.");
+    #  $$ = 0;
+    #       }
+()
+def p_jump_statement_2(p):
+    '''jump_statement : K_return ';' '''
+    print(p)
+    # { PReturn*tmp = new PReturn(0);
+    #  FILE_NAME(tmp, @1);
+    #  $$ = tmp;
+    #       }
+()
+def p_jump_statement_3(p):
+    '''jump_statement : K_return expression ';' '''
+    print(p)
+    # { PReturn*tmp = new PReturn($2);
+    #  FILE_NAME(tmp, @1);
+    #  $$ = tmp;
+    #       }
+()
+def p_lifetime_1(p):
+    '''lifetime : K_automatic '''
+    print(p)
+    # { $$ = LexicalScope::AUTOMATIC; }
+()
+def p_lifetime_2(p):
+    '''lifetime : K_static '''
+    print(p)
+    # { $$ = LexicalScope::STATIC; }
+()
+def p_lifetime_opt_1(p):
+    '''lifetime_opt : lifetime '''
+    print(p)
+    # { $$ = $1; }
+()
+def p_lifetime_opt_2(p):
+    '''lifetime_opt :  '''
+    print(p)
+    # { $$ = LexicalScope::INHERITED; }
+()
+def p_loop_statement_1(p):
+    '''loop_statement : K_for '(' lpvalue '=' expression ';' expression ';' for_step ')' statement_or_null '''
+    print(p)
+    # { PForStatement*tmp = new PForStatement($3, $5, $7, $9, $11);
+    #  FILE_NAME(tmp, @1);
+    #  $$ = tmp;
+    #       }
+()
+def p_loop_statement_2(p):
+    '''loop_statement : K_for '(' data_type IDENTIFIER '=' expression ';' expression ';' for_step ')' _embed0_loop_statement statement_or_null '''
+    print(p)
+    # { pform_name_t tmp_hident;
+    #  tmp_hident.push_back(name_component_t(lex_strings.make($4)));
+    # 
+    #  PEIdent*tmp_ident = pform_new_ident(tmp_hident);
+    #  FILE_NAME(tmp_ident, @4);
+    # 
+    #  PForStatement*tmp_for = new PForStatement(tmp_ident, $6, $8, $10, $13);
+    #  FILE_NAME(tmp_for, @1);
+    # 
+    #  pform_pop_scope();
+    #  vector<Statement*>tmp_for_list (1);
+    #  tmp_for_list[0] = tmp_for;
+    #  PBlock*tmp_blk = current_block_stack.top();
+    #  current_block_stack.pop();
+    #  tmp_blk->set_statement(tmp_for_list);
+    #  $$ = tmp_blk;
+    #  delete[]$4;
+    #       }
+()
+def p_loop_statement_3(p):
+    '''loop_statement : K_forever statement_or_null '''
+    print(p)
+    # { PForever*tmp = new PForever($2);
+    #  FILE_NAME(tmp, @1);
+    #  $$ = tmp;
+    #       }
+()
+def p_loop_statement_4(p):
+    '''loop_statement : K_repeat '(' expression ')' statement_or_null '''
+    print(p)
+    # { PRepeat*tmp = new PRepeat($3, $5);
+    #  FILE_NAME(tmp, @1);
+    #  $$ = tmp;
+    #       }
+()
+def p_loop_statement_5(p):
+    '''loop_statement : K_while '(' expression ')' statement_or_null '''
+    print(p)
+    # { PWhile*tmp = new PWhile($3, $5);
+    #  FILE_NAME(tmp, @1);
+    #  $$ = tmp;
+    #       }
+()
+def p_loop_statement_6(p):
+    '''loop_statement : K_do statement_or_null K_while '(' expression ')' ';' '''
+    print(p)
+    # { PDoWhile*tmp = new PDoWhile($5, $2);
+    #  FILE_NAME(tmp, @1);
+    #  $$ = tmp;
+    #       }
+()
+def p_loop_statement_7(p):
+    '''loop_statement : K_foreach '(' IDENTIFIER '[' loop_variables ']' ')' _embed1_loop_statement statement_or_null '''
+    print(p)
+    # { PForeach*tmp_for = pform_make_foreach(@1, $3, $5, $9);
+    # 
+    #  pform_pop_scope();
+    #  vector<Statement*>tmp_for_list(1);
+    #  tmp_for_list[0] = tmp_for;
+    #  PBlock*tmp_blk = current_block_stack.top();
+    #  current_block_stack.pop();
+    #  tmp_blk->set_statement(tmp_for_list);
+    #  $$ = tmp_blk;
+    #       }
+()
+def p_loop_statement_8(p):
+    '''loop_statement : K_for '(' lpvalue '=' expression ';' expression ';' error ')' statement_or_null '''
+    print(p)
+    # { $$ = 0;
+    #  yyerror(@1, "error: Error in for loop step assignment.");
+    #       }
+()
+def p_loop_statement_9(p):
+    '''loop_statement : K_for '(' lpvalue '=' expression ';' error ';' for_step ')' statement_or_null '''
+    print(p)
+    # { $$ = 0;
+    #  yyerror(@1, "error: Error in for loop condition expression.");
+    #       }
+()
+def p_loop_statement_10(p):
+    '''loop_statement : K_for '(' error ')' statement_or_null '''
+    print(p)
+    # { $$ = 0;
+    #  yyerror(@1, "error: Incomprehensible for loop.");
+    #       }
+()
+def p_loop_statement_11(p):
+    '''loop_statement : K_while '(' error ')' statement_or_null '''
+    print(p)
+    # { $$ = 0;
+    #  yyerror(@1, "error: Error in while loop condition.");
+    #       }
+()
+def p_loop_statement_12(p):
+    '''loop_statement : K_do statement_or_null K_while '(' error ')' ';' '''
+    print(p)
+    # { $$ = 0;
+    #  yyerror(@1, "error: Error in do/while loop condition.");
+    #       }
+()
+def p_loop_statement_13(p):
+    '''loop_statement : K_foreach '(' IDENTIFIER '[' error ']' ')' statement_or_null '''
+    print(p)
+    # { $$ = 0;
+    #         yyerror(@4, "error: Errors in foreach loop variables list.");
+    #       }
+()
+def p__embed0_loop_statement(p):
+    '''_embed0_loop_statement : '''
+    # { static unsigned for_counter = 0;
+    #  char for_block_name [64];
+    #  snprintf(for_block_name, sizeof for_block_name, "$ivl_for_loop%u", for_counter);
+    #  for_counter += 1;
+    #  PBlock*tmp = pform_push_block_scope(for_block_name, PBlock::BL_SEQ);
+    #  FILE_NAME(tmp, @1);
+    #  current_block_stack.push(tmp);
+    # 
+    #  list<decl_assignment_t*>assign_list;
+    #  decl_assignment_t*tmp_assign = new decl_assignment_t;
+    #  tmp_assign->name = lex_strings.make($4);
+    #  assign_list.push_back(tmp_assign);
+    #  pform_makewire(@4, 0, str_strength, &assign_list, NetNet::REG, $3);
+    #       }
+()
+def p__embed1_loop_statement(p):
+    '''_embed1_loop_statement : '''
+    # { static unsigned foreach_counter = 0;
+    #  char for_block_name[64];
+    #  snprintf(for_block_name, sizeof for_block_name, "$ivl_foreach%u", foreach_counter);
+    #  foreach_counter += 1;
+    # 
+    #  PBlock*tmp = pform_push_block_scope(for_block_name, PBlock::BL_SEQ);
+    #  FILE_NAME(tmp, @1);
+    #  current_block_stack.push(tmp);
+    # 
+    #  pform_make_foreach_declarations(@1, $5);
+    #       }
+()
+def p_list_of_variable_decl_assignments_1(p):
+    '''list_of_variable_decl_assignments : variable_decl_assignment '''
+    print(p)
+    # { list<decl_assignment_t*>*tmp = new list<decl_assignment_t*>;
+    #  tmp->push_back($1);
+    #  $$ = tmp;
+    #       }
+()
+def p_list_of_variable_decl_assignments_2(p):
+    '''list_of_variable_decl_assignments : list_of_variable_decl_assignments ',' variable_decl_assignment '''
+    print(p)
+    # { list<decl_assignment_t*>*tmp = $1;
+    #  tmp->push_back($3);
+    #  $$ = tmp;
+    #       }
+()
+def p_variable_decl_assignment_1(p):
+    '''variable_decl_assignment : IDENTIFIER dimensions_opt '''
+    print(p)
+    # { decl_assignment_t*tmp = new decl_assignment_t;
+    #  tmp->name = lex_strings.make($1);
+    #  if ($2) {
+    #        tmp->index = *$2;
+    #        delete $2;
+    #  }
+    #  delete[]$1;
+    #  $$ = tmp;
+    #       }
+()
+def p_variable_decl_assignment_2(p):
+    '''variable_decl_assignment : IDENTIFIER '=' expression '''
+    print(p)
+    # { decl_assignment_t*tmp = new decl_assignment_t;
+    #  tmp->name = lex_strings.make($1);
+    #  tmp->expr .reset($3);
+    #  delete[]$1;
+    #  $$ = tmp;
+    #       }
+()
+def p_variable_decl_assignment_3(p):
+    '''variable_decl_assignment : IDENTIFIER '=' K_new '(' ')' '''
+    print(p)
+    # { decl_assignment_t*tmp = new decl_assignment_t;
+    #  tmp->name = lex_strings.make($1);
+    #  PENewClass*expr = new PENewClass;
+    #  FILE_NAME(expr, @3);
+    #  tmp->expr .reset(expr);
+    #  delete[]$1;
+    #  $$ = tmp;
+    #       }
+()
+def p_loop_variables_1(p):
+    '''loop_variables : loop_variables ',' IDENTIFIER '''
+    print(p)
+    # { list<perm_string>*tmp = $1;
+    #  tmp->push_back(lex_strings.make($3));
+    #  delete[]$3;
+    #  $$ = tmp;
+    #       }
+()
+def p_loop_variables_2(p):
+    '''loop_variables : IDENTIFIER '''
+    print(p)
+    # { list<perm_string>*tmp = new list<perm_string>;
+    #  tmp->push_back(lex_strings.make($1));
+    #  delete[]$1;
+    #  $$ = tmp;
+    #       }
+()
+def p_method_qualifier_1(p):
+    '''method_qualifier : K_virtual '''
+    print(p)
+()
+def p_method_qualifier_2(p):
+    '''method_qualifier : class_item_qualifier '''
+    print(p)
+()
+def p_method_qualifier_opt_1(p):
+    '''method_qualifier_opt : method_qualifier '''
+    print(p)
+()
+def p_method_qualifier_opt_2(p):
+    '''method_qualifier_opt :  '''
+    print(p)
+()
+
+if __name__ == '__main__':
+    from ply import *
+    yacc.yacc()
+
diff --git a/parse.y b/parse.y
new file mode 100644 (file)
index 0000000..3533f79
--- /dev/null
+++ b/parse.y
@@ -0,0 +1,6993 @@
+
+%{
+/*
+ * Copyright (c) 1998-2017 Stephen Williams (steve@icarus.com)
+ * Copyright CERN 2012-2013 / Stephen Williams (steve@icarus.com)
+ *
+ *    This source code is free software; you can redistribute it
+ *    and/or modify it in source code form under the terms of the GNU
+ *    General Public License as published by the Free Software
+ *    Foundation; either version 2 of the License, or (at your option)
+ *    any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program; if not, write to the Free Software
+ *    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+# include "config.h"
+
+# include  "parse_misc.h"
+# include  "compiler.h"
+# include  "pform.h"
+# include  "Statement.h"
+# include  "PSpec.h"
+# include  <stack>
+# include  <cstring>
+# include  <sstream>
+
+class PSpecPath;
+
+extern void lex_end_table();
+
+static list<pform_range_t>* param_active_range = 0;
+static bool param_active_signed = false;
+static ivl_variable_type_t param_active_type = IVL_VT_LOGIC;
+
+/* Port declaration lists use this structure for context. */
+static struct {
+      NetNet::Type port_net_type;
+      NetNet::PortType port_type;
+      data_type_t* data_type;
+} port_declaration_context = {NetNet::NONE, NetNet::NOT_A_PORT, 0};
+
+/* Modport port declaration lists use this structure for context. */
+enum modport_port_type_t { MP_NONE, MP_SIMPLE, MP_TF, MP_CLOCKING };
+static struct {
+      modport_port_type_t type;
+      union {
+           NetNet::PortType direction;
+           bool is_import;
+      };
+} last_modport_port = { MP_NONE, {NetNet::NOT_A_PORT}};
+
+/* The task and function rules need to briefly hold the pointer to the
+   task/function that is currently in progress. */
+static PTask* current_task = 0;
+static PFunction* current_function = 0;
+static stack<PBlock*> current_block_stack;
+
+/* The variable declaration rules need to know if a lifetime has been
+   specified. */
+static LexicalScope::lifetime_t var_lifetime;
+
+static pform_name_t* pform_create_this(void)
+{
+      name_component_t name (perm_string::literal("@"));
+      pform_name_t*res = new pform_name_t;
+      res->push_back(name);
+      return res;
+}
+
+static pform_name_t* pform_create_super(void)
+{
+      name_component_t name (perm_string::literal("#"));
+      pform_name_t*res = new pform_name_t;
+      res->push_back(name);
+      return res;
+}
+
+/* This is used to keep track of the extra arguments after the notifier
+ * in the $setuphold and $recrem timing checks. This allows us to print
+ * a warning message that the delayed signals will not be created. We
+ * need to do this since not driving these signals creates real
+ * simulation issues. */
+static unsigned args_after_notifier;
+
+/* The rules sometimes push attributes into a global context where
+   sub-rules may grab them. This makes parser rules a little easier to
+   write in some cases. */
+static list<named_pexpr_t>*attributes_in_context = 0;
+
+/* Later version of bison (including 1.35) will not compile in stack
+   extension if the output is compiled with C++ and either the YYSTYPE
+   or YYLTYPE are provided by the source code. However, I can get the
+   old behavior back by defining these symbols. */
+# define YYSTYPE_IS_TRIVIAL 1
+# define YYLTYPE_IS_TRIVIAL 1
+
+/* Recent version of bison expect that the user supply a
+   YYLLOC_DEFAULT macro that makes up a yylloc value from existing
+   values. I need to supply an explicit version to account for the
+   text field, that otherwise won't be copied.
+
+   The YYLLOC_DEFAULT blends the file range for the tokens of Rhs
+   rule, which has N tokens.
+*/
+# define YYLLOC_DEFAULT(Current, Rhs, N)  do {                         \
+      if (N) {                                                         \
+           (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;      \
+           (Current).first_column = YYRHSLOC (Rhs, 1).first_column;    \
+           (Current).last_line    = YYRHSLOC (Rhs, N).last_line;       \
+           (Current).last_column  = YYRHSLOC (Rhs, N).last_column;     \
+           (Current).text         = YYRHSLOC (Rhs, 1).text;            \
+      } else {                                                         \
+           (Current).first_line   = YYRHSLOC (Rhs, 0).last_line;       \
+           (Current).first_column = YYRHSLOC (Rhs, 0).last_column;     \
+           (Current).last_line    = YYRHSLOC (Rhs, 0).last_line;       \
+           (Current).last_column  = YYRHSLOC (Rhs, 0).last_column;     \
+           (Current).text         = YYRHSLOC (Rhs, 0).text;            \
+      }                                                                        \
+   } while (0)
+
+/*
+ * These are some common strength pairs that are used as defaults when
+ * the user is not otherwise specific.
+ */
+static const struct str_pair_t pull_strength = { IVL_DR_PULL,  IVL_DR_PULL };
+static const struct str_pair_t str_strength = { IVL_DR_STRONG, IVL_DR_STRONG };
+
+static list<pform_port_t>* make_port_list(char*id, list<pform_range_t>*udims, PExpr*expr)
+{
+      list<pform_port_t>*tmp = new list<pform_port_t>;
+      tmp->push_back(pform_port_t(lex_strings.make(id), udims, expr));
+      delete[]id;
+      return tmp;
+}
+static list<pform_port_t>* make_port_list(list<pform_port_t>*tmp,
+                                          char*id, list<pform_range_t>*udims, PExpr*expr)
+{
+      tmp->push_back(pform_port_t(lex_strings.make(id), udims, expr));
+      delete[]id;
+      return tmp;
+}
+
+list<pform_range_t>* make_range_from_width(uint64_t wid)
+{
+      pform_range_t range;
+      range.first  = new PENumber(new verinum(wid-1, integer_width));
+      range.second = new PENumber(new verinum((uint64_t)0, integer_width));
+
+      list<pform_range_t>*rlist = new list<pform_range_t>;
+      rlist->push_back(range);
+      return rlist;
+}
+
+static list<perm_string>* list_from_identifier(char*id)
+{
+      list<perm_string>*tmp = new list<perm_string>;
+      tmp->push_back(lex_strings.make(id));
+      delete[]id;
+      return tmp;
+}
+
+static list<perm_string>* list_from_identifier(list<perm_string>*tmp, char*id)
+{
+      tmp->push_back(lex_strings.make(id));
+      delete[]id;
+      return tmp;
+}
+
+list<pform_range_t>* copy_range(list<pform_range_t>* orig)
+{
+      list<pform_range_t>*copy = 0;
+
+      if (orig)
+           copy = new list<pform_range_t> (*orig);
+
+      return copy;
+}
+
+template <class T> void append(vector<T>&out, const vector<T>&in)
+{
+      for (size_t idx = 0 ; idx < in.size() ; idx += 1)
+           out.push_back(in[idx]);
+}
+
+/*
+ * Look at the list and pull null pointers off the end.
+ */
+static void strip_tail_items(list<PExpr*>*lst)
+{
+      while (! lst->empty()) {
+           if (lst->back() != 0)
+                 return;
+           lst->pop_back();
+      }
+}
+
+/*
+ * This is a shorthand for making a PECallFunction that takes a single
+ * arg. This is used by some of the code that detects built-ins.
+ */
+static PECallFunction*make_call_function(perm_string tn, PExpr*arg)
+{
+      vector<PExpr*> parms(1);
+      parms[0] = arg;
+      PECallFunction*tmp = new PECallFunction(tn, parms);
+      return tmp;
+}
+
+static PECallFunction*make_call_function(perm_string tn, PExpr*arg1, PExpr*arg2)
+{
+      vector<PExpr*> parms(2);
+      parms[0] = arg1;
+      parms[1] = arg2;
+      PECallFunction*tmp = new PECallFunction(tn, parms);
+      return tmp;
+}
+
+static list<named_pexpr_t>* make_named_numbers(perm_string name, long first, long last, PExpr*val =0)
+{
+      list<named_pexpr_t>*lst = new list<named_pexpr_t>;
+      named_pexpr_t tmp;
+       // We are counting up.
+      if (first <= last) {
+           for (long idx = first ; idx <= last ; idx += 1) {
+                 ostringstream buf;
+                 buf << name.str() << idx << ends;
+                 tmp.name = lex_strings.make(buf.str());
+                 tmp.parm = val;
+                 val = 0;
+                 lst->push_back(tmp);
+           }
+       // We are counting down.
+      } else {
+           for (long idx = first ; idx >= last ; idx -= 1) {
+                 ostringstream buf;
+                 buf << name.str() << idx << ends;
+                 tmp.name = lex_strings.make(buf.str());
+                 tmp.parm = val;
+                 val = 0;
+                 lst->push_back(tmp);
+           }
+      }
+      return lst;
+}
+
+static list<named_pexpr_t>* make_named_number(perm_string name, PExpr*val =0)
+{
+      list<named_pexpr_t>*lst = new list<named_pexpr_t>;
+      named_pexpr_t tmp;
+      tmp.name = name;
+      tmp.parm = val;
+      lst->push_back(tmp);
+      return lst;
+}
+
+static long check_enum_seq_value(const YYLTYPE&loc, verinum *arg, bool zero_ok)
+{
+      long value = 1;
+       // We can never have an undefined value in an enumeration name
+       // declaration sequence.
+      if (! arg->is_defined()) {
+           yyerror(loc, "error: undefined value used in enum name sequence.");
+       // We can never have a negative value in an enumeration name
+       // declaration sequence.
+      } else if (arg->is_negative()) {
+           yyerror(loc, "error: negative value used in enum name sequence.");
+      } else {
+           value = arg->as_ulong();
+             // We cannot have a zero enumeration name declaration count.
+           if (! zero_ok && (value == 0)) {
+                 yyerror(loc, "error: zero count used in enum name sequence.");
+                 value = 1;
+           }
+      }
+      return value;
+}
+
+static void current_task_set_statement(const YYLTYPE&loc, vector<Statement*>*s)
+{
+      if (s == 0) {
+             /* if the statement list is null, then the parser
+                detected the case that there are no statements in the
+                task. If this is SystemVerilog, handle it as an
+                an empty block. */
+           if (!gn_system_verilog()) {
+                 yyerror(loc, "error: Support for empty tasks requires SystemVerilog.");
+           }
+           PBlock*tmp = new PBlock(PBlock::BL_SEQ);
+           FILE_NAME(tmp, loc);
+           current_task->set_statement(tmp);
+           return;
+      }
+      assert(s);
+
+        /* An empty vector represents one or more null statements. Handle
+           this as a simple null statement. */
+      if (s->empty())
+            return;
+
+       /* A vector of 1 is handled as a simple statement. */
+      if (s->size() == 1) {
+           current_task->set_statement((*s)[0]);
+           return;
+      }
+
+      if (!gn_system_verilog()) {
+           yyerror(loc, "error: Task body with multiple statements requires SystemVerilog.");
+      }
+
+      PBlock*tmp = new PBlock(PBlock::BL_SEQ);
+      FILE_NAME(tmp, loc);
+      tmp->set_statement(*s);
+      current_task->set_statement(tmp);
+}
+
+static void current_function_set_statement(const YYLTYPE&loc, vector<Statement*>*s)
+{
+      if (s == 0) {
+             /* if the statement list is null, then the parser
+                detected the case that there are no statements in the
+                task. If this is SystemVerilog, handle it as an
+                an empty block. */
+           if (!gn_system_verilog()) {
+                 yyerror(loc, "error: Support for empty functions requires SystemVerilog.");
+           }
+           PBlock*tmp = new PBlock(PBlock::BL_SEQ);
+           FILE_NAME(tmp, loc);
+           current_function->set_statement(tmp);
+           return;
+      }
+      assert(s);
+
+        /* An empty vector represents one or more null statements. Handle
+           this as a simple null statement. */
+      if (s->empty())
+            return;
+
+       /* A vector of 1 is handled as a simple statement. */
+      if (s->size() == 1) {
+           current_function->set_statement((*s)[0]);
+           return;
+      }
+
+      if (!gn_system_verilog()) {
+           yyerror(loc, "error: Function body with multiple statements requires SystemVerilog.");
+      }
+
+      PBlock*tmp = new PBlock(PBlock::BL_SEQ);
+      FILE_NAME(tmp, loc);
+      tmp->set_statement(*s);
+      current_function->set_statement(tmp);
+}
+
+%}
+
+%union {
+      bool flag;
+
+      char letter;
+      int  int_val;
+
+       /* text items are C strings allocated by the lexor using
+          strdup. They can be put into lists with the texts type. */
+      char*text;
+      list<perm_string>*perm_strings;
+
+      list<pform_port_t>*port_list;
+
+      vector<pform_tf_port_t>* tf_ports;
+
+      pform_name_t*pform_name;
+
+      ivl_discipline_t discipline;
+
+      hname_t*hier;
+
+      list<string>*strings;
+
+      struct str_pair_t drive;
+
+      PCase::Item*citem;
+      svector<PCase::Item*>*citems;
+
+      lgate*gate;
+      svector<lgate>*gates;
+
+      Module::port_t *mport;
+      LexicalScope::range_t* value_range;
+      vector<Module::port_t*>*mports;
+
+      named_number_t* named_number;
+      list<named_number_t>* named_numbers;
+
+      named_pexpr_t*named_pexpr;
+      list<named_pexpr_t>*named_pexprs;
+      struct parmvalue_t*parmvalue;
+      list<pform_range_t>*ranges;
+
+      PExpr*expr;
+      list<PExpr*>*exprs;
+
+      svector<PEEvent*>*event_expr;
+
+      NetNet::Type nettype;
+      PGBuiltin::Type gatetype;
+      NetNet::PortType porttype;
+      ivl_variable_type_t vartype;
+      PBlock::BL_TYPE join_keyword;
+
+      PWire*wire;
+      vector<PWire*>*wires;
+
+      PEventStatement*event_statement;
+      Statement*statement;
+      vector<Statement*>*statement_list;
+
+      net_decl_assign_t*net_decl_assign;
+      enum_type_t*enum_type;
+
+      decl_assignment_t*decl_assignment;
+      list<decl_assignment_t*>*decl_assignments;
+
+      struct_member_t*struct_member;
+      list<struct_member_t*>*struct_members;
+      struct_type_t*struct_type;
+
+      data_type_t*data_type;
+      class_type_t*class_type;
+      real_type_t::type_t real_type;
+      property_qualifier_t property_qualifier;
+      PPackage*package;
+
+      struct {
+           char*text;
+           data_type_t*type;
+      } type_identifier;
+
+      struct {
+           data_type_t*type;
+           list<PExpr*>*exprs;
+      } class_declaration_extends;
+
+      verinum* number;
+
+      verireal* realtime;
+
+      PSpecPath* specpath;
+      list<index_component_t> *dimensions;
+
+      LexicalScope::lifetime_t lifetime;
+};
+
+%token <text>      IDENTIFIER SYSTEM_IDENTIFIER STRING TIME_LITERAL
+%token <type_identifier> TYPE_IDENTIFIER
+%token <package>   PACKAGE_IDENTIFIER
+%token <discipline> DISCIPLINE_IDENTIFIER
+%token <text>   PATHPULSE_IDENTIFIER
+%token <number> BASED_NUMBER DEC_NUMBER UNBASED_NUMBER
+%token <realtime> REALTIME
+%token K_PLUS_EQ K_MINUS_EQ K_INCR K_DECR
+%token K_LE K_GE K_EG K_EQ K_NE K_CEQ K_CNE K_WEQ K_WNE K_LP K_LS K_RS K_RSS K_SG
+ /* K_CONTRIBUTE is <+, the contribution assign. */
+%token K_CONTRIBUTE
+%token K_PO_POS K_PO_NEG K_POW
+%token K_PSTAR K_STARP K_DOTSTAR
+%token K_LOR K_LAND K_NAND K_NOR K_NXOR K_TRIGGER
+%token K_SCOPE_RES
+%token K_edge_descriptor
+
+ /* The base tokens from 1364-1995. */
+%token K_always K_and K_assign K_begin K_buf K_bufif0 K_bufif1 K_case
+%token K_casex K_casez K_cmos K_deassign K_default K_defparam K_disable
+%token K_edge K_else K_end K_endcase K_endfunction K_endmodule
+%token K_endprimitive K_endspecify K_endtable K_endtask K_event K_for
+%token K_force K_forever K_fork K_function K_highz0 K_highz1 K_if
+%token K_ifnone K_initial K_inout K_input K_integer K_join K_large
+%token K_macromodule K_medium K_module K_nand K_negedge K_nmos K_nor
+%token K_not K_notif0 K_notif1 K_or K_output K_parameter K_pmos K_posedge
+%token K_primitive K_pull0 K_pull1 K_pulldown K_pullup K_rcmos K_real
+%token K_realtime K_reg K_release K_repeat K_rnmos K_rpmos K_rtran
+%token K_rtranif0 K_rtranif1 K_scalared K_small K_specify K_specparam
+%token K_strong0 K_strong1 K_supply0 K_supply1 K_table K_task K_time
+%token K_tran K_tranif0 K_tranif1 K_tri K_tri0 K_tri1 K_triand K_trior
+%token K_trireg K_vectored K_wait K_wand K_weak0 K_weak1 K_while K_wire
+%token K_wor K_xnor K_xor
+
+%token K_Shold K_Snochange K_Speriod K_Srecovery K_Ssetup K_Ssetuphold
+%token K_Sskew K_Swidth
+
+ /* Icarus specific tokens. */
+%token KK_attribute K_bool K_logic
+
+ /* The new tokens from 1364-2001. */
+%token K_automatic K_endgenerate K_generate K_genvar K_localparam
+%token K_noshowcancelled K_pulsestyle_onevent K_pulsestyle_ondetect
+%token K_showcancelled K_signed K_unsigned
+
+%token K_Sfullskew K_Srecrem K_Sremoval K_Stimeskew
+
+ /* The 1364-2001 configuration tokens. */
+%token K_cell K_config K_design K_endconfig K_incdir K_include K_instance
+%token K_liblist K_library K_use
+
+ /* The new tokens from 1364-2005. */
+%token K_wone K_uwire
+
+ /* The new tokens from 1800-2005. */
+%token K_alias K_always_comb K_always_ff K_always_latch K_assert
+%token K_assume K_before K_bind K_bins K_binsof K_bit K_break K_byte
+%token K_chandle K_class K_clocking K_const K_constraint K_context
+%token K_continue K_cover K_covergroup K_coverpoint K_cross K_dist K_do
+%token K_endclass K_endclocking K_endgroup K_endinterface K_endpackage
+%token K_endprogram K_endproperty K_endsequence K_enum K_expect K_export
+%token K_extends K_extern K_final K_first_match K_foreach K_forkjoin
+%token K_iff K_ignore_bins K_illegal_bins K_import K_inside K_int
+ /* Icarus already has defined "logic" above! */
+%token K_interface K_intersect K_join_any K_join_none K_local
+%token K_longint K_matches K_modport K_new K_null K_package K_packed
+%token K_priority K_program K_property K_protected K_pure K_rand K_randc
+%token K_randcase K_randsequence K_ref K_return K_sequence K_shortint
+%token K_shortreal K_solve K_static K_string K_struct K_super
+%token K_tagged K_this K_throughout K_timeprecision K_timeunit K_type
+%token K_typedef K_union K_unique K_var K_virtual K_void K_wait_order
+%token K_wildcard K_with K_within
+
+ /* The new tokens from 1800-2009. */
+%token K_accept_on K_checker K_endchecker K_eventually K_global K_implies
+%token K_let K_nexttime K_reject_on K_restrict K_s_always K_s_eventually
+%token K_s_nexttime K_s_until K_s_until_with K_strong K_sync_accept_on
+%token K_sync_reject_on K_unique0 K_until K_until_with K_untyped K_weak
+
+ /* The new tokens from 1800-2012. */
+%token K_implements K_interconnect K_nettype K_soft
+
+ /* The new tokens for Verilog-AMS 2.3. */
+%token K_above K_abs K_absdelay K_abstol K_access K_acos K_acosh
+ /* 1800-2005 has defined "assert" above! */
+%token K_ac_stim K_aliasparam K_analog K_analysis K_asin K_asinh
+%token K_atan K_atan2 K_atanh K_branch K_ceil K_connect K_connectmodule
+%token K_connectrules K_continuous K_cos K_cosh K_ddt K_ddt_nature K_ddx
+%token K_discipline K_discrete K_domain K_driver_update K_endconnectrules
+%token K_enddiscipline K_endnature K_endparamset K_exclude K_exp
+%token K_final_step K_flicker_noise K_floor K_flow K_from K_ground
+%token K_hypot K_idt K_idtmod K_idt_nature K_inf K_initial_step
+%token K_laplace_nd K_laplace_np K_laplace_zd K_laplace_zp
+%token K_last_crossing K_limexp K_ln K_log K_max K_merged K_min K_nature
+%token K_net_resolution K_noise_table K_paramset K_potential K_pow
+ /* 1800-2005 has defined "string" above! */
+%token K_resolveto K_sin K_sinh K_slew K_split K_sqrt K_tan K_tanh
+%token K_timer K_transition K_units K_white_noise K_wreal
+%token K_zi_nd K_zi_np K_zi_zd K_zi_zp
+
+%type <flag>    from_exclude block_item_decls_opt
+%type <number>  number pos_neg_number
+%type <flag>    signing unsigned_signed_opt signed_unsigned_opt
+%type <flag>    import_export
+%type <flag>    K_packed_opt K_reg_opt K_static_opt K_virtual_opt
+%type <flag>    udp_reg_opt edge_operator
+%type <drive>   drive_strength drive_strength_opt dr_strength0 dr_strength1
+%type <letter>  udp_input_sym udp_output_sym
+%type <text>    udp_input_list udp_sequ_entry udp_comb_entry
+%type <perm_strings> udp_input_declaration_list
+%type <strings> udp_entry_list udp_comb_entry_list udp_sequ_entry_list
+%type <strings> udp_body
+%type <perm_strings> udp_port_list
+%type <wires>   udp_port_decl udp_port_decls
+%type <statement> udp_initial udp_init_opt
+%type <expr>    udp_initial_expr_opt
+
+%type <text> register_variable net_variable event_variable endlabel_opt class_declaration_endlabel_opt
+%type <perm_strings> register_variable_list net_variable_list event_variable_list
+%type <perm_strings> list_of_identifiers loop_variables
+%type <port_list> list_of_port_identifiers list_of_variable_port_identifiers
+
+%type <net_decl_assign> net_decl_assign net_decl_assigns
+
+%type <mport> port port_opt port_reference port_reference_list
+%type <mport> port_declaration
+%type <mports> list_of_ports module_port_list_opt list_of_port_declarations module_attribute_foreign
+%type <value_range> parameter_value_range parameter_value_ranges
+%type <value_range> parameter_value_ranges_opt
+%type <expr> tf_port_item_expr_opt value_range_expression
+
+%type <named_pexprs> enum_name_list enum_name
+%type <enum_type> enum_data_type
+
+%type <tf_ports> function_item function_item_list function_item_list_opt
+%type <tf_ports> task_item task_item_list task_item_list_opt
+%type <tf_ports> tf_port_declaration tf_port_item tf_port_item_list tf_port_list tf_port_list_opt
+
+%type <named_pexpr> modport_simple_port port_name parameter_value_byname
+%type <named_pexprs> port_name_list parameter_value_byname_list
+
+%type <named_pexpr> attribute
+%type <named_pexprs> attribute_list attribute_instance_list attribute_list_opt
+
+%type <citem>  case_item
+%type <citems> case_items
+
+%type <gate>  gate_instance
+%type <gates> gate_instance_list
+
+%type <pform_name> hierarchy_identifier implicit_class_handle
+%type <expr>  assignment_pattern expression expr_mintypmax
+%type <expr>  expr_primary_or_typename expr_primary
+%type <expr>  class_new dynamic_array_new
+%type <expr>  inc_or_dec_expression inside_expression lpvalue
+%type <expr>  branch_probe_expression streaming_concatenation
+%type <expr>  delay_value delay_value_simple
+%type <exprs> delay1 delay3 delay3_opt delay_value_list
+%type <exprs> expression_list_with_nuls expression_list_proper
+%type <exprs> cont_assign cont_assign_list
+
+%type <decl_assignment> variable_decl_assignment
+%type <decl_assignments> list_of_variable_decl_assignments
+
+%type <data_type>  data_type data_type_or_implicit data_type_or_implicit_or_void
+%type <data_type>  simple_type_or_string
+%type <class_type> class_identifier
+%type <struct_member>  struct_union_member
+%type <struct_members> struct_union_member_list
+%type <struct_type>    struct_data_type
+
+%type <class_declaration_extends> class_declaration_extends_opt
+
+%type <property_qualifier> class_item_qualifier property_qualifier
+%type <property_qualifier> class_item_qualifier_list property_qualifier_list
+%type <property_qualifier> class_item_qualifier_opt property_qualifier_opt
+%type <property_qualifier> random_qualifier
+
+%type <ranges> variable_dimension
+%type <ranges> dimensions_opt dimensions
+
+%type <nettype>  net_type net_type_opt
+%type <gatetype> gatetype switchtype
+%type <porttype> port_direction port_direction_opt
+%type <vartype> bit_logic bit_logic_opt
+%type <vartype> integer_vector_type
+%type <parmvalue> parameter_value_opt
+
+%type <event_expr> event_expression_list
+%type <event_expr> event_expression
+%type <event_statement> event_control
+%type <statement> statement statement_item statement_or_null
+%type <statement> compressed_statement
+%type <statement> loop_statement for_step jump_statement
+%type <statement> procedural_assertion_statement
+%type <statement_list> statement_or_null_list statement_or_null_list_opt
+
+%type <statement> analog_statement
+
+%type <join_keyword> join_keyword
+
+%type <letter> spec_polarity
+%type <perm_strings>  specify_path_identifiers
+
+%type <specpath> specify_simple_path specify_simple_path_decl
+%type <specpath> specify_edge_path specify_edge_path_decl
+
+%type <real_type> non_integer_type
+%type <int_val> atom2_type
+%type <int_val> module_start module_end
+
+%type <lifetime> lifetime lifetime_opt
+
+%token K_TAND
+%right K_PLUS_EQ K_MINUS_EQ K_MUL_EQ K_DIV_EQ K_MOD_EQ K_AND_EQ K_OR_EQ
+%right K_XOR_EQ K_LS_EQ K_RS_EQ K_RSS_EQ
+%right '?' ':' K_inside
+%left K_LOR
+%left K_LAND
+%left '|'
+%left '^' K_NXOR K_NOR
+%left '&' K_NAND
+%left K_EQ K_NE K_CEQ K_CNE K_WEQ K_WNE
+%left K_GE K_LE '<' '>'
+%left K_LS K_RS K_RSS
+%left '+' '-'
+%left '*' '/' '%'
+%left K_POW
+%left UNARY_PREC
+
+
+ /* to resolve dangling else ambiguity. */
+%nonassoc less_than_K_else
+%nonassoc K_else
+
+ /* to resolve exclude (... ambiguity */
+%nonassoc '('
+%nonassoc K_exclude
+
+ /* to resolve timeunits declaration/redeclaration ambiguity */
+%nonassoc no_timeunits_declaration
+%nonassoc one_timeunits_declaration
+%nonassoc K_timeunit K_timeprecision
+
+%%
+
+
+  /* IEEE1800-2005: A.1.2 */
+  /* source_text ::= [ timeunits_declaration ] { description } */
+source_text
+  : timeunits_declaration_opt
+      { pform_set_scope_timescale(yyloc); }
+    description_list
+  | /* empty */
+  ;
+
+assertion_item /* IEEE1800-2012: A.6.10 */
+  : concurrent_assertion_item
+  ;
+
+assignment_pattern /* IEEE1800-2005: A.6.7.1 */
+  : K_LP expression_list_proper '}'
+      { PEAssignPattern*tmp = new PEAssignPattern(*$2);
+       FILE_NAME(tmp, @1);
+       delete $2;
+       $$ = tmp;
+      }
+  | K_LP '}'
+      { PEAssignPattern*tmp = new PEAssignPattern;
+       FILE_NAME(tmp, @1);
+       $$ = tmp;
+      }
+  ;
+
+  /* Some rules have a ... [ block_identifier ':' ] ... part. This
+     implements it in a LALR way. */
+block_identifier_opt /* */
+  : IDENTIFIER ':'
+  |
+  ;
+
+class_declaration /* IEEE1800-2005: A.1.2 */
+  : K_virtual_opt K_class lifetime_opt class_identifier class_declaration_extends_opt ';'
+      { pform_start_class_declaration(@2, $4, $5.type, $5.exprs, $3); }
+    class_items_opt K_endclass
+      { // Process a class.
+       pform_end_class_declaration(@9);
+      }
+    class_declaration_endlabel_opt
+      { // Wrap up the class.
+       if ($11 && $4 && $4->name != $11) {
+             yyerror(@11, "error: Class end label doesn't match class name.");
+             delete[]$11;
+       }
+      }
+  ;
+
+class_constraint /* IEEE1800-2005: A.1.8 */
+  : constraint_prototype
+  | constraint_declaration
+  ;
+
+class_identifier
+  : IDENTIFIER
+      { // Create a synthetic typedef for the class name so that the
+       // lexor detects the name as a type.
+       perm_string name = lex_strings.make($1);
+       class_type_t*tmp = new class_type_t(name);
+       FILE_NAME(tmp, @1);
+       pform_set_typedef(name, tmp, NULL);
+       delete[]$1;
+       $$ = tmp;
+      }
+  | TYPE_IDENTIFIER
+      { class_type_t*tmp = dynamic_cast<class_type_t*>($1.type);
+       if (tmp == 0) {
+             yyerror(@1, "Type name \"%s\"is not a predeclared class name.", $1.text);
+       }
+       delete[]$1.text;
+       $$ = tmp;
+      }
+  ;
+
+  /* The endlabel after a class declaration is a little tricky because
+     the class name is detected by the lexor as a TYPE_IDENTIFIER if it
+     does indeed match a name. */
+class_declaration_endlabel_opt
+  : ':' TYPE_IDENTIFIER
+      { class_type_t*tmp = dynamic_cast<class_type_t*> ($2.type);
+       if (tmp == 0) {
+             yyerror(@2, "error: class declaration endlabel \"%s\" is not a class name\n", $2.text);
+             $$ = 0;
+       } else {
+             $$ = strdupnew(tmp->name.str());
+       }
+       delete[]$2.text;
+      }
+  | ':' IDENTIFIER
+      { $$ = $2; }
+  |
+      { $$ = 0; }
+  ;
+
+  /* This rule implements [ extends class_type ] in the
+     class_declaration. It is not a rule of its own in the LRM.
+
+     Note that for this to be correct, the identifier after the
+     extends keyword must be a class name. Therefore, match
+     TYPE_IDENTIFIER instead of IDENTIFIER, and this rule will return
+     a data_type. */
+
+class_declaration_extends_opt /* IEEE1800-2005: A.1.2 */
+  : K_extends TYPE_IDENTIFIER
+      { $$.type = $2.type;
+       $$.exprs= 0;
+       delete[]$2.text;
+      }
+  | K_extends TYPE_IDENTIFIER '(' expression_list_with_nuls ')'
+      { $$.type  = $2.type;
+       $$.exprs = $4;
+       delete[]$2.text;
+      }
+  |
+      { $$.type = 0; $$.exprs = 0; }
+  ;
+
+  /* The class_items_opt and class_items rules together implement the
+     rule snippet { class_item } (zero or more class_item) of the
+     class_declaration. */
+class_items_opt /* IEEE1800-2005: A.1.2 */
+  : class_items
+  |
+  ;
+
+class_items /* IEEE1800-2005: A.1.2 */
+  : class_items class_item
+  | class_item
+  ;
+
+class_item /* IEEE1800-2005: A.1.8 */
+
+    /* IEEE1800 A.1.8: class_constructor_declaration */
+  : method_qualifier_opt K_function K_new
+      { assert(current_function==0);
+       current_function = pform_push_constructor_scope(@3);
+      }
+    '(' tf_port_list_opt ')' ';'
+    function_item_list_opt
+    statement_or_null_list_opt
+    K_endfunction endnew_opt
+      { current_function->set_ports($6);
+       pform_set_constructor_return(current_function);
+       pform_set_this_class(@3, current_function);
+       current_function_set_statement(@3, $10);
+       pform_pop_scope();
+       current_function = 0;
+      }
+
+    /* Class properties... */
+
+  | property_qualifier_opt data_type list_of_variable_decl_assignments ';'
+      { pform_class_property(@2, $1, $2, $3); }
+
+  | K_const class_item_qualifier_opt data_type list_of_variable_decl_assignments ';'
+      { pform_class_property(@1, $2 | property_qualifier_t::make_const(), $3, $4); }
+
+    /* Class methods... */
+
+  | method_qualifier_opt task_declaration
+      { /* The task_declaration rule puts this into the class */ }
+
+  | method_qualifier_opt function_declaration
+      { /* The function_declaration rule puts this into the class */ }
+
+    /* External class method definitions... */
+
+  | K_extern method_qualifier_opt K_function K_new ';'
+      { yyerror(@1, "sorry: External constructors are not yet supported."); }
+  | K_extern method_qualifier_opt K_function K_new '(' tf_port_list_opt ')' ';'
+      { yyerror(@1, "sorry: External constructors are not yet supported."); }
+  | K_extern method_qualifier_opt K_function data_type_or_implicit_or_void
+    IDENTIFIER ';'
+      { yyerror(@1, "sorry: External methods are not yet supported.");
+       delete[] $5;
+      }
+  | K_extern method_qualifier_opt K_function data_type_or_implicit_or_void
+    IDENTIFIER '(' tf_port_list_opt ')' ';'
+      { yyerror(@1, "sorry: External methods are not yet supported.");
+       delete[] $5;
+      }
+  | K_extern method_qualifier_opt K_task IDENTIFIER ';'
+      { yyerror(@1, "sorry: External methods are not yet supported.");
+       delete[] $4;
+      }
+  | K_extern method_qualifier_opt K_task IDENTIFIER '(' tf_port_list_opt ')' ';'
+      { yyerror(@1, "sorry: External methods are not yet supported.");
+       delete[] $4;
+      }
+
+    /* Class constraints... */
+
+  | class_constraint
+
+    /* Here are some error matching rules to help recover from various
+       syntax errors within a class declaration. */
+
+  | property_qualifier_opt data_type error ';'
+      { yyerror(@3, "error: Errors in variable names after data type.");
+       yyerrok;
+      }
+
+  | property_qualifier_opt IDENTIFIER error ';'
+      { yyerror(@3, "error: %s doesn't name a type.", $2);
+       yyerrok;
+      }
+
+  | method_qualifier_opt K_function K_new error K_endfunction endnew_opt
+      { yyerror(@1, "error: I give up on this class constructor declaration.");
+       yyerrok;
+      }
+
+  | error ';'
+      { yyerror(@2, "error: invalid class item.");
+       yyerrok;
+      }
+
+  ;
+
+class_item_qualifier /* IEEE1800-2005 A.1.8 */
+  : K_static     { $$ = property_qualifier_t::make_static(); }
+  | K_protected  { $$ = property_qualifier_t::make_protected(); }
+  | K_local      { $$ = property_qualifier_t::make_local(); }
+  ;
+
+class_item_qualifier_list
+  : class_item_qualifier_list class_item_qualifier { $$ = $1 | $2; }
+  | class_item_qualifier { $$ = $1; }
+  ;
+
+class_item_qualifier_opt
+  : class_item_qualifier_list { $$ = $1; }
+  | { $$ = property_qualifier_t::make_none(); }
+  ;
+
+class_new /* IEEE1800-2005 A.2.4 */
+  : K_new '(' expression_list_with_nuls ')'
+      { list<PExpr*>*expr_list = $3;
+       strip_tail_items(expr_list);
+       PENewClass*tmp = new PENewClass(*expr_list);
+       FILE_NAME(tmp, @1);
+       delete $3;
+       $$ = tmp;
+      }
+  | K_new hierarchy_identifier
+      { PEIdent*tmpi = new PEIdent(*$2);
+       FILE_NAME(tmpi, @2);
+       PENewCopy*tmp = new PENewCopy(tmpi);
+       FILE_NAME(tmp, @1);
+       delete $2;
+       $$ = tmp;
+      }
+  | K_new
+      { PENewClass*tmp = new PENewClass;
+       FILE_NAME(tmp, @1);
+       $$ = tmp;
+      }
+  ;
+
+  /* The concurrent_assertion_item pulls together the
+     concurrent_assertion_statement and checker_instantiation rules. */
+
+concurrent_assertion_item /* IEEE1800-2012 A.2.10 */
+  : block_identifier_opt K_assert K_property '(' property_spec ')' statement_or_null
+      { /* */
+       if (gn_assertions_flag) {
+             yyerror(@2, "sorry: concurrent_assertion_item not supported."
+                     " Try -gno-assertion to turn this message off.");
+       }
+      }
+  | block_identifier_opt K_assert K_property '(' error ')' statement_or_null
+      { yyerrok;
+        yyerror(@2, "error: Error in property_spec of concurrent assertion item.");
+      }
+  ;
+
+constraint_block_item /* IEEE1800-2005 A.1.9 */
+  : constraint_expression
+  ;
+
+constraint_block_item_list
+  : constraint_block_item_list constraint_block_item
+  | constraint_block_item
+  ;
+
+constraint_block_item_list_opt
+  :
+  | constraint_block_item_list
+  ;
+
+constraint_declaration /* IEEE1800-2005: A.1.9 */
+  : K_static_opt K_constraint IDENTIFIER '{' constraint_block_item_list_opt '}'
+      { yyerror(@2, "sorry: Constraint declarations not supported."); }
+
+  /* Error handling rules... */
+
+  | K_static_opt K_constraint IDENTIFIER '{' error '}'
+      { yyerror(@4, "error: Errors in the constraint block item list."); }
+  ;
+
+constraint_expression /* IEEE1800-2005 A.1.9 */
+  : expression ';'
+  | expression K_dist '{' '}' ';'
+  | expression K_TRIGGER constraint_set
+  | K_if '(' expression ')' constraint_set %prec less_than_K_else
+  | K_if '(' expression ')' constraint_set K_else constraint_set
+  | K_foreach '(' IDENTIFIER '[' loop_variables ']' ')' constraint_set
+  ;
+
+constraint_expression_list /* */
+  : constraint_expression_list constraint_expression
+  | constraint_expression
+  ;
+
+constraint_prototype /* IEEE1800-2005: A.1.9 */
+  : K_static_opt K_constraint IDENTIFIER ';'
+      { yyerror(@2, "sorry: Constraint prototypes not supported."); }
+  ;
+
+constraint_set /* IEEE1800-2005 A.1.9 */
+  : constraint_expression
+  | '{' constraint_expression_list '}'
+  ;
+
+data_declaration /* IEEE1800-2005: A.2.1.3 */
+  : attribute_list_opt data_type_or_implicit list_of_variable_decl_assignments ';'
+      { data_type_t*data_type = $2;
+       if (data_type == 0) {
+             data_type = new vector_type_t(IVL_VT_LOGIC, false, 0);
+             FILE_NAME(data_type, @2);
+       }
+       pform_makewire(@2, 0, str_strength, $3, NetNet::IMPLICIT_REG, data_type);
+      }
+  ;
+
+data_type /* IEEE1800-2005: A.2.2.1 */
+  : integer_vector_type unsigned_signed_opt dimensions_opt
+      { ivl_variable_type_t use_vtype = $1;
+       bool reg_flag = false;
+       if (use_vtype == IVL_VT_NO_TYPE) {
+             use_vtype = IVL_VT_LOGIC;
+             reg_flag = true;
+       }
+       vector_type_t*tmp = new vector_type_t(use_vtype, $2, $3);
+       tmp->reg_flag = reg_flag;
+       FILE_NAME(tmp, @1);
+       $$ = tmp;
+      }
+  | non_integer_type
+      { real_type_t*tmp = new real_type_t($1);
+       FILE_NAME(tmp, @1);
+       $$ = tmp;
+      }
+  | struct_data_type
+      { if (!$1->packed_flag) {
+             yyerror(@1, "sorry: Unpacked structs not supported.");
+       }
+       $$ = $1;
+      }
+  | enum_data_type
+      { $$ = $1; }
+  | atom2_type signed_unsigned_opt
+      { atom2_type_t*tmp = new atom2_type_t($1, $2);
+       FILE_NAME(tmp, @1);
+       $$ = tmp;
+      }
+  | K_integer signed_unsigned_opt
+      { list<pform_range_t>*pd = make_range_from_width(integer_width);
+       vector_type_t*tmp = new vector_type_t(IVL_VT_LOGIC, $2, pd);
+       tmp->reg_flag = true;
+       tmp->integer_flag = true;
+       $$ = tmp;
+      }
+  | K_time
+      { list<pform_range_t>*pd = make_range_from_width(64);
+       vector_type_t*tmp = new vector_type_t(IVL_VT_LOGIC, false, pd);
+       tmp->reg_flag = !gn_system_verilog();
+       $$ = tmp;
+      }
+  | TYPE_IDENTIFIER dimensions_opt
+      { if ($2) {
+             parray_type_t*tmp = new parray_type_t($1.type, $2);
+             FILE_NAME(tmp, @1);
+             $$ = tmp;
+       } else $$ = $1.type;
+       delete[]$1.text;
+      }
+  | PACKAGE_IDENTIFIER K_SCOPE_RES
+      { lex_in_package_scope($1); }
+    TYPE_IDENTIFIER
+      { lex_in_package_scope(0);
+       $$ = $4.type;
+       delete[]$4.text;
+      }
+  | K_string
+      { string_type_t*tmp = new string_type_t;
+       FILE_NAME(tmp, @1);
+       $$ = tmp;
+      }
+  ;
+
+  /* The data_type_or_implicit rule is a little more complex then the
+     rule documented in the IEEE format syntax in order to allow for
+     signaling the special case that the data_type is completely
+     absent. The context may need that information to decide to resort
+     to left context. */
+
+data_type_or_implicit /* IEEE1800-2005: A.2.2.1 */
+  : data_type
+      { $$ = $1; }
+  | signing dimensions_opt
+      { vector_type_t*tmp = new vector_type_t(IVL_VT_LOGIC, $1, $2);
+       tmp->implicit_flag = true;
+       FILE_NAME(tmp, @1);
+       $$ = tmp;
+      }
+  | dimensions
+      { vector_type_t*tmp = new vector_type_t(IVL_VT_LOGIC, false, $1);
+       tmp->implicit_flag = true;
+       FILE_NAME(tmp, @1);
+       $$ = tmp;
+      }
+  |
+      { $$ = 0; }
+  ;
+
+
+data_type_or_implicit_or_void
+  : data_type_or_implicit
+      { $$ = $1; }
+  | K_void
+      { void_type_t*tmp = new void_type_t;
+       FILE_NAME(tmp, @1);
+       $$ = tmp;
+      }
+  ;
+
+  /* NOTE: The "module" rule of the description combines the
+     module_declaration, program_declaration, and interface_declaration
+     rules from the standard description. */
+
+description /* IEEE1800-2005: A.1.2 */
+  : module
+  | udp_primitive
+  | config_declaration
+  | nature_declaration
+  | package_declaration
+  | discipline_declaration
+  | package_item
+  | KK_attribute '(' IDENTIFIER ',' STRING ',' STRING ')'
+      { perm_string tmp3 = lex_strings.make($3);
+       pform_set_type_attrib(tmp3, $5, $7);
+       delete[] $3;
+       delete[] $5;
+      }
+  ;
+
+description_list
+  : description
+  | description_list description
+  ;
+
+
+   /* This implements the [ : IDENTIFIER ] part of the constructor
+      rule documented in IEEE1800-2005: A.1.8 */
+endnew_opt : ':' K_new | ;
+
+  /* The dynamic_array_new rule is kinda like an expression, but it is
+     treated differently by rules that use this "expression". Watch out! */
+
+dynamic_array_new /* IEEE1800-2005: A.2.4 */
+  : K_new '[' expression ']'
+      { $$ = new PENewArray($3, 0);
+       FILE_NAME($$, @1);
+      }
+  | K_new '[' expression ']' '(' expression ')'
+      { $$ = new PENewArray($3, $6);
+       FILE_NAME($$, @1);
+      }
+  ;
+
+for_step /* IEEE1800-2005: A.6.8 */
+  : lpvalue '=' expression
+      { PAssign*tmp = new PAssign($1,$3);
+       FILE_NAME(tmp, @1);
+       $$ = tmp;
+      }
+  | inc_or_dec_expression
+      { $$ = pform_compressed_assign_from_inc_dec(@1, $1); }
+  | compressed_statement
+      { $$ = $1; }
+  ;
+
+
+  /* The function declaration rule matches the function declaration
+     header, then pushes the function scope. This causes the
+     definitions in the func_body to take on the scope of the function
+     instead of the module. */
+function_declaration /* IEEE1800-2005: A.2.6 */
+  : K_function lifetime_opt data_type_or_implicit_or_void IDENTIFIER ';'
+      { assert(current_function == 0);
+       current_function = pform_push_function_scope(@1, $4, $2);
+      }
+    function_item_list statement_or_null_list_opt
+    K_endfunction
+      { current_function->set_ports($7);
+       current_function->set_return($3);
+       current_function_set_statement($8? @8 : @4, $8);
+       pform_set_this_class(@4, current_function);
+       pform_pop_scope();
+       current_function = 0;
+      }
+    endlabel_opt
+      { // Last step: check any closing name.
+       if ($11) {
+             if (strcmp($4,$11) != 0) {
+                   yyerror(@11, "error: End label doesn't match "
+                                "function name");
+             }
+             if (! gn_system_verilog()) {
+                   yyerror(@11, "error: Function end labels require "
+                                "SystemVerilog.");
+             }
+             delete[]$11;
+       }
+       delete[]$4;
+      }
+
+  | K_function lifetime_opt data_type_or_implicit_or_void IDENTIFIER
+      { assert(current_function == 0);
+       current_function = pform_push_function_scope(@1, $4, $2);
+      }
+    '(' tf_port_list_opt ')' ';'
+    block_item_decls_opt
+    statement_or_null_list_opt
+    K_endfunction
+      { current_function->set_ports($7);
+       current_function->set_return($3);
+       current_function_set_statement($11? @11 : @4, $11);
+       pform_set_this_class(@4, current_function);
+       pform_pop_scope();
+       current_function = 0;
+       if ($7==0 && !gn_system_verilog()) {
+             yyerror(@4, "error: Empty parenthesis syntax requires SystemVerilog.");
+       }
+      }
+    endlabel_opt
+      { // Last step: check any closing name.
+       if ($14) {
+             if (strcmp($4,$14) != 0) {
+                   yyerror(@14, "error: End label doesn't match "
+                                "function name");
+             }
+             if (! gn_system_verilog()) {
+                   yyerror(@14, "error: Function end labels require "
+                                "SystemVerilog.");
+             }
+             delete[]$14;
+       }
+       delete[]$4;
+      }
+
+  /* Detect and recover from some errors. */
+
+  | K_function lifetime_opt data_type_or_implicit_or_void IDENTIFIER error K_endfunction
+      { /* */
+       if (current_function) {
+             pform_pop_scope();
+             current_function = 0;
+       }
+       assert(current_function == 0);
+       yyerror(@1, "error: Syntax error defining function.");
+       yyerrok;
+      }
+    endlabel_opt
+      { // Last step: check any closing name.
+       if ($8) {
+             if (strcmp($4,$8) != 0) {
+                   yyerror(@8, "error: End label doesn't match function name");
+             }
+             if (! gn_system_verilog()) {
+                   yyerror(@8, "error: Function end labels require "
+                                "SystemVerilog.");
+             }
+             delete[]$8;
+       }
+       delete[]$4;
+      }
+
+  ;
+
+import_export /* IEEE1800-2012: A.2.9 */
+  : K_import { $$ = true; }
+  | K_export { $$ = false; }
+  ;
+
+implicit_class_handle /* IEEE1800-2005: A.8.4 */
+  : K_this  { $$ = pform_create_this(); }
+  | K_super { $$ = pform_create_super(); }
+  ;
+
+  /* SystemVerilog adds support for the increment/decrement
+     expressions, which look like a++, --a, etc. These are primaries
+     but are in their own rules because they can also be
+     statements. Note that the operator can only take l-value
+     expressions. */
+
+inc_or_dec_expression /* IEEE1800-2005: A.4.3 */
+  : K_INCR lpvalue %prec UNARY_PREC
+      { PEUnary*tmp = new PEUnary('I', $2);
+       FILE_NAME(tmp, @2);
+       $$ = tmp;
+      }
+  | lpvalue K_INCR %prec UNARY_PREC
+      { PEUnary*tmp = new PEUnary('i', $1);
+       FILE_NAME(tmp, @1);
+       $$ = tmp;
+      }
+  | K_DECR lpvalue %prec UNARY_PREC
+      { PEUnary*tmp = new PEUnary('D', $2);
+       FILE_NAME(tmp, @2);
+       $$ = tmp;
+      }
+  | lpvalue K_DECR %prec UNARY_PREC
+      { PEUnary*tmp = new PEUnary('d', $1);
+       FILE_NAME(tmp, @1);
+       $$ = tmp;
+      }
+  ;
+
+inside_expression /* IEEE1800-2005 A.8.3 */
+  : expression K_inside '{' open_range_list '}'
+      { yyerror(@2, "sorry: \"inside\" expressions not supported yet.");
+       $$ = 0;
+      }
+  ;
+
+integer_vector_type /* IEEE1800-2005: A.2.2.1 */
+  : K_reg   { $$ = IVL_VT_NO_TYPE; } /* Usually a synonym for logic. */
+  | K_bit   { $$ = IVL_VT_BOOL; }
+  | K_logic { $$ = IVL_VT_LOGIC; }
+  | K_bool  { $$ = IVL_VT_BOOL; } /* Icarus Verilog xtypes extension */
+  ;
+
+join_keyword /* IEEE1800-2005: A.6.3 */
+  : K_join
+      { $$ = PBlock::BL_PAR; }
+  | K_join_none
+      { $$ = PBlock::BL_JOIN_NONE; }
+  | K_join_any
+      { $$ = PBlock::BL_JOIN_ANY; }
+  ;
+
+jump_statement /* IEEE1800-2005: A.6.5 */
+  : K_break ';'
+      { yyerror(@1, "sorry: break statements not supported.");
+       $$ = 0;
+      }
+  | K_return ';'
+      { PReturn*tmp = new PReturn(0);
+       FILE_NAME(tmp, @1);
+       $$ = tmp;
+      }
+  | K_return expression ';'
+      { PReturn*tmp = new PReturn($2);
+       FILE_NAME(tmp, @1);
+       $$ = tmp;
+      }
+  ;
+
+lifetime /* IEEE1800-2005: A.2.1.3 */
+  : K_automatic { $$ = LexicalScope::AUTOMATIC; }
+  | K_static    { $$ = LexicalScope::STATIC; }
+  ;
+
+lifetime_opt /* IEEE1800-2005: A.2.1.3 */
+  : lifetime { $$ = $1; }
+  |          { $$ = LexicalScope::INHERITED; }
+  ;
+
+  /* Loop statements are kinds of statements. */
+
+loop_statement /* IEEE1800-2005: A.6.8 */
+  : K_for '(' lpvalue '=' expression ';' expression ';' for_step ')'
+    statement_or_null
+      { PForStatement*tmp = new PForStatement($3, $5, $7, $9, $11);
+       FILE_NAME(tmp, @1);
+       $$ = tmp;
+      }
+
+      // Handle for_variable_declaration syntax by wrapping the for(...)
+      // statement in a synthetic named block. We can name the block
+      // after the variable that we are creating, that identifier is
+      // safe in the controlling scope.
+  | K_for '(' data_type IDENTIFIER '=' expression ';' expression ';' for_step ')'
+      { static unsigned for_counter = 0;
+       char for_block_name [64];
+       snprintf(for_block_name, sizeof for_block_name, "$ivl_for_loop%u", for_counter);
+       for_counter += 1;
+       PBlock*tmp = pform_push_block_scope(for_block_name, PBlock::BL_SEQ);
+       FILE_NAME(tmp, @1);
+       current_block_stack.push(tmp);
+
+       list<decl_assignment_t*>assign_list;
+       decl_assignment_t*tmp_assign = new decl_assignment_t;
+       tmp_assign->name = lex_strings.make($4);
+       assign_list.push_back(tmp_assign);
+       pform_makewire(@4, 0, str_strength, &assign_list, NetNet::REG, $3);
+      }
+    statement_or_null
+      { pform_name_t tmp_hident;
+       tmp_hident.push_back(name_component_t(lex_strings.make($4)));
+
+       PEIdent*tmp_ident = pform_new_ident(tmp_hident);
+       FILE_NAME(tmp_ident, @4);
+
+       PForStatement*tmp_for = new PForStatement(tmp_ident, $6, $8, $10, $13);
+       FILE_NAME(tmp_for, @1);
+
+       pform_pop_scope();
+       vector<Statement*>tmp_for_list (1);
+       tmp_for_list[0] = tmp_for;
+       PBlock*tmp_blk = current_block_stack.top();
+       current_block_stack.pop();
+       tmp_blk->set_statement(tmp_for_list);
+       $$ = tmp_blk;
+       delete[]$4;
+      }
+
+  | K_forever statement_or_null
+      { PForever*tmp = new PForever($2);
+       FILE_NAME(tmp, @1);
+       $$ = tmp;
+      }
+
+  | K_repeat '(' expression ')' statement_or_null
+      { PRepeat*tmp = new PRepeat($3, $5);
+       FILE_NAME(tmp, @1);
+       $$ = tmp;
+      }
+
+  | K_while '(' expression ')' statement_or_null
+      { PWhile*tmp = new PWhile($3, $5);
+       FILE_NAME(tmp, @1);
+       $$ = tmp;
+      }
+
+  | K_do statement_or_null K_while '(' expression ')' ';'
+      { PDoWhile*tmp = new PDoWhile($5, $2);
+       FILE_NAME(tmp, @1);
+       $$ = tmp;
+      }
+
+      // When matching a foreach loop, implicitly create a named block
+      // to hold the definitions for the index variables.
+  | K_foreach '(' IDENTIFIER '[' loop_variables ']' ')'
+      { static unsigned foreach_counter = 0;
+       char for_block_name[64];
+       snprintf(for_block_name, sizeof for_block_name, "$ivl_foreach%u", foreach_counter);
+       foreach_counter += 1;
+
+       PBlock*tmp = pform_push_block_scope(for_block_name, PBlock::BL_SEQ);
+       FILE_NAME(tmp, @1);
+       current_block_stack.push(tmp);
+
+       pform_make_foreach_declarations(@1, $5);
+      }
+    statement_or_null
+      { PForeach*tmp_for = pform_make_foreach(@1, $3, $5, $9);
+
+       pform_pop_scope();
+       vector<Statement*>tmp_for_list(1);
+       tmp_for_list[0] = tmp_for;
+       PBlock*tmp_blk = current_block_stack.top();
+       current_block_stack.pop();
+       tmp_blk->set_statement(tmp_for_list);
+       $$ = tmp_blk;
+      }
+
+  /* Error forms for loop statements. */
+
+  | K_for '(' lpvalue '=' expression ';' expression ';' error ')'
+    statement_or_null
+      { $$ = 0;
+       yyerror(@1, "error: Error in for loop step assignment.");
+      }
+
+  | K_for '(' lpvalue '=' expression ';' error ';' for_step ')'
+    statement_or_null
+      { $$ = 0;
+       yyerror(@1, "error: Error in for loop condition expression.");
+      }
+
+  | K_for '(' error ')' statement_or_null
+      { $$ = 0;
+       yyerror(@1, "error: Incomprehensible for loop.");
+      }
+
+  | K_while '(' error ')' statement_or_null
+      { $$ = 0;
+       yyerror(@1, "error: Error in while loop condition.");
+      }
+
+  | K_do statement_or_null K_while '(' error ')' ';'
+      { $$ = 0;
+       yyerror(@1, "error: Error in do/while loop condition.");
+      }
+
+  | K_foreach '(' IDENTIFIER '[' error ']' ')' statement_or_null
+      { $$ = 0;
+        yyerror(@4, "error: Errors in foreach loop variables list.");
+      }
+  ;
+
+
+/* TODO: Replace register_variable_list with list_of_variable_decl_assignments. */
+list_of_variable_decl_assignments /* IEEE1800-2005 A.2.3 */
+  : variable_decl_assignment
+      { list<decl_assignment_t*>*tmp = new list<decl_assignment_t*>;
+       tmp->push_back($1);
+       $$ = tmp;
+      }
+  | list_of_variable_decl_assignments ',' variable_decl_assignment
+      { list<decl_assignment_t*>*tmp = $1;
+       tmp->push_back($3);
+       $$ = tmp;
+      }
+  ;
+
+variable_decl_assignment /* IEEE1800-2005 A.2.3 */
+  : IDENTIFIER dimensions_opt
+      { decl_assignment_t*tmp = new decl_assignment_t;
+       tmp->name = lex_strings.make($1);
+       if ($2) {
+             tmp->index = *$2;
+             delete $2;
+       }
+       delete[]$1;
+       $$ = tmp;
+      }
+  | IDENTIFIER '=' expression
+      { decl_assignment_t*tmp = new decl_assignment_t;
+       tmp->name = lex_strings.make($1);
+       tmp->expr .reset($3);
+       delete[]$1;
+       $$ = tmp;
+      }
+  | IDENTIFIER '=' K_new '(' ')'
+      { decl_assignment_t*tmp = new decl_assignment_t;
+       tmp->name = lex_strings.make($1);
+       PENewClass*expr = new PENewClass;
+       FILE_NAME(expr, @3);
+       tmp->expr .reset(expr);
+       delete[]$1;
+       $$ = tmp;
+      }
+  ;
+
+
+loop_variables /* IEEE1800-2005: A.6.8 */
+  : loop_variables ',' IDENTIFIER
+      { list<perm_string>*tmp = $1;
+       tmp->push_back(lex_strings.make($3));
+       delete[]$3;
+       $$ = tmp;
+      }
+  | IDENTIFIER
+      { list<perm_string>*tmp = new list<perm_string>;
+       tmp->push_back(lex_strings.make($1));
+       delete[]$1;
+       $$ = tmp;
+      }
+  ;
+
+method_qualifier /* IEEE1800-2005: A.1.8 */
+  : K_virtual
+  | class_item_qualifier
+  ;
+
+method_qualifier_opt
+  : method_qualifier
+  |
+  ;
+
+modport_declaration /* IEEE1800-2012: A.2.9 */
+  : K_modport
+      { if (!pform_in_interface())
+             yyerror(@1, "error: modport declarations are only allowed "
+                         "in interfaces.");
+      }
+    modport_item_list ';'
+
+modport_item_list
+  : modport_item
+  | modport_item_list ',' modport_item
+  ;
+
+modport_item
+  : IDENTIFIER
+      { pform_start_modport_item(@1, $1); }
+    '(' modport_ports_list ')'
+      { pform_end_modport_item(@1); }
+  ;
+
+  /* The modport_ports_list is a LALR(2) grammar. When the parser sees a
+     ',' it needs to look ahead to the next token to decide whether it is
+     a continuation of the preceding modport_ports_declaration, or the
+     start of a new modport_ports_declaration. bison only supports LALR(1),
+     so we have to handcraft a mini parser for this part of the syntax.
+     last_modport_port holds the state for this mini parser.*/
+
+modport_ports_list
+  : modport_ports_declaration
+  | modport_ports_list ',' modport_ports_declaration
+  | modport_ports_list ',' modport_simple_port
+      { if (last_modport_port.type == MP_SIMPLE) {
+             pform_add_modport_port(@3, last_modport_port.direction,
+                                    $3->name, $3->parm);
+       } else {
+             yyerror(@3, "error: modport expression not allowed here.");
+       }
+       delete $3;
+      }
+  | modport_ports_list ',' modport_tf_port
+      { if (last_modport_port.type != MP_TF)
+             yyerror(@3, "error: task/function declaration not allowed here.");
+      }
+  | modport_ports_list ',' IDENTIFIER
+      { if (last_modport_port.type == MP_SIMPLE) {
+             pform_add_modport_port(@3, last_modport_port.direction,
+                                    lex_strings.make($3), 0);
+       } else if (last_modport_port.type != MP_TF) {
+             yyerror(@3, "error: list of identifiers not allowed here.");
+       }
+       delete[] $3;
+      }
+  | modport_ports_list ','
+      { yyerror(@2, "error: NULL port declarations are not allowed"); }
+  ;
+
+modport_ports_declaration
+  : attribute_list_opt port_direction IDENTIFIER
+      { last_modport_port.type = MP_SIMPLE;
+       last_modport_port.direction = $2;
+       pform_add_modport_port(@3, $2, lex_strings.make($3), 0);
+       delete[] $3;
+       delete $1;
+      }
+  | attribute_list_opt port_direction modport_simple_port
+      { last_modport_port.type = MP_SIMPLE;
+       last_modport_port.direction = $2;
+       pform_add_modport_port(@3, $2, $3->name, $3->parm);
+       delete $3;
+       delete $1;
+      }
+  | attribute_list_opt import_export IDENTIFIER
+      { last_modport_port.type = MP_TF;
+       last_modport_port.is_import = $2;
+       yyerror(@3, "sorry: modport task/function ports are not yet supported.");
+       delete[] $3;
+       delete $1;
+      }
+  | attribute_list_opt import_export modport_tf_port
+      { last_modport_port.type = MP_TF;
+       last_modport_port.is_import = $2;
+       yyerror(@3, "sorry: modport task/function ports are not yet supported.");
+       delete $1;
+      }
+  | attribute_list_opt K_clocking IDENTIFIER
+      { last_modport_port.type = MP_CLOCKING;
+       last_modport_port.direction = NetNet::NOT_A_PORT;
+       yyerror(@3, "sorry: modport clocking declaration is not yet supported.");
+       delete[] $3;
+       delete $1;
+      }
+  ;
+
+modport_simple_port
+  : '.' IDENTIFIER '(' expression ')'
+      { named_pexpr_t*tmp = new named_pexpr_t;
+       tmp->name = lex_strings.make($2);
+       tmp->parm = $4;
+       delete[]$2;
+       $$ = tmp;
+      }
+  ;
+
+modport_tf_port
+  : K_task IDENTIFIER
+  | K_task IDENTIFIER '(' tf_port_list_opt ')'
+  | K_function data_type_or_implicit_or_void IDENTIFIER
+  | K_function data_type_or_implicit_or_void IDENTIFIER '(' tf_port_list_opt ')'
+  ;
+
+non_integer_type /* IEEE1800-2005: A.2.2.1 */
+  : K_real { $$ = real_type_t::REAL; }
+  | K_realtime { $$ = real_type_t::REAL; }
+  | K_shortreal { $$ = real_type_t::SHORTREAL; }
+  ;
+
+number  : BASED_NUMBER
+            { $$ = $1; based_size = 0;}
+        | DEC_NUMBER
+            { $$ = $1; based_size = 0;}
+        | DEC_NUMBER BASED_NUMBER
+            { $$ = pform_verinum_with_size($1,$2, @2.text, @2.first_line);
+              based_size = 0; }
+        | UNBASED_NUMBER
+            { $$ = $1; based_size = 0;}
+        | DEC_NUMBER UNBASED_NUMBER
+            { yyerror(@1, "error: Unbased SystemVerilog literal cannot have "
+                          "a size.");
+              $$ = $1; based_size = 0;}
+       ;
+
+open_range_list /* IEEE1800-2005 A.2.11 */
+  : open_range_list ',' value_range
+  | value_range
+  ;
+
+package_declaration /* IEEE1800-2005 A.1.2 */
+  : K_package lifetime_opt IDENTIFIER ';'
+      { pform_start_package_declaration(@1, $3, $2); }
+    timeunits_declaration_opt
+      { pform_set_scope_timescale(@1); }
+    package_item_list_opt
+    K_endpackage endlabel_opt
+      { pform_end_package_declaration(@1);
+       // If an end label is present make sure it match the package name.
+       if ($10) {
+             if (strcmp($3,$10) != 0) {
+                   yyerror(@10, "error: End label doesn't match package name");
+             }
+             delete[]$10;
+       }
+       delete[]$3;
+      }
+  ;
+
+module_package_import_list_opt
+  :
+  | package_import_list
+  ;
+
+package_import_list
+  : package_import_declaration
+  | package_import_list package_import_declaration
+  ;
+
+package_import_declaration /* IEEE1800-2005 A.2.1.3 */
+  : K_import package_import_item_list ';'
+      { }
+  ;
+
+package_import_item
+  : PACKAGE_IDENTIFIER K_SCOPE_RES IDENTIFIER
+      { pform_package_import(@2, $1, $3);
+       delete[]$3;
+      }
+  | PACKAGE_IDENTIFIER K_SCOPE_RES '*'
+      { pform_package_import(@2, $1, 0);
+      }
+  ;
+
+package_import_item_list
+  : package_import_item_list',' package_import_item
+  | package_import_item
+  ;
+
+package_item /* IEEE1800-2005 A.1.10 */
+  : timeunits_declaration
+  | K_parameter param_type parameter_assign_list ';'
+  | K_localparam param_type localparam_assign_list ';'
+  | type_declaration
+  | function_declaration
+  | task_declaration
+  | data_declaration
+  | class_declaration
+  ;
+
+package_item_list
+  : package_item_list package_item
+  | package_item
+  ;
+
+package_item_list_opt : package_item_list | ;
+
+port_direction /* IEEE1800-2005 A.1.3 */
+  : K_input  { $$ = NetNet::PINPUT; }
+  | K_output { $$ = NetNet::POUTPUT; }
+  | K_inout  { $$ = NetNet::PINOUT; }
+  | K_ref
+      { $$ = NetNet::PREF;
+        if (!gn_system_verilog()) {
+             yyerror(@1, "error: Reference ports (ref) require SystemVerilog.");
+             $$ = NetNet::PINPUT;
+       }
+      }
+  ;
+
+  /* port_direction_opt is used in places where the port direction is
+     optional. The default direction is selected by the context,
+     which needs to notice the PIMPLICIT direction. */
+
+port_direction_opt
+  : port_direction { $$ = $1; }
+  |                { $$ = NetNet::PIMPLICIT; }
+  ;
+
+property_expr /* IEEE1800-2012 A.2.10 */
+  : expression
+  ;
+
+procedural_assertion_statement /* IEEE1800-2012 A.6.10 */
+  : K_assert '(' expression ')' statement %prec less_than_K_else
+      { yyerror(@1, "sorry: Simple immediate assertion statements not implemented.");
+       $$ = 0;
+      }
+  | K_assert '(' expression ')' K_else statement
+      { yyerror(@1, "sorry: Simple immediate assertion statements not implemented.");
+       $$ = 0;
+      }
+  | K_assert '(' expression ')' statement K_else statement
+      { yyerror(@1, "sorry: Simple immediate assertion statements not implemented.");
+       $$ = 0;
+      }
+  ;
+
+  /* The property_qualifier rule is as literally described in the LRM,
+     but the use is usually as { property_qualifier }, which is
+     implemented by the property_qualifier_opt rule below. */
+
+property_qualifier /* IEEE1800-2005 A.1.8 */
+  : class_item_qualifier
+  | random_qualifier
+  ;
+
+property_qualifier_opt /* IEEE1800-2005 A.1.8: ... { property_qualifier } */
+  : property_qualifier_list { $$ = $1; }
+  | { $$ = property_qualifier_t::make_none(); }
+  ;
+
+property_qualifier_list /* IEEE1800-2005 A.1.8 */
+  : property_qualifier_list property_qualifier { $$ = $1 | $2; }
+  | property_qualifier { $$ = $1; }
+  ;
+
+  /* The property_spec rule uses some helper rules to implement this
+     rule from the LRM:
+     [ clocking_event ] [ disable iff ( expression_or_dist ) ] property_expr
+     This does it is a YACC friendly way. */
+
+property_spec /* IEEE1800-2012 A.2.10 */
+  : clocking_event_opt property_spec_disable_iff_opt property_expr
+  ;
+
+property_spec_disable_iff_opt /* */
+  : K_disable K_iff '(' expression ')'
+  |
+  ;
+
+random_qualifier /* IEEE1800-2005 A.1.8 */
+  : K_rand { $$ = property_qualifier_t::make_rand(); }
+  | K_randc { $$ = property_qualifier_t::make_randc(); }
+  ;
+
+  /* real and realtime are exactly the same so save some code
+   * with a common matching rule. */
+real_or_realtime
+       : K_real
+       | K_realtime
+       ;
+
+signing /* IEEE1800-2005: A.2.2.1 */
+  : K_signed   { $$ = true; }
+  | K_unsigned { $$ = false; }
+  ;
+
+simple_type_or_string /* IEEE1800-2005: A.2.2.1 */
+  : integer_vector_type
+      { ivl_variable_type_t use_vtype = $1;
+       bool reg_flag = false;
+       if (use_vtype == IVL_VT_NO_TYPE) {
+             use_vtype = IVL_VT_LOGIC;
+             reg_flag = true;
+       }
+       vector_type_t*tmp = new vector_type_t(use_vtype, false, 0);
+       tmp->reg_flag = reg_flag;
+       FILE_NAME(tmp, @1);
+       $$ = tmp;
+      }
+  | non_integer_type
+      { real_type_t*tmp = new real_type_t($1);
+       FILE_NAME(tmp, @1);
+       $$ = tmp;
+      }
+  | atom2_type
+      { atom2_type_t*tmp = new atom2_type_t($1, true);
+       FILE_NAME(tmp, @1);
+       $$ = tmp;
+      }
+  | K_integer
+      { list<pform_range_t>*pd = make_range_from_width(integer_width);
+       vector_type_t*tmp = new vector_type_t(IVL_VT_LOGIC, true, pd);
+       tmp->reg_flag = true;
+       tmp->integer_flag = true;
+       $$ = tmp;
+      }
+  | K_time
+      { list<pform_range_t>*pd = make_range_from_width(64);
+       vector_type_t*tmp = new vector_type_t(IVL_VT_LOGIC, false, pd);
+       tmp->reg_flag = !gn_system_verilog();
+       $$ = tmp;
+      }
+  | TYPE_IDENTIFIER
+      { $$ = $1.type;
+       delete[]$1.text;
+      }
+  | PACKAGE_IDENTIFIER K_SCOPE_RES
+      { lex_in_package_scope($1); }
+    TYPE_IDENTIFIER
+      { lex_in_package_scope(0);
+       $$ = $4.type;
+       delete[]$4.text;
+      }
+  | K_string
+      { string_type_t*tmp = new string_type_t;
+       FILE_NAME(tmp, @1);
+       $$ = tmp;
+      }
+  ;
+
+statement /* IEEE1800-2005: A.6.4 */
+  : attribute_list_opt statement_item
+      { pform_bind_attributes($2->attributes, $1);
+       $$ = $2;
+      }
+  ;
+
+  /* Many places where statements are allowed can actually take a
+     statement or a null statement marked with a naked semi-colon. */
+
+statement_or_null /* IEEE1800-2005: A.6.4 */
+  : statement
+      { $$ = $1; }
+  | attribute_list_opt ';'
+      { $$ = 0; }
+  ;
+
+stream_expression
+  : expression
+  ;
+
+stream_expression_list
+  : stream_expression_list ',' stream_expression
+  | stream_expression
+  ;
+
+stream_operator
+  : K_LS
+  | K_RS
+  ;
+
+streaming_concatenation /* IEEE1800-2005: A.8.1 */
+  : '{' stream_operator '{' stream_expression_list '}' '}'
+      { /* streaming concatenation is a SystemVerilog thing. */
+       if (gn_system_verilog()) {
+             yyerror(@2, "sorry: Streaming concatenation not supported.");
+             $$ = 0;
+       } else {
+             yyerror(@2, "error: Streaming concatenation requires SystemVerilog");
+             $$ = 0;
+       }
+      }
+  ;
+
+  /* The task declaration rule matches the task declaration
+     header, then pushes the function scope. This causes the
+     definitions in the task_body to take on the scope of the task
+     instead of the module. */
+
+task_declaration /* IEEE1800-2005: A.2.7 */
+
+  : K_task lifetime_opt IDENTIFIER ';'
+      { assert(current_task == 0);
+       current_task = pform_push_task_scope(@1, $3, $2);
+      }
+    task_item_list_opt
+    statement_or_null_list_opt
+    K_endtask
+      { current_task->set_ports($6);
+       current_task_set_statement(@3, $7);
+       pform_set_this_class(@3, current_task);
+       pform_pop_scope();
+       current_task = 0;
+       if ($7 && $7->size() > 1 && !gn_system_verilog()) {
+             yyerror(@7, "error: Task body with multiple statements requires SystemVerilog.");
+       }
+       delete $7;
+      }
+    endlabel_opt
+      { // Last step: check any closing name. This is done late so
+       // that the parser can look ahead to detect the present
+       // endlabel_opt but still have the pform_endmodule() called
+       // early enough that the lexor can know we are outside the
+       // module.
+       if ($10) {
+             if (strcmp($3,$10) != 0) {
+                   yyerror(@10, "error: End label doesn't match task name");
+             }
+             if (! gn_system_verilog()) {
+                   yyerror(@10, "error: Task end labels require "
+                                "SystemVerilog.");
+             }
+             delete[]$10;
+       }
+       delete[]$3;
+      }
+
+  | K_task lifetime_opt IDENTIFIER '('
+      { assert(current_task == 0);
+       current_task = pform_push_task_scope(@1, $3, $2);
+      }
+    tf_port_list ')' ';'
+    block_item_decls_opt
+    statement_or_null_list_opt
+    K_endtask
+      { current_task->set_ports($6);
+       current_task_set_statement(@3, $10);
+       pform_set_this_class(@3, current_task);
+       pform_pop_scope();
+       current_task = 0;
+       if ($10) delete $10;
+      }
+    endlabel_opt
+      { // Last step: check any closing name. This is done late so
+       // that the parser can look ahead to detect the present
+       // endlabel_opt but still have the pform_endmodule() called
+       // early enough that the lexor can know we are outside the
+       // module.
+       if ($13) {
+             if (strcmp($3,$13) != 0) {
+                   yyerror(@13, "error: End label doesn't match task name");
+             }
+             if (! gn_system_verilog()) {
+                   yyerror(@13, "error: Task end labels require "
+                                "SystemVerilog.");
+             }
+             delete[]$13;
+       }
+       delete[]$3;
+      }
+
+  | K_task lifetime_opt IDENTIFIER '(' ')' ';'
+      { assert(current_task == 0);
+       current_task = pform_push_task_scope(@1, $3, $2);
+      }
+    block_item_decls_opt
+    statement_or_null_list
+    K_endtask
+      { current_task->set_ports(0);
+       current_task_set_statement(@3, $9);
+       pform_set_this_class(@3, current_task);
+       if (! current_task->method_of()) {
+             cerr << @3 << ": warning: task definition for \"" << $3
+                  << "\" has an empty port declaration list!" << endl;
+       }
+       pform_pop_scope();
+       current_task = 0;
+       if ($9->size() > 1 && !gn_system_verilog()) {
+             yyerror(@9, "error: Task body with multiple statements requires SystemVerilog.");
+       }
+       delete $9;
+      }
+    endlabel_opt
+      { // Last step: check any closing name. This is done late so
+       // that the parser can look ahead to detect the present
+       // endlabel_opt but still have the pform_endmodule() called
+       // early enough that the lexor can know we are outside the
+       // module.
+       if ($12) {
+             if (strcmp($3,$12) != 0) {
+                   yyerror(@12, "error: End label doesn't match task name");
+             }
+             if (! gn_system_verilog()) {
+                   yyerror(@12, "error: Task end labels require "
+                                "SystemVerilog.");
+             }
+             delete[]$12;
+       }
+       delete[]$3;
+      }
+
+  | K_task lifetime_opt IDENTIFIER error K_endtask
+      {
+       if (current_task) {
+             pform_pop_scope();
+             current_task = 0;
+       }
+      }
+    endlabel_opt
+      { // Last step: check any closing name. This is done late so
+       // that the parser can look ahead to detect the present
+       // endlabel_opt but still have the pform_endmodule() called
+       // early enough that the lexor can know we are outside the
+       // module.
+       if ($7) {
+             if (strcmp($3,$7) != 0) {
+                   yyerror(@7, "error: End label doesn't match task name");
+             }
+             if (! gn_system_verilog()) {
+                   yyerror(@7, "error: Task end labels require "
+                                "SystemVerilog.");
+             }
+             delete[]$7;
+       }
+       delete[]$3;
+      }
+
+  ;
+
+
+tf_port_declaration /* IEEE1800-2005: A.2.7 */
+  : port_direction K_reg_opt unsigned_signed_opt dimensions_opt list_of_identifiers ';'
+      { vector<pform_tf_port_t>*tmp = pform_make_task_ports(@1, $1,
+                                               $2 ? IVL_VT_LOGIC :
+                                                    IVL_VT_NO_TYPE,
+                                               $3, $4, $5);
+       $$ = tmp;
+      }
+
+  /* When the port is an integer, infer a signed vector of the integer
+     shape. Generate a range ([31:0]) to make it work. */
+
+  | port_direction K_integer list_of_identifiers ';'
+      { list<pform_range_t>*range_stub = make_range_from_width(integer_width);
+       vector<pform_tf_port_t>*tmp = pform_make_task_ports(@1, $1, IVL_VT_LOGIC, true,
+                                                   range_stub, $3, true);
+       $$ = tmp;
+      }
+
+  /* Ports can be time with a width of [63:0] (unsigned). */
+
+  | port_direction K_time list_of_identifiers ';'
+      { list<pform_range_t>*range_stub = make_range_from_width(64);
+       vector<pform_tf_port_t>*tmp = pform_make_task_ports(@1, $1, IVL_VT_LOGIC, false,
+                                                  range_stub, $3);
+       $$ = tmp;
+      }
+
+  /* Ports can be real or realtime. */
+
+  | port_direction real_or_realtime list_of_identifiers ';'
+      { vector<pform_tf_port_t>*tmp = pform_make_task_ports(@1, $1, IVL_VT_REAL, true,
+                                                  0, $3);
+       $$ = tmp;
+      }
+
+
+  /* Ports can be string. */
+
+  | port_direction K_string list_of_identifiers ';'
+      { vector<pform_tf_port_t>*tmp = pform_make_task_ports(@1, $1, IVL_VT_STRING, true,
+                                                  0, $3);
+       $$ = tmp;
+      }
+
+  ;
+
+
+  /* These rules for tf_port_item are slightly expanded from the
+     strict rules in the LRM to help with LALR parsing.
+
+     NOTE: Some of these rules should be folded into the "data_type"
+     variant which uses the data_type rule to match data type
+     declarations. That some rules do not use the data_type production
+     is a consequence of legacy. */
+
+tf_port_item /* IEEE1800-2005: A.2.7 */
+
+  : port_direction_opt data_type_or_implicit IDENTIFIER dimensions_opt tf_port_item_expr_opt
+      { vector<pform_tf_port_t>*tmp;
+       NetNet::PortType use_port_type = $1;
+        if ((use_port_type == NetNet::PIMPLICIT) && (gn_system_verilog() || ($2 == 0)))
+              use_port_type = port_declaration_context.port_type;
+       perm_string name = lex_strings.make($3);
+       list<perm_string>* ilist = list_from_identifier($3);
+
+       if (use_port_type == NetNet::PIMPLICIT) {
+             yyerror(@1, "error: missing task/function port direction.");
+             use_port_type = NetNet::PINPUT; // for error recovery
+       }
+       if (($2 == 0) && ($1==NetNet::PIMPLICIT)) {
+               // Detect special case this is an undecorated
+               // identifier and we need to get the declaration from
+               // left context.
+             if ($4 != 0) {
+                   yyerror(@4, "internal error: How can there be an unpacked range here?\n");
+             }
+             tmp = pform_make_task_ports(@3, use_port_type,
+                                         port_declaration_context.data_type,
+                                         ilist);
+
+       } else {
+               // Otherwise, the decorations for this identifier
+               // indicate the type. Save the type for any right
+               // context that may come later.
+             port_declaration_context.port_type = use_port_type;
+             if ($2 == 0) {
+                   $2 = new vector_type_t(IVL_VT_LOGIC, false, 0);
+                   FILE_NAME($2, @3);
+             }
+             port_declaration_context.data_type = $2;
+             tmp = pform_make_task_ports(@3, use_port_type, $2, ilist);
+       }
+       if ($4 != 0) {
+             pform_set_reg_idx(name, $4);
+       }
+
+       $$ = tmp;
+       if ($5) {
+             assert(tmp->size()==1);
+             tmp->front().defe = $5;
+       }
+      }
+
+  /* Rules to match error cases... */
+
+  | port_direction_opt data_type_or_implicit IDENTIFIER error
+      { yyerror(@3, "error: Error in task/function port item after port name %s.", $3);
+       yyerrok;
+       $$ = 0;
+      }
+  ;
+
+  /* This rule matches the [ = <expression> ] part of the tf_port_item rules. */
+
+tf_port_item_expr_opt
+  : '=' expression
+      { if (! gn_system_verilog()) {
+             yyerror(@1, "error: Task/function default arguments require "
+                         "SystemVerilog.");
+       }
+       $$ = $2;
+      }
+  |   { $$ = 0; }
+  ;
+
+tf_port_list /* IEEE1800-2005: A.2.7 */
+  :   { port_declaration_context.port_type = gn_system_verilog() ? NetNet::PINPUT : NetNet::PIMPLICIT;
+       port_declaration_context.data_type = 0;
+      }
+    tf_port_item_list
+      { $$ = $2; }
+  ;
+
+tf_port_item_list
+  : tf_port_item_list ',' tf_port_item
+      { vector<pform_tf_port_t>*tmp;
+       if ($1 && $3) {
+             size_t s1 = $1->size();
+             tmp = $1;
+             tmp->resize(tmp->size()+$3->size());
+             for (size_t idx = 0 ; idx < $3->size() ; idx += 1)
+                   tmp->at(s1+idx) = $3->at(idx);
+             delete $3;
+       } else if ($1) {
+             tmp = $1;
+       } else {
+             tmp = $3;
+       }
+       $$ = tmp;
+      }
+
+  | tf_port_item
+      { $$ = $1; }
+
+  /* Rules to handle some errors in tf_port_list items. */
+
+  | error ',' tf_port_item
+      { yyerror(@2, "error: Syntax error in task/function port declaration.");
+       $$ = $3;
+      }
+  | tf_port_item_list ','
+      { yyerror(@2, "error: NULL port declarations are not allowed.");
+       $$ = $1;
+      }
+  | tf_port_item_list ';'
+      { yyerror(@2, "error: ';' is an invalid port declaration separator.");
+       $$ = $1;
+      }
+  ;
+
+timeunits_declaration /* IEEE1800-2005: A.1.2 */
+  : K_timeunit TIME_LITERAL ';'
+      { pform_set_timeunit($2, allow_timeunit_decl); }
+  | K_timeunit TIME_LITERAL '/' TIME_LITERAL ';'
+      { bool initial_decl = allow_timeunit_decl && allow_timeprec_decl;
+        pform_set_timeunit($2, initial_decl);
+        pform_set_timeprec($4, initial_decl);
+      }
+  | K_timeprecision TIME_LITERAL ';'
+      { pform_set_timeprec($2, allow_timeprec_decl); }
+  ;
+
+  /* Allow zero, one, or two declarations. The second declaration might
+     be a repeat declaration, but the pform functions take care of that. */
+timeunits_declaration_opt
+  : /* empty */           %prec no_timeunits_declaration
+  | timeunits_declaration %prec one_timeunits_declaration
+  | timeunits_declaration timeunits_declaration
+  ;
+
+value_range /* IEEE1800-2005: A.8.3 */
+  : expression
+      { }
+  | '[' expression ':' expression ']'
+      { }
+  ;
+
+variable_dimension /* IEEE1800-2005: A.2.5 */
+  : '[' expression ':' expression ']'
+      { list<pform_range_t> *tmp = new list<pform_range_t>;
+       pform_range_t index ($2,$4);
+       tmp->push_back(index);
+       $$ = tmp;
+      }
+  | '[' expression ']'
+      { // SystemVerilog canonical range
+       if (!gn_system_verilog()) {
+             warn_count += 1;
+             cerr << @2 << ": warning: Use of SystemVerilog [size] dimension. "
+                  << "Use at least -g2005-sv to remove this warning." << endl;
+       }
+       list<pform_range_t> *tmp = new list<pform_range_t>;
+       pform_range_t index;
+       index.first = new PENumber(new verinum((uint64_t)0, integer_width));
+       index.second = new PEBinary('-', $2, new PENumber(new verinum((uint64_t)1, integer_width)));
+       tmp->push_back(index);
+       $$ = tmp;
+      }
+  | '[' ']'
+      { list<pform_range_t> *tmp = new list<pform_range_t>;
+       pform_range_t index (0,0);
+       tmp->push_back(index);
+       $$ = tmp;
+      }
+  | '[' '$' ']'
+      { // SystemVerilog queue
+       list<pform_range_t> *tmp = new list<pform_range_t>;
+       pform_range_t index (new PENull,0);
+       if (!gn_system_verilog()) {
+             yyerror("error: Queue declarations require SystemVerilog.");
+       }
+       tmp->push_back(index);
+       $$ = tmp;
+      }
+  ;
+
+variable_lifetime
+  : lifetime
+      { if (!gn_system_verilog()) {
+             yyerror(@1, "error: overriding the default variable lifetime "
+                         "requires SystemVerilog.");
+       } else if ($1 != pform_peek_scope()->default_lifetime) {
+             yyerror(@1, "sorry: overriding the default variable lifetime "
+                         "is not yet supported.");
+       }
+       var_lifetime = $1;
+      }
+  ;
+
+  /* Verilog-2001 supports attribute lists, which can be attached to a
+     variety of different objects. The syntax inside the (* *) is a
+     comma separated list of names or names with assigned values. */
+attribute_list_opt
+  : attribute_instance_list
+      { $$ = $1; }
+  |
+      { $$ = 0; }
+  ;
+
+attribute_instance_list
+  : K_PSTAR K_STARP { $$ = 0; }
+  | K_PSTAR attribute_list K_STARP { $$ = $2; }
+  | attribute_instance_list K_PSTAR K_STARP { $$ = $1; }
+  | attribute_instance_list K_PSTAR attribute_list K_STARP
+      { list<named_pexpr_t>*tmp = $1;
+       if (tmp) {
+           tmp->splice(tmp->end(), *$3);
+           delete $3;
+           $$ = tmp;
+       } else $$ = $3;
+      }
+  ;
+
+attribute_list
+  : attribute_list ',' attribute
+      { list<named_pexpr_t>*tmp = $1;
+        tmp->push_back(*$3);
+       delete $3;
+       $$ = tmp;
+      }
+  | attribute
+      { list<named_pexpr_t>*tmp = new list<named_pexpr_t>;
+        tmp->push_back(*$1);
+       delete $1;
+       $$ = tmp;
+      }
+  ;
+
+
+attribute
+       : IDENTIFIER
+               { named_pexpr_t*tmp = new named_pexpr_t;
+                 tmp->name = lex_strings.make($1);
+                 tmp->parm = 0;
+                 delete[]$1;
+                 $$ = tmp;
+               }
+       | IDENTIFIER '=' expression
+               { PExpr*tmp = $3;
+                 named_pexpr_t*tmp2 = new named_pexpr_t;
+                 tmp2->name = lex_strings.make($1);
+                 tmp2->parm = tmp;
+                 delete[]$1;
+                 $$ = tmp2;
+               }
+       ;
+
+
+  /* The block_item_decl is used in function definitions, task
+     definitions, module definitions and named blocks. Wherever a new
+     scope is entered, the source may declare new registers and
+     integers. This rule matches those declarations. The containing
+     rule has presumably set up the scope. */
+
+block_item_decl
+
+  /* variable declarations. Note that data_type can be 0 if we are
+     recovering from an error. */
+
+  : data_type register_variable_list ';'
+      { if ($1) pform_set_data_type(@1, $1, $2, NetNet::REG, attributes_in_context);
+      }
+
+  | variable_lifetime data_type register_variable_list ';'
+      { if ($2) pform_set_data_type(@2, $2, $3, NetNet::REG, attributes_in_context);
+       var_lifetime = LexicalScope::INHERITED;
+      }
+
+  | K_reg data_type register_variable_list ';'
+      { if ($2) pform_set_data_type(@2, $2, $3, NetNet::REG, attributes_in_context);
+      }
+
+  | variable_lifetime K_reg data_type register_variable_list ';'
+      { if ($3) pform_set_data_type(@3, $3, $4, NetNet::REG, attributes_in_context);
+       var_lifetime = LexicalScope::INHERITED;
+      }
+
+  | K_event event_variable_list ';'
+      { if ($2) pform_make_events($2, @1.text, @1.first_line);
+      }
+
+  | K_parameter param_type parameter_assign_list ';'
+  | K_localparam param_type localparam_assign_list ';'
+
+  /* Blocks can have type declarations. */
+
+  | type_declaration
+
+  /* Recover from errors that happen within variable lists. Use the
+     trailing semi-colon to resync the parser. */
+
+  | K_integer error ';'
+      { yyerror(@1, "error: syntax error in integer variable list.");
+       yyerrok;
+      }
+
+  | K_time error ';'
+      { yyerror(@1, "error: syntax error in time variable list.");
+       yyerrok;
+      }
+
+  | K_parameter error ';'
+      { yyerror(@1, "error: syntax error in parameter list.");
+       yyerrok;
+      }
+  | K_localparam error ';'
+      { yyerror(@1, "error: syntax error localparam list.");
+       yyerrok;
+      }
+  ;
+
+block_item_decls
+       : block_item_decl
+       | block_item_decls block_item_decl
+       ;
+
+block_item_decls_opt
+       : block_item_decls { $$ = true; }
+       | { $$ = false; }
+       ;
+
+  /* Type declarations are parsed here. The rule actions call pform
+     functions that add the declaration to the current lexical scope. */
+type_declaration
+  : K_typedef data_type IDENTIFIER dimensions_opt ';'
+      { perm_string name = lex_strings.make($3);
+       pform_set_typedef(name, $2, $4);
+       delete[]$3;
+      }
+
+  /* If the IDENTIFIER already is a typedef, it is possible for this
+     code to override the definition, but only if the typedef is
+     inherited from a different scope. */
+  | K_typedef data_type TYPE_IDENTIFIER ';'
+      { perm_string name = lex_strings.make($3.text);
+       if (pform_test_type_identifier_local(name)) {
+             yyerror(@3, "error: Typedef identifier \"%s\" is already a type name.", $3.text);
+
+       } else {
+             pform_set_typedef(name, $2, NULL);
+       }
+       delete[]$3.text;
+      }
+
+  /* These are forward declarations... */
+
+  | K_typedef K_class  IDENTIFIER ';'
+      { // Create a synthetic typedef for the class name so that the
+       // lexor detects the name as a type.
+       perm_string name = lex_strings.make($3);
+       class_type_t*tmp = new class_type_t(name);
+       FILE_NAME(tmp, @3);
+       pform_set_typedef(name, tmp, NULL);
+       delete[]$3;
+      }
+  | K_typedef K_enum   IDENTIFIER ';'
+      { yyerror(@1, "sorry: Enum forward declarations not supported yet."); }
+  | K_typedef K_struct IDENTIFIER ';'
+      { yyerror(@1, "sorry: Struct forward declarations not supported yet."); }
+  | K_typedef K_union  IDENTIFIER ';'
+      { yyerror(@1, "sorry: Union forward declarations not supported yet."); }
+  | K_typedef          IDENTIFIER ';'
+      { // Create a synthetic typedef for the class name so that the
+       // lexor detects the name as a type.
+       perm_string name = lex_strings.make($2);
+       class_type_t*tmp = new class_type_t(name);
+       FILE_NAME(tmp, @2);
+       pform_set_typedef(name, tmp, NULL);
+       delete[]$2;
+      }
+
+  | K_typedef error ';'
+      { yyerror(@2, "error: Syntax error in typedef clause.");
+       yyerrok;
+      }
+
+  ;
+
+  /* The structure for an enumeration data type is the keyword "enum",
+     followed by the enumeration values in curly braces. Also allow
+     for an optional base type. The default base type is "int", but it
+     can be any of the integral or vector types. */
+
+enum_data_type
+  : K_enum '{' enum_name_list '}'
+      { enum_type_t*enum_type = new enum_type_t;
+       FILE_NAME(enum_type, @1);
+       enum_type->names .reset($3);
+       enum_type->base_type = IVL_VT_BOOL;
+       enum_type->signed_flag = true;
+       enum_type->integer_flag = false;
+       enum_type->range.reset(make_range_from_width(32));
+       $$ = enum_type;
+      }
+  | K_enum atom2_type signed_unsigned_opt '{' enum_name_list '}'
+      { enum_type_t*enum_type = new enum_type_t;
+       FILE_NAME(enum_type, @1);
+       enum_type->names .reset($5);
+       enum_type->base_type = IVL_VT_BOOL;
+       enum_type->signed_flag = $3;
+       enum_type->integer_flag = false;
+       enum_type->range.reset(make_range_from_width($2));
+       $$ = enum_type;
+      }
+  | K_enum K_integer signed_unsigned_opt '{' enum_name_list '}'
+      { enum_type_t*enum_type = new enum_type_t;
+       FILE_NAME(enum_type, @1);
+       enum_type->names .reset($5);
+       enum_type->base_type = IVL_VT_LOGIC;
+       enum_type->signed_flag = $3;
+       enum_type->integer_flag = true;
+       enum_type->range.reset(make_range_from_width(integer_width));
+       $$ = enum_type;
+      }
+  | K_enum K_logic unsigned_signed_opt dimensions_opt '{' enum_name_list '}'
+      { enum_type_t*enum_type = new enum_type_t;
+       FILE_NAME(enum_type, @1);
+       enum_type->names .reset($6);
+       enum_type->base_type = IVL_VT_LOGIC;
+       enum_type->signed_flag = $3;
+       enum_type->integer_flag = false;
+       enum_type->range.reset($4 ? $4 : make_range_from_width(1));
+       $$ = enum_type;
+      }
+  | K_enum K_reg unsigned_signed_opt dimensions_opt '{' enum_name_list '}'
+      { enum_type_t*enum_type = new enum_type_t;
+       FILE_NAME(enum_type, @1);
+       enum_type->names .reset($6);
+       enum_type->base_type = IVL_VT_LOGIC;
+       enum_type->signed_flag = $3;
+       enum_type->integer_flag = false;
+       enum_type->range.reset($4 ? $4 : make_range_from_width(1));
+       $$ = enum_type;
+      }
+  | K_enum K_bit unsigned_signed_opt dimensions_opt '{' enum_name_list '}'
+      { enum_type_t*enum_type = new enum_type_t;
+       FILE_NAME(enum_type, @1);
+       enum_type->names .reset($6);
+       enum_type->base_type = IVL_VT_BOOL;
+       enum_type->signed_flag = $3;
+       enum_type->integer_flag = false;
+       enum_type->range.reset($4 ? $4 : make_range_from_width(1));
+       $$ = enum_type;
+      }
+  ;
+
+enum_name_list
+  : enum_name
+      { $$ = $1;
+      }
+  | enum_name_list ',' enum_name
+      { list<named_pexpr_t>*lst = $1;
+       lst->splice(lst->end(), *$3);
+       delete $3;
+       $$ = lst;
+      }
+  ;
+
+pos_neg_number
+  : number
+      { $$ = $1;
+      }
+  | '-' number
+      { verinum tmp = -(*($2));
+       *($2) = tmp;
+       $$ = $2;
+      }
+  ;
+
+enum_name
+  : IDENTIFIER
+      { perm_string name = lex_strings.make($1);
+       delete[]$1;
+       $$ = make_named_number(name);
+      }
+  | IDENTIFIER '[' pos_neg_number ']'
+      { perm_string name = lex_strings.make($1);
+       long count = check_enum_seq_value(@1, $3, false);
+       delete[]$1;
+       $$ = make_named_numbers(name, 0, count-1);
+       delete $3;
+      }
+  | IDENTIFIER '[' pos_neg_number ':' pos_neg_number ']'
+      { perm_string name = lex_strings.make($1);
+       $$ = make_named_numbers(name, check_enum_seq_value(@1, $3, true),
+                                     check_enum_seq_value(@1, $5, true));
+       delete[]$1;
+       delete $3;
+       delete $5;
+      }
+  | IDENTIFIER '=' expression
+      { perm_string name = lex_strings.make($1);
+       delete[]$1;
+       $$ = make_named_number(name, $3);
+      }
+  | IDENTIFIER '[' pos_neg_number ']' '=' expression
+      { perm_string name = lex_strings.make($1);
+       long count = check_enum_seq_value(@1, $3, false);
+       $$ = make_named_numbers(name, 0, count-1, $6);
+       delete[]$1;
+       delete $3;
+      }
+  | IDENTIFIER '[' pos_neg_number ':' pos_neg_number ']' '=' expression
+      { perm_string name = lex_strings.make($1);
+       $$ = make_named_numbers(name, check_enum_seq_value(@1, $3, true),
+                                     check_enum_seq_value(@1, $5, true), $8);
+       delete[]$1;
+       delete $3;
+       delete $5;
+      }
+  ;
+
+struct_data_type
+  : K_struct K_packed_opt '{' struct_union_member_list '}'
+      { struct_type_t*tmp = new struct_type_t;
+       FILE_NAME(tmp, @1);
+       tmp->packed_flag = $2;
+       tmp->union_flag = false;
+       tmp->members .reset($4);
+       $$ = tmp;
+      }
+  | K_union K_packed_opt '{' struct_union_member_list '}'
+      { struct_type_t*tmp = new struct_type_t;
+       FILE_NAME(tmp, @1);
+       tmp->packed_flag = $2;
+       tmp->union_flag = true;
+       tmp->members .reset($4);
+       $$ = tmp;
+      }
+  | K_struct K_packed_opt '{' error '}'
+      { yyerror(@3, "error: Errors in struct member list.");
+       yyerrok;
+       struct_type_t*tmp = new struct_type_t;
+       FILE_NAME(tmp, @1);
+       tmp->packed_flag = $2;
+       tmp->union_flag = false;
+       $$ = tmp;
+      }
+  | K_union K_packed_opt '{' error '}'
+      { yyerror(@3, "error: Errors in union member list.");
+       yyerrok;
+       struct_type_t*tmp = new struct_type_t;
+       FILE_NAME(tmp, @1);
+       tmp->packed_flag = $2;
+       tmp->union_flag = true;
+       $$ = tmp;
+      }
+  ;
+
+  /* This is an implementation of the rule snippet:
+       struct_union_member { struct_union_member }
+     that is used in the rule matching struct and union types
+     in IEEE 1800-2012 A.2.2.1. */
+struct_union_member_list
+  : struct_union_member_list struct_union_member
+      { list<struct_member_t*>*tmp = $1;
+       tmp->push_back($2);
+       $$ = tmp;
+      }
+  | struct_union_member
+      { list<struct_member_t*>*tmp = new list<struct_member_t*>;
+       tmp->push_back($1);
+       $$ = tmp;
+      }
+  ;
+
+struct_union_member /* IEEE 1800-2012 A.2.2.1 */
+  : attribute_list_opt data_type list_of_variable_decl_assignments ';'
+      { struct_member_t*tmp = new struct_member_t;
+       FILE_NAME(tmp, @2);
+       tmp->type  .reset($2);
+       tmp->names .reset($3);
+       $$ = tmp;
+      }
+  | error ';'
+      { yyerror(@2, "Error in struct/union member.");
+       yyerrok;
+       $$ = 0;
+      }
+  ;
+
+case_item
+       : expression_list_proper ':' statement_or_null
+               { PCase::Item*tmp = new PCase::Item;
+                 tmp->expr = *$1;
+                 tmp->stat = $3;
+                 delete $1;
+                 $$ = tmp;
+               }
+       | K_default ':' statement_or_null
+               { PCase::Item*tmp = new PCase::Item;
+                 tmp->stat = $3;
+                 $$ = tmp;
+               }
+       | K_default  statement_or_null
+               { PCase::Item*tmp = new PCase::Item;
+                 tmp->stat = $2;
+                 $$ = tmp;
+               }
+       | error ':' statement_or_null
+               { yyerror(@2, "error: Incomprehensible case expression.");
+                 yyerrok;
+               }
+       ;
+
+case_items
+       : case_items case_item
+               { svector<PCase::Item*>*tmp;
+                 tmp = new svector<PCase::Item*>(*$1, $2);
+                 delete $1;
+                 $$ = tmp;
+               }
+       | case_item
+               { svector<PCase::Item*>*tmp = new svector<PCase::Item*>(1);
+                 (*tmp)[0] = $1;
+                 $$ = tmp;
+               }
+       ;
+
+charge_strength
+       : '(' K_small ')'
+       | '(' K_medium ')'
+       | '(' K_large ')'
+       ;
+
+charge_strength_opt
+       : charge_strength
+       |
+       ;
+
+defparam_assign
+       : hierarchy_identifier '=' expression
+               { pform_set_defparam(*$1, $3);
+                 delete $1;
+               }
+       ;
+
+defparam_assign_list
+  : defparam_assign
+  | dimensions defparam_assign
+      { yyerror(@1, "error: defparam may not include a range.");
+       delete $1;
+      }
+  | defparam_assign_list ',' defparam_assign
+       ;
+
+delay1
+       : '#' delay_value_simple
+               { list<PExpr*>*tmp = new list<PExpr*>;
+                 tmp->push_back($2);
+                 $$ = tmp;
+               }
+       | '#' '(' delay_value ')'
+               { list<PExpr*>*tmp = new list<PExpr*>;
+                 tmp->push_back($3);
+                 $$ = tmp;
+               }
+       ;
+
+delay3
+       : '#' delay_value_simple
+               { list<PExpr*>*tmp = new list<PExpr*>;
+                 tmp->push_back($2);
+                 $$ = tmp;
+               }
+       | '#' '(' delay_value ')'
+               { list<PExpr*>*tmp = new list<PExpr*>;
+                 tmp->push_back($3);
+                 $$ = tmp;
+               }
+       | '#' '(' delay_value ',' delay_value ')'
+               { list<PExpr*>*tmp = new list<PExpr*>;
+                 tmp->push_back($3);
+                 tmp->push_back($5);
+                 $$ = tmp;
+               }
+       | '#' '(' delay_value ',' delay_value ',' delay_value ')'
+               { list<PExpr*>*tmp = new list<PExpr*>;
+                 tmp->push_back($3);
+                 tmp->push_back($5);
+                 tmp->push_back($7);
+                 $$ = tmp;
+               }
+       ;
+
+delay3_opt
+       : delay3 { $$ = $1; }
+       |        { $$ = 0; }
+       ;
+
+delay_value_list
+  : delay_value
+      { list<PExpr*>*tmp = new list<PExpr*>;
+       tmp->push_back($1);
+       $$ = tmp;
+      }
+  | delay_value_list ',' delay_value
+      { list<PExpr*>*tmp = $1;
+       tmp->push_back($3);
+       $$ = tmp;
+      }
+  ;
+
+delay_value
+       : expression
+               { PExpr*tmp = $1;
+                 $$ = tmp;
+               }
+       | expression ':' expression ':' expression
+               { $$ = pform_select_mtm_expr($1, $3, $5); }
+       ;
+
+
+delay_value_simple
+       : DEC_NUMBER
+               { verinum*tmp = $1;
+                 if (tmp == 0) {
+                       yyerror(@1, "internal error: delay.");
+                       $$ = 0;
+                 } else {
+                       $$ = new PENumber(tmp);
+                       FILE_NAME($$, @1);
+                 }
+                 based_size = 0;
+               }
+       | REALTIME
+               { verireal*tmp = $1;
+                 if (tmp == 0) {
+                       yyerror(@1, "internal error: delay.");
+                       $$ = 0;
+                 } else {
+                       $$ = new PEFNumber(tmp);
+                       FILE_NAME($$, @1);
+                 }
+               }
+       | IDENTIFIER
+                { PEIdent*tmp = new PEIdent(lex_strings.make($1));
+                 FILE_NAME(tmp, @1);
+                 $$ = tmp;
+                 delete[]$1;
+               }
+       | TIME_LITERAL
+               { int unit;
+
+                 based_size = 0;
+                 $$         = 0;
+                 if ($1 == 0 || !get_time_unit($1, unit))
+                       yyerror(@1, "internal error: delay.");
+                 else {
+                       double p = pow(10.0,
+                                      (double)(unit - pform_get_timeunit()));
+                       double time = atof($1) * p;
+
+                       verireal *v = new verireal(time);
+                       $$ = new PEFNumber(v);
+                       FILE_NAME($$, @1);
+                 }
+               }
+       ;
+
+  /* The discipline and nature declarations used to take no ';' after
+     the identifier. The 2.3 LRM adds the ';', but since there are
+     programs written to the 2.1 and 2.2 standard that don't, we
+     choose to make the ';' optional in this context. */
+optional_semicolon : ';' | ;
+
+discipline_declaration
+  : K_discipline IDENTIFIER optional_semicolon
+      { pform_start_discipline($2); }
+    discipline_items K_enddiscipline
+      { pform_end_discipline(@1); delete[] $2; }
+  ;
+
+discipline_items
+  : discipline_items discipline_item
+  | discipline_item
+  ;
+
+discipline_item
+  : K_domain K_discrete ';'
+      { pform_discipline_domain(@1, IVL_DIS_DISCRETE); }
+  | K_domain K_continuous ';'
+      { pform_discipline_domain(@1, IVL_DIS_CONTINUOUS); }
+  | K_potential IDENTIFIER ';'
+      { pform_discipline_potential(@1, $2); delete[] $2; }
+  | K_flow IDENTIFIER ';'
+      { pform_discipline_flow(@1, $2); delete[] $2; }
+  ;
+
+nature_declaration
+  : K_nature IDENTIFIER optional_semicolon
+      { pform_start_nature($2); }
+    nature_items
+    K_endnature
+      { pform_end_nature(@1); delete[] $2; }
+  ;
+
+nature_items
+  : nature_items nature_item
+  | nature_item
+  ;
+
+nature_item
+  : K_units '=' STRING ';'
+      { delete[] $3; }
+  | K_abstol '=' expression ';'
+  | K_access '=' IDENTIFIER ';'
+      { pform_nature_access(@1, $3); delete[] $3; }
+  | K_idt_nature '=' IDENTIFIER ';'
+      { delete[] $3; }
+  | K_ddt_nature '=' IDENTIFIER ';'
+      { delete[] $3; }
+  ;
+
+config_declaration
+  : K_config IDENTIFIER ';'
+    K_design lib_cell_identifiers ';'
+    list_of_config_rule_statements
+    K_endconfig
+      { cerr << @1 << ": sorry: config declarations are not supported and "
+                "will be skipped." << endl;
+       delete[] $2;
+      }
+  ;
+
+lib_cell_identifiers
+  : /* The BNF implies this can be blank, but I'm not sure exactly what
+     * this means. */
+  | lib_cell_identifiers lib_cell_id
+  ;
+
+list_of_config_rule_statements
+  : /* config rules are optional. */
+  | list_of_config_rule_statements config_rule_statement
+  ;
+
+config_rule_statement
+  : K_default K_liblist list_of_libraries ';'
+  | K_instance hierarchy_identifier K_liblist list_of_libraries ';'
+      { delete $2; }
+  | K_instance hierarchy_identifier K_use lib_cell_id opt_config ';'
+      { delete $2; }
+  | K_cell lib_cell_id K_liblist list_of_libraries ';'
+  | K_cell lib_cell_id K_use lib_cell_id opt_config ';'
+  ;
+
+opt_config
+  : /* The use clause takes an optional :config. */
+  | ':' K_config
+  ;
+
+lib_cell_id
+  : IDENTIFIER
+      { delete[] $1; }
+  | IDENTIFIER '.' IDENTIFIER
+      { delete[] $1; delete[] $3; }
+  ;
+
+list_of_libraries
+  : /* A NULL library means use the parents cell library. */
+  | list_of_libraries IDENTIFIER
+      { delete[] $2; }
+  ;
+
+drive_strength
+       : '(' dr_strength0 ',' dr_strength1 ')'
+               { $$.str0 = $2.str0;
+                 $$.str1 = $4.str1;
+               }
+       | '(' dr_strength1 ',' dr_strength0 ')'
+               { $$.str0 = $4.str0;
+                 $$.str1 = $2.str1;
+               }
+       | '(' dr_strength0 ',' K_highz1 ')'
+               { $$.str0 = $2.str0;
+                 $$.str1 = IVL_DR_HiZ;
+               }
+       | '(' dr_strength1 ',' K_highz0 ')'
+               { $$.str0 = IVL_DR_HiZ;
+                 $$.str1 = $2.str1;
+               }
+       | '(' K_highz1 ',' dr_strength0 ')'
+               { $$.str0 = $4.str0;
+                 $$.str1 = IVL_DR_HiZ;
+               }
+       | '(' K_highz0 ',' dr_strength1 ')'
+               { $$.str0 = IVL_DR_HiZ;
+                 $$.str1 = $4.str1;
+               }
+       ;
+
+drive_strength_opt
+       : drive_strength { $$ = $1; }
+       |                { $$.str0 = IVL_DR_STRONG; $$.str1 = IVL_DR_STRONG; }
+       ;
+
+dr_strength0
+       : K_supply0 { $$.str0 = IVL_DR_SUPPLY; }
+       | K_strong0 { $$.str0 = IVL_DR_STRONG; }
+       | K_pull0   { $$.str0 = IVL_DR_PULL; }
+       | K_weak0   { $$.str0 = IVL_DR_WEAK; }
+       ;
+
+dr_strength1
+       : K_supply1 { $$.str1 = IVL_DR_SUPPLY; }
+       | K_strong1 { $$.str1 = IVL_DR_STRONG; }
+       | K_pull1   { $$.str1 = IVL_DR_PULL; }
+       | K_weak1   { $$.str1 = IVL_DR_WEAK; }
+       ;
+
+clocking_event_opt /* */
+  : event_control
+  |
+  ;
+
+event_control /* A.K.A. clocking_event */
+       : '@' hierarchy_identifier
+               { PEIdent*tmpi = new PEIdent(*$2);
+                 PEEvent*tmpe = new PEEvent(PEEvent::ANYEDGE, tmpi);
+                 PEventStatement*tmps = new PEventStatement(tmpe);
+                 FILE_NAME(tmps, @1);
+                 $$ = tmps;
+                 delete $2;
+               }
+       | '@' '(' event_expression_list ')'
+               { PEventStatement*tmp = new PEventStatement(*$3);
+                 FILE_NAME(tmp, @1);
+                 delete $3;
+                 $$ = tmp;
+               }
+       | '@' '(' error ')'
+               { yyerror(@1, "error: Malformed event control expression.");
+                 $$ = 0;
+               }
+       ;
+
+event_expression_list
+       : event_expression
+               { $$ = $1; }
+       | event_expression_list K_or event_expression
+               { svector<PEEvent*>*tmp = new svector<PEEvent*>(*$1, *$3);
+                 delete $1;
+                 delete $3;
+                 $$ = tmp;
+               }
+       | event_expression_list ',' event_expression
+               { svector<PEEvent*>*tmp = new svector<PEEvent*>(*$1, *$3);
+                 delete $1;
+                 delete $3;
+                 $$ = tmp;
+               }
+       ;
+
+event_expression
+       : K_posedge expression
+               { PEEvent*tmp = new PEEvent(PEEvent::POSEDGE, $2);
+                 FILE_NAME(tmp, @1);
+                 svector<PEEvent*>*tl = new svector<PEEvent*>(1);
+                 (*tl)[0] = tmp;
+                 $$ = tl;
+               }
+       | K_negedge expression
+               { PEEvent*tmp = new PEEvent(PEEvent::NEGEDGE, $2);
+                 FILE_NAME(tmp, @1);
+                 svector<PEEvent*>*tl = new svector<PEEvent*>(1);
+                 (*tl)[0] = tmp;
+                 $$ = tl;
+               }
+       | expression
+               { PEEvent*tmp = new PEEvent(PEEvent::ANYEDGE, $1);
+                 FILE_NAME(tmp, @1);
+                 svector<PEEvent*>*tl = new svector<PEEvent*>(1);
+                 (*tl)[0] = tmp;
+                 $$ = tl;
+               }
+       ;
+
+  /* A branch probe expression applies a probe function (potential or
+     flow) to a branch. The branch may be implicit as a pair of nets
+     or explicit as a named branch. Elaboration will check that the
+     function name really is a nature attribute identifier. */
+branch_probe_expression
+  : IDENTIFIER '(' IDENTIFIER ',' IDENTIFIER ')'
+      { $$ = pform_make_branch_probe_expression(@1, $1, $3, $5); }
+  | IDENTIFIER '(' IDENTIFIER ')'
+      { $$ = pform_make_branch_probe_expression(@1, $1, $3); }
+  ;
+
+expression
+  : expr_primary_or_typename
+      { $$ = $1; }
+  | inc_or_dec_expression
+      { $$ = $1; }
+  | inside_expression
+      { $$ = $1; }
+  | '+' attribute_list_opt expr_primary %prec UNARY_PREC
+      { $$ = $3; }
+  | '-' attribute_list_opt expr_primary %prec UNARY_PREC
+      { PEUnary*tmp = new PEUnary('-', $3);
+       FILE_NAME(tmp, @3);
+       $$ = tmp;
+      }
+  | '~' attribute_list_opt expr_primary %prec UNARY_PREC
+      { PEUnary*tmp = new PEUnary('~', $3);
+       FILE_NAME(tmp, @3);
+       $$ = tmp;
+      }
+  | '&' attribute_list_opt expr_primary %prec UNARY_PREC
+      { PEUnary*tmp = new PEUnary('&', $3);
+       FILE_NAME(tmp, @3);
+       $$ = tmp;
+      }
+  | '!' attribute_list_opt expr_primary %prec UNARY_PREC
+      { PEUnary*tmp = new PEUnary('!', $3);
+       FILE_NAME(tmp, @3);
+       $$ = tmp;
+      }
+  | '|' attribute_list_opt expr_primary %prec UNARY_PREC
+      { PEUnary*tmp = new PEUnary('|', $3);
+       FILE_NAME(tmp, @3);
+       $$ = tmp;
+      }
+  | '^' attribute_list_opt expr_primary %prec UNARY_PREC
+      { PEUnary*tmp = new PEUnary('^', $3);
+       FILE_NAME(tmp, @3);
+       $$ = tmp;
+      }
+  | '~' '&' attribute_list_opt expr_primary %prec UNARY_PREC
+      { yyerror(@1, "error: '~' '&'  is not a valid expression. "
+               "Please use operator '~&' instead.");
+       $$ = 0;
+      }
+  | '~' '|' attribute_list_opt expr_primary %prec UNARY_PREC
+      { yyerror(@1, "error: '~' '|'  is not a valid expression. "
+               "Please use operator '~|' instead.");
+       $$ = 0;
+      }
+  | '~' '^' attribute_list_opt expr_primary %prec UNARY_PREC
+      { yyerror(@1, "error: '~' '^'  is not a valid expression. "
+               "Please use operator '~^' instead.");
+       $$ = 0;
+      }
+  | K_NAND attribute_list_opt expr_primary %prec UNARY_PREC
+      { PEUnary*tmp = new PEUnary('A', $3);
+       FILE_NAME(tmp, @3);
+       $$ = tmp;
+      }
+  | K_NOR attribute_list_opt expr_primary %prec UNARY_PREC
+      { PEUnary*tmp = new PEUnary('N', $3);
+       FILE_NAME(tmp, @3);
+       $$ = tmp;
+      }
+  | K_NXOR attribute_list_opt expr_primary %prec UNARY_PREC
+      { PEUnary*tmp = new PEUnary('X', $3);
+       FILE_NAME(tmp, @3);
+       $$ = tmp;
+      }
+  | '!' error %prec UNARY_PREC
+      { yyerror(@1, "error: Operand of unary ! "
+               "is not a primary expression.");
+       $$ = 0;
+      }
+  | '^' error %prec UNARY_PREC
+      { yyerror(@1, "error: Operand of reduction ^ "
+               "is not a primary expression.");
+       $$ = 0;
+      }
+  | expression '^' attribute_list_opt expression
+      { PEBinary*tmp = new PEBinary('^', $1, $4);
+       FILE_NAME(tmp, @2);
+       $$ = tmp;
+      }
+  | expression K_POW attribute_list_opt expression
+      { PEBinary*tmp = new PEBPower('p', $1, $4);
+       FILE_NAME(tmp, @2);
+       $$ = tmp;
+      }
+  | expression '*' attribute_list_opt expression
+      { PEBinary*tmp = new PEBinary('*', $1, $4);
+       FILE_NAME(tmp, @2);
+       $$ = tmp;
+      }
+  | expression '/' attribute_list_opt expression
+      { PEBinary*tmp = new PEBinary('/', $1, $4);
+       FILE_NAME(tmp, @2);
+       $$ = tmp;
+      }
+  | expression '%' attribute_list_opt expression
+      { PEBinary*tmp = new PEBinary('%', $1, $4);
+       FILE_NAME(tmp, @2);
+       $$ = tmp;
+      }
+  | expression '+' attribute_list_opt expression
+      { PEBinary*tmp = new PEBinary('+', $1, $4);
+       FILE_NAME(tmp, @2);
+       $$ = tmp;
+      }
+  | expression '-' attribute_list_opt expression
+      { PEBinary*tmp = new PEBinary('-', $1, $4);
+       FILE_NAME(tmp, @2);
+       $$ = tmp;
+      }
+  | expression '&' attribute_list_opt expression
+      { PEBinary*tmp = new PEBinary('&', $1, $4);
+       FILE_NAME(tmp, @2);
+       $$ = tmp;
+      }
+  | expression '|' attribute_list_opt expression
+      { PEBinary*tmp = new PEBinary('|', $1, $4);
+       FILE_NAME(tmp, @2);
+       $$ = tmp;
+      }
+  | expression K_NAND attribute_list_opt expression
+      { PEBinary*tmp = new PEBinary('A', $1, $4);
+       FILE_NAME(tmp, @2);
+       $$ = tmp;
+      }
+  | expression K_NOR attribute_list_opt expression
+      { PEBinary*tmp = new PEBinary('O', $1, $4);
+       FILE_NAME(tmp, @2);
+       $$ = tmp;
+      }
+  | expression K_NXOR attribute_list_opt expression
+      { PEBinary*tmp = new PEBinary('X', $1, $4);
+       FILE_NAME(tmp, @2);
+       $$ = tmp;
+      }
+  | expression '<' attribute_list_opt expression
+      { PEBinary*tmp = new PEBComp('<', $1, $4);
+       FILE_NAME(tmp, @2);
+       $$ = tmp;
+      }
+  | expression '>' attribute_list_opt expression
+      { PEBinary*tmp = new PEBComp('>', $1, $4);
+       FILE_NAME(tmp, @2);
+       $$ = tmp;
+      }
+  | expression K_LS attribute_list_opt expression
+      { PEBinary*tmp = new PEBShift('l', $1, $4);
+       FILE_NAME(tmp, @2);
+       $$ = tmp;
+      }
+  | expression K_RS attribute_list_opt expression
+      { PEBinary*tmp = new PEBShift('r', $1, $4);
+       FILE_NAME(tmp, @2);
+       $$ = tmp;
+      }
+  | expression K_RSS attribute_list_opt expression
+      { PEBinary*tmp = new PEBShift('R', $1, $4);
+       FILE_NAME(tmp, @2);
+       $$ = tmp;
+      }
+  | expression K_EQ attribute_list_opt expression
+      { PEBinary*tmp = new PEBComp('e', $1, $4);
+       FILE_NAME(tmp, @2);
+       $$ = tmp;
+      }
+  | expression K_CEQ attribute_list_opt expression
+      { PEBinary*tmp = new PEBComp('E', $1, $4);
+       FILE_NAME(tmp, @2);
+       $$ = tmp;
+      }
+  | expression K_WEQ attribute_list_opt expression
+      { PEBinary*tmp = new PEBComp('w', $1, $4);
+       FILE_NAME(tmp, @2);
+       $$ = tmp;
+      }
+  | expression K_LE attribute_list_opt expression
+      { PEBinary*tmp = new PEBComp('L', $1, $4);
+       FILE_NAME(tmp, @2);
+       $$ = tmp;
+      }
+  | expression K_GE attribute_list_opt expression
+      { PEBinary*tmp = new PEBComp('G', $1, $4);
+       FILE_NAME(tmp, @2);
+       $$ = tmp;
+      }
+  | expression K_NE attribute_list_opt expression
+      { PEBinary*tmp = new PEBComp('n', $1, $4);
+       FILE_NAME(tmp, @2);
+       $$ = tmp;
+      }
+  | expression K_CNE attribute_list_opt expression
+      { PEBinary*tmp = new PEBComp('N', $1, $4);
+       FILE_NAME(tmp, @2);
+       $$ = tmp;
+      }
+  | expression K_WNE attribute_list_opt expression
+      { PEBinary*tmp = new PEBComp('W', $1, $4);
+       FILE_NAME(tmp, @2);
+       $$ = tmp;
+      }
+  | expression K_LOR attribute_list_opt expression
+      { PEBinary*tmp = new PEBLogic('o', $1, $4);
+       FILE_NAME(tmp, @2);
+       $$ = tmp;
+      }
+  | expression K_LAND attribute_list_opt expression
+      { PEBinary*tmp = new PEBLogic('a', $1, $4);
+       FILE_NAME(tmp, @2);
+       $$ = tmp;
+      }
+  | expression '?' attribute_list_opt expression ':' expression
+      { PETernary*tmp = new PETernary($1, $4, $6);
+       FILE_NAME(tmp, @2);
+       $$ = tmp;
+      }
+  ;
+
+expr_mintypmax
+       : expression
+               { $$ = $1; }
+       | expression ':' expression ':' expression
+               { switch (min_typ_max_flag) {
+                     case MIN:
+                       $$ = $1;
+                       delete $3;
+                       delete $5;
+                       break;
+                     case TYP:
+                       delete $1;
+                       $$ = $3;
+                       delete $5;
+                       break;
+                     case MAX:
+                       delete $1;
+                       delete $3;
+                       $$ = $5;
+                       break;
+                 }
+                 if (min_typ_max_warn > 0) {
+                       cerr << $$->get_fileline() << ": warning: choosing ";
+                       switch (min_typ_max_flag) {
+                           case MIN:
+                             cerr << "min";
+                             break;
+                           case TYP:
+                             cerr << "typ";
+                             break;
+                           case MAX:
+                             cerr << "max";
+                             break;
+                       }
+                       cerr << " expression." << endl;
+                       min_typ_max_warn -= 1;
+                 }
+               }
+       ;
+
+
+  /* Many contexts take a comma separated list of expressions. Null
+     expressions can happen anywhere in the list, so there are two
+     extra rules in expression_list_with_nuls for parsing and
+     installing those nulls.
+
+     The expression_list_proper rules do not allow null items in the
+     expression list, so can be used where nul expressions are not allowed. */
+
+expression_list_with_nuls
+  : expression_list_with_nuls ',' expression
+      { list<PExpr*>*tmp = $1;
+       tmp->push_back($3);
+       $$ = tmp;
+      }
+  | expression
+      { list<PExpr*>*tmp = new list<PExpr*>;
+       tmp->push_back($1);
+       $$ = tmp;
+      }
+  |
+      { list<PExpr*>*tmp = new list<PExpr*>;
+        tmp->push_back(0);
+       $$ = tmp;
+      }
+  | expression_list_with_nuls ','
+      { list<PExpr*>*tmp = $1;
+       tmp->push_back(0);
+       $$ = tmp;
+      }
+       ;
+
+expression_list_proper
+  : expression_list_proper ',' expression
+      { list<PExpr*>*tmp = $1;
+        tmp->push_back($3);
+        $$ = tmp;
+      }
+  | expression
+      { list<PExpr*>*tmp = new list<PExpr*>;
+       tmp->push_back($1);
+       $$ = tmp;
+      }
+  ;
+
+expr_primary_or_typename
+  : expr_primary
+
+  /* There are a few special cases (notably $bits argument) where the
+     expression may be a type name. Let the elaborator sort this out. */
+  | TYPE_IDENTIFIER
+      { PETypename*tmp = new PETypename($1.type);
+       FILE_NAME(tmp,@1);
+       $$ = tmp;
+       delete[]$1.text;
+      }
+
+  ;
+
+expr_primary
+  : number
+      { assert($1);
+       PENumber*tmp = new PENumber($1);
+       FILE_NAME(tmp, @1);
+       $$ = tmp;
+      }
+  | REALTIME
+      { PEFNumber*tmp = new PEFNumber($1);
+       FILE_NAME(tmp, @1);
+       $$ = tmp;
+      }
+  | STRING
+      { PEString*tmp = new PEString($1);
+       FILE_NAME(tmp, @1);
+       $$ = tmp;
+      }
+  | TIME_LITERAL
+      { int unit;
+
+          based_size = 0;
+          $$         = 0;
+          if ($1 == 0 || !get_time_unit($1, unit))
+              yyerror(@1, "internal error: delay.");
+          else {
+              double p = pow(10.0, (double)(unit - pform_get_timeunit()));
+              double time = atof($1) * p;
+
+              verireal *v = new verireal(time);
+              $$ = new PEFNumber(v);
+              FILE_NAME($$, @1);
+          }
+      }
+  | SYSTEM_IDENTIFIER
+      { perm_string tn = lex_strings.make($1);
+       PECallFunction*tmp = new PECallFunction(tn);
+       FILE_NAME(tmp, @1);
+       $$ = tmp;
+       delete[]$1;
+      }
+
+  /* The hierarchy_identifier rule matches simple identifiers as well as
+     indexed arrays and part selects */
+
+  | hierarchy_identifier
+      { PEIdent*tmp = pform_new_ident(*$1);
+       FILE_NAME(tmp, @1);
+       $$ = tmp;
+       delete $1;
+      }
+
+  | PACKAGE_IDENTIFIER K_SCOPE_RES hierarchy_identifier
+      { $$ = pform_package_ident(@2, $1, $3);
+       delete $3;
+      }
+
+  /* An identifier followed by an expression list in parentheses is a
+     function call. If a system identifier, then a system function
+     call. It can also be a call to a class method (function). */
+
+  | hierarchy_identifier '(' expression_list_with_nuls ')'
+      { list<PExpr*>*expr_list = $3;
+       strip_tail_items(expr_list);
+       PECallFunction*tmp = pform_make_call_function(@1, *$1, *expr_list);
+       delete $1;
+       $$ = tmp;
+      }
+  | implicit_class_handle '.' hierarchy_identifier '(' expression_list_with_nuls ')'
+      { pform_name_t*t_name = $1;
+       while (! $3->empty()) {
+             t_name->push_back($3->front());
+             $3->pop_front();
+       }
+       list<PExpr*>*expr_list = $5;
+       strip_tail_items(expr_list);
+       PECallFunction*tmp = pform_make_call_function(@1, *t_name, *expr_list);
+       delete $1;
+       delete $3;
+       $$ = tmp;
+      }
+  | SYSTEM_IDENTIFIER '(' expression_list_proper ')'
+      { perm_string tn = lex_strings.make($1);
+       PECallFunction*tmp = new PECallFunction(tn, *$3);
+       FILE_NAME(tmp, @1);
+       delete[]$1;
+       $$ = tmp;
+      }
+  | PACKAGE_IDENTIFIER K_SCOPE_RES IDENTIFIER '(' expression_list_proper ')'
+      { perm_string use_name = lex_strings.make($3);
+       PECallFunction*tmp = new PECallFunction($1, use_name, *$5);
+       FILE_NAME(tmp, @3);
+       delete[]$3;
+       $$ = tmp;
+      }
+  | SYSTEM_IDENTIFIER '('  ')'
+      { perm_string tn = lex_strings.make($1);
+       const vector<PExpr*>empty;
+       PECallFunction*tmp = new PECallFunction(tn, empty);
+       FILE_NAME(tmp, @1);
+       delete[]$1;
+       $$ = tmp;
+       if (!gn_system_verilog()) {
+             yyerror(@1, "error: Empty function argument list requires SystemVerilog.");
+       }
+      }
+
+  | implicit_class_handle
+      { PEIdent*tmp = new PEIdent(*$1);
+       FILE_NAME(tmp,@1);
+       delete $1;
+       $$ = tmp;
+      }
+
+  | implicit_class_handle '.' hierarchy_identifier
+      { pform_name_t*t_name = $1;
+       while (! $3->empty()) {
+             t_name->push_back($3->front());
+             $3->pop_front();
+       }
+       PEIdent*tmp = new PEIdent(*t_name);
+       FILE_NAME(tmp,@1);
+       delete $1;
+       delete $3;
+       $$ = tmp;
+      }
+
+  /* Many of the VAMS built-in functions are available as builtin
+     functions with $system_function equivalents. */
+
+  | K_acos '(' expression ')'
+      { perm_string tn = perm_string::literal("$acos");
+       PECallFunction*tmp = make_call_function(tn, $3);
+       FILE_NAME(tmp,@1);
+       $$ = tmp;
+      }
+
+  | K_acosh '(' expression ')'
+      { perm_string tn = perm_string::literal("$acosh");
+       PECallFunction*tmp = make_call_function(tn, $3);
+       FILE_NAME(tmp,@1);
+       $$ = tmp;
+      }
+
+  | K_asin '(' expression ')'
+      { perm_string tn = perm_string::literal("$asin");
+       PECallFunction*tmp = make_call_function(tn, $3);
+       FILE_NAME(tmp,@1);
+       $$ = tmp;
+      }
+
+  | K_asinh '(' expression ')'
+      { perm_string tn = perm_string::literal("$asinh");
+       PECallFunction*tmp = make_call_function(tn, $3);
+       FILE_NAME(tmp,@1);
+       $$ = tmp;
+      }
+
+  | K_atan '(' expression ')'
+      { perm_string tn = perm_string::literal("$atan");
+       PECallFunction*tmp = make_call_function(tn, $3);
+       FILE_NAME(tmp,@1);
+       $$ = tmp;
+      }
+
+  | K_atanh '(' expression ')'
+      { perm_string tn = perm_string::literal("$atanh");
+       PECallFunction*tmp = make_call_function(tn, $3);
+       FILE_NAME(tmp,@1);
+       $$ = tmp;
+      }
+
+  | K_atan2 '(' expression ',' expression ')'
+      { perm_string tn = perm_string::literal("$atan2");
+       PECallFunction*tmp = make_call_function(tn, $3, $5);
+       FILE_NAME(tmp,@1);
+       $$ = tmp;
+      }
+
+  | K_ceil '(' expression ')'
+      { perm_string tn = perm_string::literal("$ceil");
+       PECallFunction*tmp = make_call_function(tn, $3);
+       FILE_NAME(tmp,@1);
+       $$ = tmp;
+      }
+
+  | K_cos '(' expression ')'
+      { perm_string tn = perm_string::literal("$cos");
+       PECallFunction*tmp = make_call_function(tn, $3);
+       FILE_NAME(tmp,@1);
+       $$ = tmp;
+      }
+
+  | K_cosh '(' expression ')'
+      { perm_string tn = perm_string::literal("$cosh");
+       PECallFunction*tmp = make_call_function(tn, $3);
+       FILE_NAME(tmp,@1);
+       $$ = tmp;
+      }
+
+  | K_exp '(' expression ')'
+      { perm_string tn = perm_string::literal("$exp");
+       PECallFunction*tmp = make_call_function(tn, $3);
+       FILE_NAME(tmp,@1);
+       $$ = tmp;
+      }
+
+  | K_floor '(' expression ')'
+      { perm_string tn = perm_string::literal("$floor");
+       PECallFunction*tmp = make_call_function(tn, $3);
+       FILE_NAME(tmp,@1);
+       $$ = tmp;
+      }
+
+  | K_hypot '(' expression ',' expression ')'
+      { perm_string tn = perm_string::literal("$hypot");
+       PECallFunction*tmp = make_call_function(tn, $3, $5);
+       FILE_NAME(tmp,@1);
+       $$ = tmp;
+      }
+
+  | K_ln '(' expression ')'
+      { perm_string tn = perm_string::literal("$ln");
+       PECallFunction*tmp = make_call_function(tn, $3);
+       FILE_NAME(tmp,@1);
+       $$ = tmp;
+      }
+
+  | K_log '(' expression ')'
+      { perm_string tn = perm_string::literal("$log10");
+       PECallFunction*tmp = make_call_function(tn, $3);
+       FILE_NAME(tmp,@1);
+       $$ = tmp;
+      }
+
+  | K_pow '(' expression ',' expression ')'
+      { perm_string tn = perm_string::literal("$pow");
+        PECallFunction*tmp = make_call_function(tn, $3, $5);
+       FILE_NAME(tmp,@1);
+       $$ = tmp;
+      }
+
+  | K_sin '(' expression ')'
+      { perm_string tn = perm_string::literal("$sin");
+       PECallFunction*tmp = make_call_function(tn, $3);
+       FILE_NAME(tmp,@1);
+       $$ = tmp;
+      }
+
+  | K_sinh '(' expression ')'
+      { perm_string tn = perm_string::literal("$sinh");
+       PECallFunction*tmp = make_call_function(tn, $3);
+       FILE_NAME(tmp,@1);
+       $$ = tmp;
+      }
+
+  | K_sqrt '(' expression ')'
+      { perm_string tn = perm_string::literal("$sqrt");
+       PECallFunction*tmp = make_call_function(tn, $3);
+       FILE_NAME(tmp,@1);
+       $$ = tmp;
+      }
+
+  | K_tan '(' expression ')'
+      { perm_string tn = perm_string::literal("$tan");
+       PECallFunction*tmp = make_call_function(tn, $3);
+       FILE_NAME(tmp,@1);
+       $$ = tmp;
+      }
+
+  | K_tanh '(' expression ')'
+      { perm_string tn = perm_string::literal("$tanh");
+       PECallFunction*tmp = make_call_function(tn, $3);
+       FILE_NAME(tmp,@1);
+       $$ = tmp;
+      }
+
+  /* These mathematical functions are conveniently expressed as unary
+     and binary expressions. They behave much like unary/binary
+     operators, even though they are parsed as functions.  */
+
+  | K_abs '(' expression ')'
+      { PEUnary*tmp = new PEUnary('m', $3);
+        FILE_NAME(tmp,@1);
+       $$ = tmp;
+      }
+
+  | K_max '(' expression ',' expression ')'
+      { PEBinary*tmp = new PEBinary('M', $3, $5);
+       FILE_NAME(tmp,@1);
+       $$ = tmp;
+      }
+
+  | K_min '(' expression ',' expression ')'
+      { PEBinary*tmp = new PEBinary('m', $3, $5);
+       FILE_NAME(tmp,@1);
+       $$ = tmp;
+      }
+
+  /* Parenthesized expressions are primaries. */
+
+  | '(' expr_mintypmax ')'
+      { $$ = $2; }
+
+  /* Various kinds of concatenation expressions. */
+
+  | '{' expression_list_proper '}'
+      { PEConcat*tmp = new PEConcat(*$2);
+       FILE_NAME(tmp, @1);
+       delete $2;
+       $$ = tmp;
+      }
+  | '{' expression '{' expression_list_proper '}' '}'
+      { PExpr*rep = $2;
+       PEConcat*tmp = new PEConcat(*$4, rep);
+       FILE_NAME(tmp, @1);
+       delete $4;
+       $$ = tmp;
+      }
+  | '{' expression '{' expression_list_proper '}' error '}'
+      { PExpr*rep = $2;
+       PEConcat*tmp = new PEConcat(*$4, rep);
+       FILE_NAME(tmp, @1);
+       delete $4;
+       $$ = tmp;
+       yyerror(@5, "error: Syntax error between internal '}' "
+               "and closing '}' of repeat concatenation.");
+       yyerrok;
+      }
+
+  | '{' '}'
+      { // This is the empty queue syntax.
+       if (gn_system_verilog()) {
+             list<PExpr*> empty_list;
+             PEConcat*tmp = new PEConcat(empty_list);
+             FILE_NAME(tmp, @1);
+             $$ = tmp;
+       } else {
+             yyerror(@1, "error: Concatenations are not allowed to be empty.");
+             $$ = 0;
+       }
+      }
+
+  /* Cast expressions are primaries */
+
+  | expr_primary "'" '(' expression ')'
+      { PExpr*base = $4;
+       if (gn_system_verilog()) {
+             PECastSize*tmp = new PECastSize($1, base);
+             FILE_NAME(tmp, @1);
+             $$ = tmp;
+       } else {
+             yyerror(@1, "error: Size cast requires SystemVerilog.");
+             $$ = base;
+       }
+      }
+
+  | simple_type_or_string "'" '(' expression ')'
+      { PExpr*base = $4;
+       if (gn_system_verilog()) {
+             PECastType*tmp = new PECastType($1, base);
+             FILE_NAME(tmp, @1);
+             $$ = tmp;
+       } else {
+             yyerror(@1, "error: Type cast requires SystemVerilog.");
+             $$ = base;
+       }
+      }
+
+  /* Aggregate literals are primaries. */
+
+  | assignment_pattern
+      { $$ = $1; }
+
+  /* SystemVerilog supports streaming concatenation */
+  | streaming_concatenation
+      { $$ = $1; }
+
+  | K_null
+      { PENull*tmp = new PENull;
+           FILE_NAME(tmp, @1);
+       $$ = tmp;
+      }
+  ;
+
+  /* A function_item_list borrows the task_port_item run to match
+     declarations of ports. We check later to make sure there are no
+     output or inout ports actually used.
+
+     The function_item is the same as tf_item_declaration. */
+function_item_list_opt
+  : function_item_list { $$ = $1; }
+  |                    { $$ = 0; }
+  ;
+
+function_item_list
+  : function_item
+      { $$ = $1; }
+  | function_item_list function_item
+      { /* */
+       if ($1 && $2) {
+             vector<pform_tf_port_t>*tmp = $1;
+             size_t s1 = tmp->size();
+             tmp->resize(s1 + $2->size());
+             for (size_t idx = 0 ; idx < $2->size() ; idx += 1)
+                   tmp->at(s1+idx) = $2->at(idx);
+             delete $2;
+             $$ = tmp;
+       } else if ($1) {
+             $$ = $1;
+       } else {
+             $$ = $2;
+       }
+      }
+ ;
+
+function_item
+  : tf_port_declaration
+      { $$ = $1; }
+  | block_item_decl
+      { $$ = 0; }
+  ;
+
+  /* A gate_instance is a module instantiation or a built in part
+     type. In any case, the gate has a set of connections to ports. */
+gate_instance
+       : IDENTIFIER '(' expression_list_with_nuls ')'
+               { lgate*tmp = new lgate;
+                 tmp->name = $1;
+                 tmp->parms = $3;
+                 tmp->file  = @1.text;
+                 tmp->lineno = @1.first_line;
+                 delete[]$1;
+                 $$ = tmp;
+               }
+
+  | IDENTIFIER dimensions '(' expression_list_with_nuls ')'
+      { lgate*tmp = new lgate;
+       list<pform_range_t>*rng = $2;
+       tmp->name = $1;
+       tmp->parms = $4;
+       tmp->range = rng->front();
+       rng->pop_front();
+       assert(rng->empty());
+       tmp->file  = @1.text;
+       tmp->lineno = @1.first_line;
+       delete[]$1;
+       delete rng;
+       $$ = tmp;
+      }
+
+       | '(' expression_list_with_nuls ')'
+               { lgate*tmp = new lgate;
+                 tmp->name = "";
+                 tmp->parms = $2;
+                 tmp->file  = @1.text;
+                 tmp->lineno = @1.first_line;
+                 $$ = tmp;
+               }
+
+  /* Degenerate modules can have no ports. */
+
+  | IDENTIFIER dimensions
+      { lgate*tmp = new lgate;
+       list<pform_range_t>*rng = $2;
+       tmp->name = $1;
+       tmp->parms = 0;
+       tmp->parms_by_name = 0;
+       tmp->range = rng->front();
+       rng->pop_front();
+       assert(rng->empty());
+       tmp->file  = @1.text;
+       tmp->lineno = @1.first_line;
+       delete[]$1;
+       delete rng;
+       $$ = tmp;
+      }
+
+  /* Modules can also take ports by port-name expressions. */
+
+  | IDENTIFIER '(' port_name_list ')'
+      { lgate*tmp = new lgate;
+       tmp->name = $1;
+       tmp->parms = 0;
+       tmp->parms_by_name = $3;
+       tmp->file  = @1.text;
+       tmp->lineno = @1.first_line;
+       delete[]$1;
+       $$ = tmp;
+      }
+
+  | IDENTIFIER dimensions '(' port_name_list ')'
+      { lgate*tmp = new lgate;
+       list<pform_range_t>*rng = $2;
+       tmp->name = $1;
+       tmp->parms = 0;
+       tmp->parms_by_name = $4;
+       tmp->range = rng->front();
+       rng->pop_front();
+       assert(rng->empty());
+       tmp->file  = @1.text;
+       tmp->lineno = @1.first_line;
+       delete[]$1;
+       delete rng;
+       $$ = tmp;
+      }
+
+       | IDENTIFIER '(' error ')'
+               { lgate*tmp = new lgate;
+                 tmp->name = $1;
+                 tmp->parms = 0;
+                 tmp->parms_by_name = 0;
+                 tmp->file  = @1.text;
+                 tmp->lineno = @1.first_line;
+                 yyerror(@2, "error: Syntax error in instance port "
+                         "expression(s).");
+                 delete[]$1;
+                 $$ = tmp;
+               }
+
+       | IDENTIFIER dimensions '(' error ')'
+               { lgate*tmp = new lgate;
+                 tmp->name = $1;
+                 tmp->parms = 0;
+                 tmp->parms_by_name = 0;
+                 tmp->file  = @1.text;
+                 tmp->lineno = @1.first_line;
+                 yyerror(@3, "error: Syntax error in instance port "
+                         "expression(s).");
+                 delete[]$1;
+                 $$ = tmp;
+               }
+       ;
+
+gate_instance_list
+       : gate_instance_list ',' gate_instance
+               { svector<lgate>*tmp1 = $1;
+                 lgate*tmp2 = $3;
+                 svector<lgate>*out = new svector<lgate> (*tmp1, *tmp2);
+                 delete tmp1;
+                 delete tmp2;
+                 $$ = out;
+               }
+       | gate_instance
+               { svector<lgate>*tmp = new svector<lgate>(1);
+                 (*tmp)[0] = *$1;
+                 delete $1;
+                 $$ = tmp;
+               }
+       ;
+
+gatetype
+       : K_and  { $$ = PGBuiltin::AND; }
+       | K_nand { $$ = PGBuiltin::NAND; }
+       | K_or   { $$ = PGBuiltin::OR; }
+       | K_nor  { $$ = PGBuiltin::NOR; }
+       | K_xor  { $$ = PGBuiltin::XOR; }
+       | K_xnor { $$ = PGBuiltin::XNO