first commit
[sv2nmigen.git] / parse.y
1
2 %{
3 /*
4  * Copyright (c) 1998-2017 Stephen Williams (steve@icarus.com)
5  * Copyright CERN 2012-2013 / Stephen Williams (steve@icarus.com)
6  *
7  *    This source code is free software; you can redistribute it
8  *    and/or modify it in source code form under the terms of the GNU
9  *    General Public License as published by the Free Software
10  *    Foundation; either version 2 of the License, or (at your option)
11  *    any later version.
12  *
13  *    This program is distributed in the hope that it will be useful,
14  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
15  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  *    GNU General Public License for more details.
17  *
18  *    You should have received a copy of the GNU General Public License
19  *    along with this program; if not, write to the Free Software
20  *    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
21  */
22
23 # include "config.h"
24
25 # include  "parse_misc.h"
26 # include  "compiler.h"
27 # include  "pform.h"
28 # include  "Statement.h"
29 # include  "PSpec.h"
30 # include  <stack>
31 # include  <cstring>
32 # include  <sstream>
33
34 class PSpecPath;
35
36 extern void lex_end_table();
37
38 static list<pform_range_t>* param_active_range = 0;
39 static bool param_active_signed = false;
40 static ivl_variable_type_t param_active_type = IVL_VT_LOGIC;
41
42 /* Port declaration lists use this structure for context. */
43 static struct {
44       NetNet::Type port_net_type;
45       NetNet::PortType port_type;
46       data_type_t* data_type;
47 } port_declaration_context = {NetNet::NONE, NetNet::NOT_A_PORT, 0};
48
49 /* Modport port declaration lists use this structure for context. */
50 enum modport_port_type_t { MP_NONE, MP_SIMPLE, MP_TF, MP_CLOCKING };
51 static struct {
52       modport_port_type_t type;
53       union {
54             NetNet::PortType direction;
55             bool is_import;
56       };
57 } last_modport_port = { MP_NONE, {NetNet::NOT_A_PORT}};
58
59 /* The task and function rules need to briefly hold the pointer to the
60    task/function that is currently in progress. */
61 static PTask* current_task = 0;
62 static PFunction* current_function = 0;
63 static stack<PBlock*> current_block_stack;
64
65 /* The variable declaration rules need to know if a lifetime has been
66    specified. */
67 static LexicalScope::lifetime_t var_lifetime;
68
69 static pform_name_t* pform_create_this(void)
70 {
71       name_component_t name (perm_string::literal("@"));
72       pform_name_t*res = new pform_name_t;
73       res->push_back(name);
74       return res;
75 }
76
77 static pform_name_t* pform_create_super(void)
78 {
79       name_component_t name (perm_string::literal("#"));
80       pform_name_t*res = new pform_name_t;
81       res->push_back(name);
82       return res;
83 }
84
85 /* This is used to keep track of the extra arguments after the notifier
86  * in the $setuphold and $recrem timing checks. This allows us to print
87  * a warning message that the delayed signals will not be created. We
88  * need to do this since not driving these signals creates real
89  * simulation issues. */
90 static unsigned args_after_notifier;
91
92 /* The rules sometimes push attributes into a global context where
93    sub-rules may grab them. This makes parser rules a little easier to
94    write in some cases. */
95 static list<named_pexpr_t>*attributes_in_context = 0;
96
97 /* Later version of bison (including 1.35) will not compile in stack
98    extension if the output is compiled with C++ and either the YYSTYPE
99    or YYLTYPE are provided by the source code. However, I can get the
100    old behavior back by defining these symbols. */
101 # define YYSTYPE_IS_TRIVIAL 1
102 # define YYLTYPE_IS_TRIVIAL 1
103
104 /* Recent version of bison expect that the user supply a
105    YYLLOC_DEFAULT macro that makes up a yylloc value from existing
106    values. I need to supply an explicit version to account for the
107    text field, that otherwise won't be copied.
108
109    The YYLLOC_DEFAULT blends the file range for the tokens of Rhs
110    rule, which has N tokens.
111 */
112 # define YYLLOC_DEFAULT(Current, Rhs, N)  do {                          \
113       if (N) {                                                          \
114             (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;      \
115             (Current).first_column = YYRHSLOC (Rhs, 1).first_column;    \
116             (Current).last_line    = YYRHSLOC (Rhs, N).last_line;       \
117             (Current).last_column  = YYRHSLOC (Rhs, N).last_column;     \
118             (Current).text         = YYRHSLOC (Rhs, 1).text;            \
119       } else {                                                          \
120             (Current).first_line   = YYRHSLOC (Rhs, 0).last_line;       \
121             (Current).first_column = YYRHSLOC (Rhs, 0).last_column;     \
122             (Current).last_line    = YYRHSLOC (Rhs, 0).last_line;       \
123             (Current).last_column  = YYRHSLOC (Rhs, 0).last_column;     \
124             (Current).text         = YYRHSLOC (Rhs, 0).text;            \
125       }                                                                 \
126    } while (0)
127
128 /*
129  * These are some common strength pairs that are used as defaults when
130  * the user is not otherwise specific.
131  */
132 static const struct str_pair_t pull_strength = { IVL_DR_PULL,  IVL_DR_PULL };
133 static const struct str_pair_t str_strength = { IVL_DR_STRONG, IVL_DR_STRONG };
134
135 static list<pform_port_t>* make_port_list(char*id, list<pform_range_t>*udims, PExpr*expr)
136 {
137       list<pform_port_t>*tmp = new list<pform_port_t>;
138       tmp->push_back(pform_port_t(lex_strings.make(id), udims, expr));
139       delete[]id;
140       return tmp;
141 }
142 static list<pform_port_t>* make_port_list(list<pform_port_t>*tmp,
143                                           char*id, list<pform_range_t>*udims, PExpr*expr)
144 {
145       tmp->push_back(pform_port_t(lex_strings.make(id), udims, expr));
146       delete[]id;
147       return tmp;
148 }
149
150 list<pform_range_t>* make_range_from_width(uint64_t wid)
151 {
152       pform_range_t range;
153       range.first  = new PENumber(new verinum(wid-1, integer_width));
154       range.second = new PENumber(new verinum((uint64_t)0, integer_width));
155
156       list<pform_range_t>*rlist = new list<pform_range_t>;
157       rlist->push_back(range);
158       return rlist;
159 }
160
161 static list<perm_string>* list_from_identifier(char*id)
162 {
163       list<perm_string>*tmp = new list<perm_string>;
164       tmp->push_back(lex_strings.make(id));
165       delete[]id;
166       return tmp;
167 }
168
169 static list<perm_string>* list_from_identifier(list<perm_string>*tmp, char*id)
170 {
171       tmp->push_back(lex_strings.make(id));
172       delete[]id;
173       return tmp;
174 }
175
176 list<pform_range_t>* copy_range(list<pform_range_t>* orig)
177 {
178       list<pform_range_t>*copy = 0;
179
180       if (orig)
181             copy = new list<pform_range_t> (*orig);
182
183       return copy;
184 }
185
186 template <class T> void append(vector<T>&out, const vector<T>&in)
187 {
188       for (size_t idx = 0 ; idx < in.size() ; idx += 1)
189             out.push_back(in[idx]);
190 }
191
192 /*
193  * Look at the list and pull null pointers off the end.
194  */
195 static void strip_tail_items(list<PExpr*>*lst)
196 {
197       while (! lst->empty()) {
198             if (lst->back() != 0)
199                   return;
200             lst->pop_back();
201       }
202 }
203
204 /*
205  * This is a shorthand for making a PECallFunction that takes a single
206  * arg. This is used by some of the code that detects built-ins.
207  */
208 static PECallFunction*make_call_function(perm_string tn, PExpr*arg)
209 {
210       vector<PExpr*> parms(1);
211       parms[0] = arg;
212       PECallFunction*tmp = new PECallFunction(tn, parms);
213       return tmp;
214 }
215
216 static PECallFunction*make_call_function(perm_string tn, PExpr*arg1, PExpr*arg2)
217 {
218       vector<PExpr*> parms(2);
219       parms[0] = arg1;
220       parms[1] = arg2;
221       PECallFunction*tmp = new PECallFunction(tn, parms);
222       return tmp;
223 }
224
225 static list<named_pexpr_t>* make_named_numbers(perm_string name, long first, long last, PExpr*val =0)
226 {
227       list<named_pexpr_t>*lst = new list<named_pexpr_t>;
228       named_pexpr_t tmp;
229         // We are counting up.
230       if (first <= last) {
231             for (long idx = first ; idx <= last ; idx += 1) {
232                   ostringstream buf;
233                   buf << name.str() << idx << ends;
234                   tmp.name = lex_strings.make(buf.str());
235                   tmp.parm = val;
236                   val = 0;
237                   lst->push_back(tmp);
238             }
239         // We are counting down.
240       } else {
241             for (long idx = first ; idx >= last ; idx -= 1) {
242                   ostringstream buf;
243                   buf << name.str() << idx << ends;
244                   tmp.name = lex_strings.make(buf.str());
245                   tmp.parm = val;
246                   val = 0;
247                   lst->push_back(tmp);
248             }
249       }
250       return lst;
251 }
252
253 static list<named_pexpr_t>* make_named_number(perm_string name, PExpr*val =0)
254 {
255       list<named_pexpr_t>*lst = new list<named_pexpr_t>;
256       named_pexpr_t tmp;
257       tmp.name = name;
258       tmp.parm = val;
259       lst->push_back(tmp);
260       return lst;
261 }
262
263 static long check_enum_seq_value(const YYLTYPE&loc, verinum *arg, bool zero_ok)
264 {
265       long value = 1;
266         // We can never have an undefined value in an enumeration name
267         // declaration sequence.
268       if (! arg->is_defined()) {
269             yyerror(loc, "error: undefined value used in enum name sequence.");
270         // We can never have a negative value in an enumeration name
271         // declaration sequence.
272       } else if (arg->is_negative()) {
273             yyerror(loc, "error: negative value used in enum name sequence.");
274       } else {
275             value = arg->as_ulong();
276               // We cannot have a zero enumeration name declaration count.
277             if (! zero_ok && (value == 0)) {
278                   yyerror(loc, "error: zero count used in enum name sequence.");
279                   value = 1;
280             }
281       }
282       return value;
283 }
284
285 static void current_task_set_statement(const YYLTYPE&loc, vector<Statement*>*s)
286 {
287       if (s == 0) {
288               /* if the statement list is null, then the parser
289                  detected the case that there are no statements in the
290                  task. If this is SystemVerilog, handle it as an
291                  an empty block. */
292             if (!gn_system_verilog()) {
293                   yyerror(loc, "error: Support for empty tasks requires SystemVerilog.");
294             }
295             PBlock*tmp = new PBlock(PBlock::BL_SEQ);
296             FILE_NAME(tmp, loc);
297             current_task->set_statement(tmp);
298             return;
299       }
300       assert(s);
301
302         /* An empty vector represents one or more null statements. Handle
303            this as a simple null statement. */
304       if (s->empty())
305             return;
306
307         /* A vector of 1 is handled as a simple statement. */
308       if (s->size() == 1) {
309             current_task->set_statement((*s)[0]);
310             return;
311       }
312
313       if (!gn_system_verilog()) {
314             yyerror(loc, "error: Task body with multiple statements requires SystemVerilog.");
315       }
316
317       PBlock*tmp = new PBlock(PBlock::BL_SEQ);
318       FILE_NAME(tmp, loc);
319       tmp->set_statement(*s);
320       current_task->set_statement(tmp);
321 }
322
323 static void current_function_set_statement(const YYLTYPE&loc, vector<Statement*>*s)
324 {
325       if (s == 0) {
326               /* if the statement list is null, then the parser
327                  detected the case that there are no statements in the
328                  task. If this is SystemVerilog, handle it as an
329                  an empty block. */
330             if (!gn_system_verilog()) {
331                   yyerror(loc, "error: Support for empty functions requires SystemVerilog.");
332             }
333             PBlock*tmp = new PBlock(PBlock::BL_SEQ);
334             FILE_NAME(tmp, loc);
335             current_function->set_statement(tmp);
336             return;
337       }
338       assert(s);
339
340         /* An empty vector represents one or more null statements. Handle
341            this as a simple null statement. */
342       if (s->empty())
343             return;
344
345         /* A vector of 1 is handled as a simple statement. */
346       if (s->size() == 1) {
347             current_function->set_statement((*s)[0]);
348             return;
349       }
350
351       if (!gn_system_verilog()) {
352             yyerror(loc, "error: Function body with multiple statements requires SystemVerilog.");
353       }
354
355       PBlock*tmp = new PBlock(PBlock::BL_SEQ);
356       FILE_NAME(tmp, loc);
357       tmp->set_statement(*s);
358       current_function->set_statement(tmp);
359 }
360
361 %}
362
363 %union {
364       bool flag;
365
366       char letter;
367       int  int_val;
368
369         /* text items are C strings allocated by the lexor using
370            strdup. They can be put into lists with the texts type. */
371       char*text;
372       list<perm_string>*perm_strings;
373
374       list<pform_port_t>*port_list;
375
376       vector<pform_tf_port_t>* tf_ports;
377
378       pform_name_t*pform_name;
379
380       ivl_discipline_t discipline;
381
382       hname_t*hier;
383
384       list<string>*strings;
385
386       struct str_pair_t drive;
387
388       PCase::Item*citem;
389       svector<PCase::Item*>*citems;
390
391       lgate*gate;
392       svector<lgate>*gates;
393
394       Module::port_t *mport;
395       LexicalScope::range_t* value_range;
396       vector<Module::port_t*>*mports;
397
398       named_number_t* named_number;
399       list<named_number_t>* named_numbers;
400
401       named_pexpr_t*named_pexpr;
402       list<named_pexpr_t>*named_pexprs;
403       struct parmvalue_t*parmvalue;
404       list<pform_range_t>*ranges;
405
406       PExpr*expr;
407       list<PExpr*>*exprs;
408
409       svector<PEEvent*>*event_expr;
410
411       NetNet::Type nettype;
412       PGBuiltin::Type gatetype;
413       NetNet::PortType porttype;
414       ivl_variable_type_t vartype;
415       PBlock::BL_TYPE join_keyword;
416
417       PWire*wire;
418       vector<PWire*>*wires;
419
420       PEventStatement*event_statement;
421       Statement*statement;
422       vector<Statement*>*statement_list;
423
424       net_decl_assign_t*net_decl_assign;
425       enum_type_t*enum_type;
426
427       decl_assignment_t*decl_assignment;
428       list<decl_assignment_t*>*decl_assignments;
429
430       struct_member_t*struct_member;
431       list<struct_member_t*>*struct_members;
432       struct_type_t*struct_type;
433
434       data_type_t*data_type;
435       class_type_t*class_type;
436       real_type_t::type_t real_type;
437       property_qualifier_t property_qualifier;
438       PPackage*package;
439
440       struct {
441             char*text;
442             data_type_t*type;
443       } type_identifier;
444
445       struct {
446             data_type_t*type;
447             list<PExpr*>*exprs;
448       } class_declaration_extends;
449
450       verinum* number;
451
452       verireal* realtime;
453
454       PSpecPath* specpath;
455       list<index_component_t> *dimensions;
456
457       LexicalScope::lifetime_t lifetime;
458 };
459
460 %token <text>      IDENTIFIER SYSTEM_IDENTIFIER STRING TIME_LITERAL
461 %token <type_identifier> TYPE_IDENTIFIER
462 %token <package>   PACKAGE_IDENTIFIER
463 %token <discipline> DISCIPLINE_IDENTIFIER
464 %token <text>   PATHPULSE_IDENTIFIER
465 %token <number> BASED_NUMBER DEC_NUMBER UNBASED_NUMBER
466 %token <realtime> REALTIME
467 %token K_PLUS_EQ K_MINUS_EQ K_INCR K_DECR
468 %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
469  /* K_CONTRIBUTE is <+, the contribution assign. */
470 %token K_CONTRIBUTE
471 %token K_PO_POS K_PO_NEG K_POW
472 %token K_PSTAR K_STARP K_DOTSTAR
473 %token K_LOR K_LAND K_NAND K_NOR K_NXOR K_TRIGGER
474 %token K_SCOPE_RES
475 %token K_edge_descriptor
476
477  /* The base tokens from 1364-1995. */
478 %token K_always K_and K_assign K_begin K_buf K_bufif0 K_bufif1 K_case
479 %token K_casex K_casez K_cmos K_deassign K_default K_defparam K_disable
480 %token K_edge K_else K_end K_endcase K_endfunction K_endmodule
481 %token K_endprimitive K_endspecify K_endtable K_endtask K_event K_for
482 %token K_force K_forever K_fork K_function K_highz0 K_highz1 K_if
483 %token K_ifnone K_initial K_inout K_input K_integer K_join K_large
484 %token K_macromodule K_medium K_module K_nand K_negedge K_nmos K_nor
485 %token K_not K_notif0 K_notif1 K_or K_output K_parameter K_pmos K_posedge
486 %token K_primitive K_pull0 K_pull1 K_pulldown K_pullup K_rcmos K_real
487 %token K_realtime K_reg K_release K_repeat K_rnmos K_rpmos K_rtran
488 %token K_rtranif0 K_rtranif1 K_scalared K_small K_specify K_specparam
489 %token K_strong0 K_strong1 K_supply0 K_supply1 K_table K_task K_time
490 %token K_tran K_tranif0 K_tranif1 K_tri K_tri0 K_tri1 K_triand K_trior
491 %token K_trireg K_vectored K_wait K_wand K_weak0 K_weak1 K_while K_wire
492 %token K_wor K_xnor K_xor
493
494 %token K_Shold K_Snochange K_Speriod K_Srecovery K_Ssetup K_Ssetuphold
495 %token K_Sskew K_Swidth
496
497  /* Icarus specific tokens. */
498 %token KK_attribute K_bool K_logic
499
500  /* The new tokens from 1364-2001. */
501 %token K_automatic K_endgenerate K_generate K_genvar K_localparam
502 %token K_noshowcancelled K_pulsestyle_onevent K_pulsestyle_ondetect
503 %token K_showcancelled K_signed K_unsigned
504
505 %token K_Sfullskew K_Srecrem K_Sremoval K_Stimeskew
506
507  /* The 1364-2001 configuration tokens. */
508 %token K_cell K_config K_design K_endconfig K_incdir K_include K_instance
509 %token K_liblist K_library K_use
510
511  /* The new tokens from 1364-2005. */
512 %token K_wone K_uwire
513
514  /* The new tokens from 1800-2005. */
515 %token K_alias K_always_comb K_always_ff K_always_latch K_assert
516 %token K_assume K_before K_bind K_bins K_binsof K_bit K_break K_byte
517 %token K_chandle K_class K_clocking K_const K_constraint K_context
518 %token K_continue K_cover K_covergroup K_coverpoint K_cross K_dist K_do
519 %token K_endclass K_endclocking K_endgroup K_endinterface K_endpackage
520 %token K_endprogram K_endproperty K_endsequence K_enum K_expect K_export
521 %token K_extends K_extern K_final K_first_match K_foreach K_forkjoin
522 %token K_iff K_ignore_bins K_illegal_bins K_import K_inside K_int
523  /* Icarus already has defined "logic" above! */
524 %token K_interface K_intersect K_join_any K_join_none K_local
525 %token K_longint K_matches K_modport K_new K_null K_package K_packed
526 %token K_priority K_program K_property K_protected K_pure K_rand K_randc
527 %token K_randcase K_randsequence K_ref K_return K_sequence K_shortint
528 %token K_shortreal K_solve K_static K_string K_struct K_super
529 %token K_tagged K_this K_throughout K_timeprecision K_timeunit K_type
530 %token K_typedef K_union K_unique K_var K_virtual K_void K_wait_order
531 %token K_wildcard K_with K_within
532
533  /* The new tokens from 1800-2009. */
534 %token K_accept_on K_checker K_endchecker K_eventually K_global K_implies
535 %token K_let K_nexttime K_reject_on K_restrict K_s_always K_s_eventually
536 %token K_s_nexttime K_s_until K_s_until_with K_strong K_sync_accept_on
537 %token K_sync_reject_on K_unique0 K_until K_until_with K_untyped K_weak
538
539  /* The new tokens from 1800-2012. */
540 %token K_implements K_interconnect K_nettype K_soft
541
542  /* The new tokens for Verilog-AMS 2.3. */
543 %token K_above K_abs K_absdelay K_abstol K_access K_acos K_acosh
544  /* 1800-2005 has defined "assert" above! */
545 %token K_ac_stim K_aliasparam K_analog K_analysis K_asin K_asinh
546 %token K_atan K_atan2 K_atanh K_branch K_ceil K_connect K_connectmodule
547 %token K_connectrules K_continuous K_cos K_cosh K_ddt K_ddt_nature K_ddx
548 %token K_discipline K_discrete K_domain K_driver_update K_endconnectrules
549 %token K_enddiscipline K_endnature K_endparamset K_exclude K_exp
550 %token K_final_step K_flicker_noise K_floor K_flow K_from K_ground
551 %token K_hypot K_idt K_idtmod K_idt_nature K_inf K_initial_step
552 %token K_laplace_nd K_laplace_np K_laplace_zd K_laplace_zp
553 %token K_last_crossing K_limexp K_ln K_log K_max K_merged K_min K_nature
554 %token K_net_resolution K_noise_table K_paramset K_potential K_pow
555  /* 1800-2005 has defined "string" above! */
556 %token K_resolveto K_sin K_sinh K_slew K_split K_sqrt K_tan K_tanh
557 %token K_timer K_transition K_units K_white_noise K_wreal
558 %token K_zi_nd K_zi_np K_zi_zd K_zi_zp
559
560 %type <flag>    from_exclude block_item_decls_opt
561 %type <number>  number pos_neg_number
562 %type <flag>    signing unsigned_signed_opt signed_unsigned_opt
563 %type <flag>    import_export
564 %type <flag>    K_packed_opt K_reg_opt K_static_opt K_virtual_opt
565 %type <flag>    udp_reg_opt edge_operator
566 %type <drive>   drive_strength drive_strength_opt dr_strength0 dr_strength1
567 %type <letter>  udp_input_sym udp_output_sym
568 %type <text>    udp_input_list udp_sequ_entry udp_comb_entry
569 %type <perm_strings> udp_input_declaration_list
570 %type <strings> udp_entry_list udp_comb_entry_list udp_sequ_entry_list
571 %type <strings> udp_body
572 %type <perm_strings> udp_port_list
573 %type <wires>   udp_port_decl udp_port_decls
574 %type <statement> udp_initial udp_init_opt
575 %type <expr>    udp_initial_expr_opt
576
577 %type <text> register_variable net_variable event_variable endlabel_opt class_declaration_endlabel_opt
578 %type <perm_strings> register_variable_list net_variable_list event_variable_list
579 %type <perm_strings> list_of_identifiers loop_variables
580 %type <port_list> list_of_port_identifiers list_of_variable_port_identifiers
581
582 %type <net_decl_assign> net_decl_assign net_decl_assigns
583
584 %type <mport> port port_opt port_reference port_reference_list
585 %type <mport> port_declaration
586 %type <mports> list_of_ports module_port_list_opt list_of_port_declarations module_attribute_foreign
587 %type <value_range> parameter_value_range parameter_value_ranges
588 %type <value_range> parameter_value_ranges_opt
589 %type <expr> tf_port_item_expr_opt value_range_expression
590
591 %type <named_pexprs> enum_name_list enum_name
592 %type <enum_type> enum_data_type
593
594 %type <tf_ports> function_item function_item_list function_item_list_opt
595 %type <tf_ports> task_item task_item_list task_item_list_opt
596 %type <tf_ports> tf_port_declaration tf_port_item tf_port_item_list tf_port_list tf_port_list_opt
597
598 %type <named_pexpr> modport_simple_port port_name parameter_value_byname
599 %type <named_pexprs> port_name_list parameter_value_byname_list
600
601 %type <named_pexpr> attribute
602 %type <named_pexprs> attribute_list attribute_instance_list attribute_list_opt
603
604 %type <citem>  case_item
605 %type <citems> case_items
606
607 %type <gate>  gate_instance
608 %type <gates> gate_instance_list
609
610 %type <pform_name> hierarchy_identifier implicit_class_handle
611 %type <expr>  assignment_pattern expression expr_mintypmax
612 %type <expr>  expr_primary_or_typename expr_primary
613 %type <expr>  class_new dynamic_array_new
614 %type <expr>  inc_or_dec_expression inside_expression lpvalue
615 %type <expr>  branch_probe_expression streaming_concatenation
616 %type <expr>  delay_value delay_value_simple
617 %type <exprs> delay1 delay3 delay3_opt delay_value_list
618 %type <exprs> expression_list_with_nuls expression_list_proper
619 %type <exprs> cont_assign cont_assign_list
620
621 %type <decl_assignment> variable_decl_assignment
622 %type <decl_assignments> list_of_variable_decl_assignments
623
624 %type <data_type>  data_type data_type_or_implicit data_type_or_implicit_or_void
625 %type <data_type>  simple_type_or_string
626 %type <class_type> class_identifier
627 %type <struct_member>  struct_union_member
628 %type <struct_members> struct_union_member_list
629 %type <struct_type>    struct_data_type
630
631 %type <class_declaration_extends> class_declaration_extends_opt
632
633 %type <property_qualifier> class_item_qualifier property_qualifier
634 %type <property_qualifier> class_item_qualifier_list property_qualifier_list
635 %type <property_qualifier> class_item_qualifier_opt property_qualifier_opt
636 %type <property_qualifier> random_qualifier
637
638 %type <ranges> variable_dimension
639 %type <ranges> dimensions_opt dimensions
640
641 %type <nettype>  net_type net_type_opt
642 %type <gatetype> gatetype switchtype
643 %type <porttype> port_direction port_direction_opt
644 %type <vartype> bit_logic bit_logic_opt
645 %type <vartype> integer_vector_type
646 %type <parmvalue> parameter_value_opt
647
648 %type <event_expr> event_expression_list
649 %type <event_expr> event_expression
650 %type <event_statement> event_control
651 %type <statement> statement statement_item statement_or_null
652 %type <statement> compressed_statement
653 %type <statement> loop_statement for_step jump_statement
654 %type <statement> procedural_assertion_statement
655 %type <statement_list> statement_or_null_list statement_or_null_list_opt
656
657 %type <statement> analog_statement
658
659 %type <join_keyword> join_keyword
660
661 %type <letter> spec_polarity
662 %type <perm_strings>  specify_path_identifiers
663
664 %type <specpath> specify_simple_path specify_simple_path_decl
665 %type <specpath> specify_edge_path specify_edge_path_decl
666
667 %type <real_type> non_integer_type
668 %type <int_val> atom2_type
669 %type <int_val> module_start module_end
670
671 %type <lifetime> lifetime lifetime_opt
672
673 %token K_TAND
674 %right K_PLUS_EQ K_MINUS_EQ K_MUL_EQ K_DIV_EQ K_MOD_EQ K_AND_EQ K_OR_EQ
675 %right K_XOR_EQ K_LS_EQ K_RS_EQ K_RSS_EQ
676 %right '?' ':' K_inside
677 %left K_LOR
678 %left K_LAND
679 %left '|'
680 %left '^' K_NXOR K_NOR
681 %left '&' K_NAND
682 %left K_EQ K_NE K_CEQ K_CNE K_WEQ K_WNE
683 %left K_GE K_LE '<' '>'
684 %left K_LS K_RS K_RSS
685 %left '+' '-'
686 %left '*' '/' '%'
687 %left K_POW
688 %left UNARY_PREC
689
690
691  /* to resolve dangling else ambiguity. */
692 %nonassoc less_than_K_else
693 %nonassoc K_else
694
695  /* to resolve exclude (... ambiguity */
696 %nonassoc '('
697 %nonassoc K_exclude
698
699  /* to resolve timeunits declaration/redeclaration ambiguity */
700 %nonassoc no_timeunits_declaration
701 %nonassoc one_timeunits_declaration
702 %nonassoc K_timeunit K_timeprecision
703
704 %%
705
706
707   /* IEEE1800-2005: A.1.2 */
708   /* source_text ::= [ timeunits_declaration ] { description } */
709 source_text
710   : timeunits_declaration_opt
711       { pform_set_scope_timescale(yyloc); }
712     description_list
713   | /* empty */
714   ;
715
716 assertion_item /* IEEE1800-2012: A.6.10 */
717   : concurrent_assertion_item
718   ;
719
720 assignment_pattern /* IEEE1800-2005: A.6.7.1 */
721   : K_LP expression_list_proper '}'
722       { PEAssignPattern*tmp = new PEAssignPattern(*$2);
723         FILE_NAME(tmp, @1);
724         delete $2;
725         $$ = tmp;
726       }
727   | K_LP '}'
728       { PEAssignPattern*tmp = new PEAssignPattern;
729         FILE_NAME(tmp, @1);
730         $$ = tmp;
731       }
732   ;
733
734   /* Some rules have a ... [ block_identifier ':' ] ... part. This
735      implements it in a LALR way. */
736 block_identifier_opt /* */
737   : IDENTIFIER ':'
738   |
739   ;
740
741 class_declaration /* IEEE1800-2005: A.1.2 */
742   : K_virtual_opt K_class lifetime_opt class_identifier class_declaration_extends_opt ';'
743       { pform_start_class_declaration(@2, $4, $5.type, $5.exprs, $3); }
744     class_items_opt K_endclass
745       { // Process a class.
746         pform_end_class_declaration(@9);
747       }
748     class_declaration_endlabel_opt
749       { // Wrap up the class.
750         if ($11 && $4 && $4->name != $11) {
751               yyerror(@11, "error: Class end label doesn't match class name.");
752               delete[]$11;
753         }
754       }
755   ;
756
757 class_constraint /* IEEE1800-2005: A.1.8 */
758   : constraint_prototype
759   | constraint_declaration
760   ;
761
762 class_identifier
763   : IDENTIFIER
764       { // Create a synthetic typedef for the class name so that the
765         // lexor detects the name as a type.
766         perm_string name = lex_strings.make($1);
767         class_type_t*tmp = new class_type_t(name);
768         FILE_NAME(tmp, @1);
769         pform_set_typedef(name, tmp, NULL);
770         delete[]$1;
771         $$ = tmp;
772       }
773   | TYPE_IDENTIFIER
774       { class_type_t*tmp = dynamic_cast<class_type_t*>($1.type);
775         if (tmp == 0) {
776               yyerror(@1, "Type name \"%s\"is not a predeclared class name.", $1.text);
777         }
778         delete[]$1.text;
779         $$ = tmp;
780       }
781   ;
782
783   /* The endlabel after a class declaration is a little tricky because
784      the class name is detected by the lexor as a TYPE_IDENTIFIER if it
785      does indeed match a name. */
786 class_declaration_endlabel_opt
787   : ':' TYPE_IDENTIFIER
788       { class_type_t*tmp = dynamic_cast<class_type_t*> ($2.type);
789         if (tmp == 0) {
790               yyerror(@2, "error: class declaration endlabel \"%s\" is not a class name\n", $2.text);
791               $$ = 0;
792         } else {
793               $$ = strdupnew(tmp->name.str());
794         }
795         delete[]$2.text;
796       }
797   | ':' IDENTIFIER
798       { $$ = $2; }
799   |
800       { $$ = 0; }
801   ;
802
803   /* This rule implements [ extends class_type ] in the
804      class_declaration. It is not a rule of its own in the LRM.
805
806      Note that for this to be correct, the identifier after the
807      extends keyword must be a class name. Therefore, match
808      TYPE_IDENTIFIER instead of IDENTIFIER, and this rule will return
809      a data_type. */
810
811 class_declaration_extends_opt /* IEEE1800-2005: A.1.2 */
812   : K_extends TYPE_IDENTIFIER
813       { $$.type = $2.type;
814         $$.exprs= 0;
815         delete[]$2.text;
816       }
817   | K_extends TYPE_IDENTIFIER '(' expression_list_with_nuls ')'
818       { $$.type  = $2.type;
819         $$.exprs = $4;
820         delete[]$2.text;
821       }
822   |
823       { $$.type = 0; $$.exprs = 0; }
824   ;
825
826   /* The class_items_opt and class_items rules together implement the
827      rule snippet { class_item } (zero or more class_item) of the
828      class_declaration. */
829 class_items_opt /* IEEE1800-2005: A.1.2 */
830   : class_items
831   |
832   ;
833
834 class_items /* IEEE1800-2005: A.1.2 */
835   : class_items class_item
836   | class_item
837   ;
838
839 class_item /* IEEE1800-2005: A.1.8 */
840
841     /* IEEE1800 A.1.8: class_constructor_declaration */
842   : method_qualifier_opt K_function K_new
843       { assert(current_function==0);
844         current_function = pform_push_constructor_scope(@3);
845       }
846     '(' tf_port_list_opt ')' ';'
847     function_item_list_opt
848     statement_or_null_list_opt
849     K_endfunction endnew_opt
850       { current_function->set_ports($6);
851         pform_set_constructor_return(current_function);
852         pform_set_this_class(@3, current_function);
853         current_function_set_statement(@3, $10);
854         pform_pop_scope();
855         current_function = 0;
856       }
857
858     /* Class properties... */
859
860   | property_qualifier_opt data_type list_of_variable_decl_assignments ';'
861       { pform_class_property(@2, $1, $2, $3); }
862
863   | K_const class_item_qualifier_opt data_type list_of_variable_decl_assignments ';'
864       { pform_class_property(@1, $2 | property_qualifier_t::make_const(), $3, $4); }
865
866     /* Class methods... */
867
868   | method_qualifier_opt task_declaration
869       { /* The task_declaration rule puts this into the class */ }
870
871   | method_qualifier_opt function_declaration
872       { /* The function_declaration rule puts this into the class */ }
873
874     /* External class method definitions... */
875
876   | K_extern method_qualifier_opt K_function K_new ';'
877       { yyerror(@1, "sorry: External constructors are not yet supported."); }
878   | K_extern method_qualifier_opt K_function K_new '(' tf_port_list_opt ')' ';'
879       { yyerror(@1, "sorry: External constructors are not yet supported."); }
880   | K_extern method_qualifier_opt K_function data_type_or_implicit_or_void
881     IDENTIFIER ';'
882       { yyerror(@1, "sorry: External methods are not yet supported.");
883         delete[] $5;
884       }
885   | K_extern method_qualifier_opt K_function data_type_or_implicit_or_void
886     IDENTIFIER '(' tf_port_list_opt ')' ';'
887       { yyerror(@1, "sorry: External methods are not yet supported.");
888         delete[] $5;
889       }
890   | K_extern method_qualifier_opt K_task IDENTIFIER ';'
891       { yyerror(@1, "sorry: External methods are not yet supported.");
892         delete[] $4;
893       }
894   | K_extern method_qualifier_opt K_task IDENTIFIER '(' tf_port_list_opt ')' ';'
895       { yyerror(@1, "sorry: External methods are not yet supported.");
896         delete[] $4;
897       }
898
899     /* Class constraints... */
900
901   | class_constraint
902
903     /* Here are some error matching rules to help recover from various
904        syntax errors within a class declaration. */
905
906   | property_qualifier_opt data_type error ';'
907       { yyerror(@3, "error: Errors in variable names after data type.");
908         yyerrok;
909       }
910
911   | property_qualifier_opt IDENTIFIER error ';'
912       { yyerror(@3, "error: %s doesn't name a type.", $2);
913         yyerrok;
914       }
915
916   | method_qualifier_opt K_function K_new error K_endfunction endnew_opt
917       { yyerror(@1, "error: I give up on this class constructor declaration.");
918         yyerrok;
919       }
920
921   | error ';'
922       { yyerror(@2, "error: invalid class item.");
923         yyerrok;
924       }
925
926   ;
927
928 class_item_qualifier /* IEEE1800-2005 A.1.8 */
929   : K_static     { $$ = property_qualifier_t::make_static(); }
930   | K_protected  { $$ = property_qualifier_t::make_protected(); }
931   | K_local      { $$ = property_qualifier_t::make_local(); }
932   ;
933
934 class_item_qualifier_list
935   : class_item_qualifier_list class_item_qualifier { $$ = $1 | $2; }
936   | class_item_qualifier { $$ = $1; }
937   ;
938
939 class_item_qualifier_opt
940   : class_item_qualifier_list { $$ = $1; }
941   | { $$ = property_qualifier_t::make_none(); }
942   ;
943
944 class_new /* IEEE1800-2005 A.2.4 */
945   : K_new '(' expression_list_with_nuls ')'
946       { list<PExpr*>*expr_list = $3;
947         strip_tail_items(expr_list);
948         PENewClass*tmp = new PENewClass(*expr_list);
949         FILE_NAME(tmp, @1);
950         delete $3;
951         $$ = tmp;
952       }
953   | K_new hierarchy_identifier
954       { PEIdent*tmpi = new PEIdent(*$2);
955         FILE_NAME(tmpi, @2);
956         PENewCopy*tmp = new PENewCopy(tmpi);
957         FILE_NAME(tmp, @1);
958         delete $2;
959         $$ = tmp;
960       }
961   | K_new
962       { PENewClass*tmp = new PENewClass;
963         FILE_NAME(tmp, @1);
964         $$ = tmp;
965       }
966   ;
967
968   /* The concurrent_assertion_item pulls together the
969      concurrent_assertion_statement and checker_instantiation rules. */
970
971 concurrent_assertion_item /* IEEE1800-2012 A.2.10 */
972   : block_identifier_opt K_assert K_property '(' property_spec ')' statement_or_null
973       { /* */
974         if (gn_assertions_flag) {
975               yyerror(@2, "sorry: concurrent_assertion_item not supported."
976                       " Try -gno-assertion to turn this message off.");
977         }
978       }
979   | block_identifier_opt K_assert K_property '(' error ')' statement_or_null
980       { yyerrok;
981         yyerror(@2, "error: Error in property_spec of concurrent assertion item.");
982       }
983   ;
984
985 constraint_block_item /* IEEE1800-2005 A.1.9 */
986   : constraint_expression
987   ;
988
989 constraint_block_item_list
990   : constraint_block_item_list constraint_block_item
991   | constraint_block_item
992   ;
993
994 constraint_block_item_list_opt
995   :
996   | constraint_block_item_list
997   ;
998
999 constraint_declaration /* IEEE1800-2005: A.1.9 */
1000   : K_static_opt K_constraint IDENTIFIER '{' constraint_block_item_list_opt '}'
1001       { yyerror(@2, "sorry: Constraint declarations not supported."); }
1002
1003   /* Error handling rules... */
1004
1005   | K_static_opt K_constraint IDENTIFIER '{' error '}'
1006       { yyerror(@4, "error: Errors in the constraint block item list."); }
1007   ;
1008
1009 constraint_expression /* IEEE1800-2005 A.1.9 */
1010   : expression ';'
1011   | expression K_dist '{' '}' ';'
1012   | expression K_TRIGGER constraint_set
1013   | K_if '(' expression ')' constraint_set %prec less_than_K_else
1014   | K_if '(' expression ')' constraint_set K_else constraint_set
1015   | K_foreach '(' IDENTIFIER '[' loop_variables ']' ')' constraint_set
1016   ;
1017
1018 constraint_expression_list /* */
1019   : constraint_expression_list constraint_expression
1020   | constraint_expression
1021   ;
1022
1023 constraint_prototype /* IEEE1800-2005: A.1.9 */
1024   : K_static_opt K_constraint IDENTIFIER ';'
1025       { yyerror(@2, "sorry: Constraint prototypes not supported."); }
1026   ;
1027
1028 constraint_set /* IEEE1800-2005 A.1.9 */
1029   : constraint_expression
1030   | '{' constraint_expression_list '}'
1031   ;
1032
1033 data_declaration /* IEEE1800-2005: A.2.1.3 */
1034   : attribute_list_opt data_type_or_implicit list_of_variable_decl_assignments ';'
1035       { data_type_t*data_type = $2;
1036         if (data_type == 0) {
1037               data_type = new vector_type_t(IVL_VT_LOGIC, false, 0);
1038               FILE_NAME(data_type, @2);
1039         }
1040         pform_makewire(@2, 0, str_strength, $3, NetNet::IMPLICIT_REG, data_type);
1041       }
1042   ;
1043
1044 data_type /* IEEE1800-2005: A.2.2.1 */
1045   : integer_vector_type unsigned_signed_opt dimensions_opt
1046       { ivl_variable_type_t use_vtype = $1;
1047         bool reg_flag = false;
1048         if (use_vtype == IVL_VT_NO_TYPE) {
1049               use_vtype = IVL_VT_LOGIC;
1050               reg_flag = true;
1051         }
1052         vector_type_t*tmp = new vector_type_t(use_vtype, $2, $3);
1053         tmp->reg_flag = reg_flag;
1054         FILE_NAME(tmp, @1);
1055         $$ = tmp;
1056       }
1057   | non_integer_type
1058       { real_type_t*tmp = new real_type_t($1);
1059         FILE_NAME(tmp, @1);
1060         $$ = tmp;
1061       }
1062   | struct_data_type
1063       { if (!$1->packed_flag) {
1064               yyerror(@1, "sorry: Unpacked structs not supported.");
1065         }
1066         $$ = $1;
1067       }
1068   | enum_data_type
1069       { $$ = $1; }
1070   | atom2_type signed_unsigned_opt
1071       { atom2_type_t*tmp = new atom2_type_t($1, $2);
1072         FILE_NAME(tmp, @1);
1073         $$ = tmp;
1074       }
1075   | K_integer signed_unsigned_opt
1076       { list<pform_range_t>*pd = make_range_from_width(integer_width);
1077         vector_type_t*tmp = new vector_type_t(IVL_VT_LOGIC, $2, pd);
1078         tmp->reg_flag = true;
1079         tmp->integer_flag = true;
1080         $$ = tmp;
1081       }
1082   | K_time
1083       { list<pform_range_t>*pd = make_range_from_width(64);
1084         vector_type_t*tmp = new vector_type_t(IVL_VT_LOGIC, false, pd);
1085         tmp->reg_flag = !gn_system_verilog();
1086         $$ = tmp;
1087       }
1088   | TYPE_IDENTIFIER dimensions_opt
1089       { if ($2) {
1090               parray_type_t*tmp = new parray_type_t($1.type, $2);
1091               FILE_NAME(tmp, @1);
1092               $$ = tmp;
1093         } else $$ = $1.type;
1094         delete[]$1.text;
1095       }
1096   | PACKAGE_IDENTIFIER K_SCOPE_RES
1097       { lex_in_package_scope($1); }
1098     TYPE_IDENTIFIER
1099       { lex_in_package_scope(0);
1100         $$ = $4.type;
1101         delete[]$4.text;
1102       }
1103   | K_string
1104       { string_type_t*tmp = new string_type_t;
1105         FILE_NAME(tmp, @1);
1106         $$ = tmp;
1107       }
1108   ;
1109
1110   /* The data_type_or_implicit rule is a little more complex then the
1111      rule documented in the IEEE format syntax in order to allow for
1112      signaling the special case that the data_type is completely
1113      absent. The context may need that information to decide to resort
1114      to left context. */
1115
1116 data_type_or_implicit /* IEEE1800-2005: A.2.2.1 */
1117   : data_type
1118       { $$ = $1; }
1119   | signing dimensions_opt
1120       { vector_type_t*tmp = new vector_type_t(IVL_VT_LOGIC, $1, $2);
1121         tmp->implicit_flag = true;
1122         FILE_NAME(tmp, @1);
1123         $$ = tmp;
1124       }
1125   | dimensions
1126       { vector_type_t*tmp = new vector_type_t(IVL_VT_LOGIC, false, $1);
1127         tmp->implicit_flag = true;
1128         FILE_NAME(tmp, @1);
1129         $$ = tmp;
1130       }
1131   |
1132       { $$ = 0; }
1133   ;
1134
1135
1136 data_type_or_implicit_or_void
1137   : data_type_or_implicit
1138       { $$ = $1; }
1139   | K_void
1140       { void_type_t*tmp = new void_type_t;
1141         FILE_NAME(tmp, @1);
1142         $$ = tmp;
1143       }
1144   ;
1145
1146   /* NOTE: The "module" rule of the description combines the
1147      module_declaration, program_declaration, and interface_declaration
1148      rules from the standard description. */
1149
1150 description /* IEEE1800-2005: A.1.2 */
1151   : module
1152   | udp_primitive
1153   | config_declaration
1154   | nature_declaration
1155   | package_declaration
1156   | discipline_declaration
1157   | package_item
1158   | KK_attribute '(' IDENTIFIER ',' STRING ',' STRING ')'
1159       { perm_string tmp3 = lex_strings.make($3);
1160         pform_set_type_attrib(tmp3, $5, $7);
1161         delete[] $3;
1162         delete[] $5;
1163       }
1164   ;
1165
1166 description_list
1167   : description
1168   | description_list description
1169   ;
1170
1171
1172    /* This implements the [ : IDENTIFIER ] part of the constructor
1173       rule documented in IEEE1800-2005: A.1.8 */
1174 endnew_opt : ':' K_new | ;
1175
1176   /* The dynamic_array_new rule is kinda like an expression, but it is
1177      treated differently by rules that use this "expression". Watch out! */
1178
1179 dynamic_array_new /* IEEE1800-2005: A.2.4 */
1180   : K_new '[' expression ']'
1181       { $$ = new PENewArray($3, 0);
1182         FILE_NAME($$, @1);
1183       }
1184   | K_new '[' expression ']' '(' expression ')'
1185       { $$ = new PENewArray($3, $6);
1186         FILE_NAME($$, @1);
1187       }
1188   ;
1189
1190 for_step /* IEEE1800-2005: A.6.8 */
1191   : lpvalue '=' expression
1192       { PAssign*tmp = new PAssign($1,$3);
1193         FILE_NAME(tmp, @1);
1194         $$ = tmp;
1195       }
1196   | inc_or_dec_expression
1197       { $$ = pform_compressed_assign_from_inc_dec(@1, $1); }
1198   | compressed_statement
1199       { $$ = $1; }
1200   ;
1201
1202
1203   /* The function declaration rule matches the function declaration
1204      header, then pushes the function scope. This causes the
1205      definitions in the func_body to take on the scope of the function
1206      instead of the module. */
1207 function_declaration /* IEEE1800-2005: A.2.6 */
1208   : K_function lifetime_opt data_type_or_implicit_or_void IDENTIFIER ';'
1209       { assert(current_function == 0);
1210         current_function = pform_push_function_scope(@1, $4, $2);
1211       }
1212     function_item_list statement_or_null_list_opt
1213     K_endfunction
1214       { current_function->set_ports($7);
1215         current_function->set_return($3);
1216         current_function_set_statement($8? @8 : @4, $8);
1217         pform_set_this_class(@4, current_function);
1218         pform_pop_scope();
1219         current_function = 0;
1220       }
1221     endlabel_opt
1222       { // Last step: check any closing name.
1223         if ($11) {
1224               if (strcmp($4,$11) != 0) {
1225                     yyerror(@11, "error: End label doesn't match "
1226                                  "function name");
1227               }
1228               if (! gn_system_verilog()) {
1229                     yyerror(@11, "error: Function end labels require "
1230                                  "SystemVerilog.");
1231               }
1232               delete[]$11;
1233         }
1234         delete[]$4;
1235       }
1236
1237   | K_function lifetime_opt data_type_or_implicit_or_void IDENTIFIER
1238       { assert(current_function == 0);
1239         current_function = pform_push_function_scope(@1, $4, $2);
1240       }
1241     '(' tf_port_list_opt ')' ';'
1242     block_item_decls_opt
1243     statement_or_null_list_opt
1244     K_endfunction
1245       { current_function->set_ports($7);
1246         current_function->set_return($3);
1247         current_function_set_statement($11? @11 : @4, $11);
1248         pform_set_this_class(@4, current_function);
1249         pform_pop_scope();
1250         current_function = 0;
1251         if ($7==0 && !gn_system_verilog()) {
1252               yyerror(@4, "error: Empty parenthesis syntax requires SystemVerilog.");
1253         }
1254       }
1255     endlabel_opt
1256       { // Last step: check any closing name.
1257         if ($14) {
1258               if (strcmp($4,$14) != 0) {
1259                     yyerror(@14, "error: End label doesn't match "
1260                                  "function name");
1261               }
1262               if (! gn_system_verilog()) {
1263                     yyerror(@14, "error: Function end labels require "
1264                                  "SystemVerilog.");
1265               }
1266               delete[]$14;
1267         }
1268         delete[]$4;
1269       }
1270
1271   /* Detect and recover from some errors. */
1272
1273   | K_function lifetime_opt data_type_or_implicit_or_void IDENTIFIER error K_endfunction
1274       { /* */
1275         if (current_function) {
1276               pform_pop_scope();
1277               current_function = 0;
1278         }
1279         assert(current_function == 0);
1280         yyerror(@1, "error: Syntax error defining function.");
1281         yyerrok;
1282       }
1283     endlabel_opt
1284       { // Last step: check any closing name.
1285         if ($8) {
1286               if (strcmp($4,$8) != 0) {
1287                     yyerror(@8, "error: End label doesn't match function name");
1288               }
1289               if (! gn_system_verilog()) {
1290                     yyerror(@8, "error: Function end labels require "
1291                                  "SystemVerilog.");
1292               }
1293               delete[]$8;
1294         }
1295         delete[]$4;
1296       }
1297
1298   ;
1299
1300 import_export /* IEEE1800-2012: A.2.9 */
1301   : K_import { $$ = true; }
1302   | K_export { $$ = false; }
1303   ;
1304
1305 implicit_class_handle /* IEEE1800-2005: A.8.4 */
1306   : K_this  { $$ = pform_create_this(); }
1307   | K_super { $$ = pform_create_super(); }
1308   ;
1309
1310   /* SystemVerilog adds support for the increment/decrement
1311      expressions, which look like a++, --a, etc. These are primaries
1312      but are in their own rules because they can also be
1313      statements. Note that the operator can only take l-value
1314      expressions. */
1315
1316 inc_or_dec_expression /* IEEE1800-2005: A.4.3 */
1317   : K_INCR lpvalue %prec UNARY_PREC
1318       { PEUnary*tmp = new PEUnary('I', $2);
1319         FILE_NAME(tmp, @2);
1320         $$ = tmp;
1321       }
1322   | lpvalue K_INCR %prec UNARY_PREC
1323       { PEUnary*tmp = new PEUnary('i', $1);
1324         FILE_NAME(tmp, @1);
1325         $$ = tmp;
1326       }
1327   | K_DECR lpvalue %prec UNARY_PREC
1328       { PEUnary*tmp = new PEUnary('D', $2);
1329         FILE_NAME(tmp, @2);
1330         $$ = tmp;
1331       }
1332   | lpvalue K_DECR %prec UNARY_PREC
1333       { PEUnary*tmp = new PEUnary('d', $1);
1334         FILE_NAME(tmp, @1);
1335         $$ = tmp;
1336       }
1337   ;
1338
1339 inside_expression /* IEEE1800-2005 A.8.3 */
1340   : expression K_inside '{' open_range_list '}'
1341       { yyerror(@2, "sorry: \"inside\" expressions not supported yet.");
1342         $$ = 0;
1343       }
1344   ;
1345
1346 integer_vector_type /* IEEE1800-2005: A.2.2.1 */
1347   : K_reg   { $$ = IVL_VT_NO_TYPE; } /* Usually a synonym for logic. */
1348   | K_bit   { $$ = IVL_VT_BOOL; }
1349   | K_logic { $$ = IVL_VT_LOGIC; }
1350   | K_bool  { $$ = IVL_VT_BOOL; } /* Icarus Verilog xtypes extension */
1351   ;
1352
1353 join_keyword /* IEEE1800-2005: A.6.3 */
1354   : K_join
1355       { $$ = PBlock::BL_PAR; }
1356   | K_join_none
1357       { $$ = PBlock::BL_JOIN_NONE; }
1358   | K_join_any
1359       { $$ = PBlock::BL_JOIN_ANY; }
1360   ;
1361
1362 jump_statement /* IEEE1800-2005: A.6.5 */
1363   : K_break ';'
1364       { yyerror(@1, "sorry: break statements not supported.");
1365         $$ = 0;
1366       }
1367   | K_return ';'
1368       { PReturn*tmp = new PReturn(0);
1369         FILE_NAME(tmp, @1);
1370         $$ = tmp;
1371       }
1372   | K_return expression ';'
1373       { PReturn*tmp = new PReturn($2);
1374         FILE_NAME(tmp, @1);
1375         $$ = tmp;
1376       }
1377   ;
1378
1379 lifetime /* IEEE1800-2005: A.2.1.3 */
1380   : K_automatic { $$ = LexicalScope::AUTOMATIC; }
1381   | K_static    { $$ = LexicalScope::STATIC; }
1382   ;
1383
1384 lifetime_opt /* IEEE1800-2005: A.2.1.3 */
1385   : lifetime { $$ = $1; }
1386   |          { $$ = LexicalScope::INHERITED; }
1387   ;
1388
1389   /* Loop statements are kinds of statements. */
1390
1391 loop_statement /* IEEE1800-2005: A.6.8 */
1392   : K_for '(' lpvalue '=' expression ';' expression ';' for_step ')'
1393     statement_or_null
1394       { PForStatement*tmp = new PForStatement($3, $5, $7, $9, $11);
1395         FILE_NAME(tmp, @1);
1396         $$ = tmp;
1397       }
1398
1399       // Handle for_variable_declaration syntax by wrapping the for(...)
1400       // statement in a synthetic named block. We can name the block
1401       // after the variable that we are creating, that identifier is
1402       // safe in the controlling scope.
1403   | K_for '(' data_type IDENTIFIER '=' expression ';' expression ';' for_step ')'
1404       { static unsigned for_counter = 0;
1405         char for_block_name [64];
1406         snprintf(for_block_name, sizeof for_block_name, "$ivl_for_loop%u", for_counter);
1407         for_counter += 1;
1408         PBlock*tmp = pform_push_block_scope(for_block_name, PBlock::BL_SEQ);
1409         FILE_NAME(tmp, @1);
1410         current_block_stack.push(tmp);
1411
1412         list<decl_assignment_t*>assign_list;
1413         decl_assignment_t*tmp_assign = new decl_assignment_t;
1414         tmp_assign->name = lex_strings.make($4);
1415         assign_list.push_back(tmp_assign);
1416         pform_makewire(@4, 0, str_strength, &assign_list, NetNet::REG, $3);
1417       }
1418     statement_or_null
1419       { pform_name_t tmp_hident;
1420         tmp_hident.push_back(name_component_t(lex_strings.make($4)));
1421
1422         PEIdent*tmp_ident = pform_new_ident(tmp_hident);
1423         FILE_NAME(tmp_ident, @4);
1424
1425         PForStatement*tmp_for = new PForStatement(tmp_ident, $6, $8, $10, $13);
1426         FILE_NAME(tmp_for, @1);
1427
1428         pform_pop_scope();
1429         vector<Statement*>tmp_for_list (1);
1430         tmp_for_list[0] = tmp_for;
1431         PBlock*tmp_blk = current_block_stack.top();
1432         current_block_stack.pop();
1433         tmp_blk->set_statement(tmp_for_list);
1434         $$ = tmp_blk;
1435         delete[]$4;
1436       }
1437
1438   | K_forever statement_or_null
1439       { PForever*tmp = new PForever($2);
1440         FILE_NAME(tmp, @1);
1441         $$ = tmp;
1442       }
1443
1444   | K_repeat '(' expression ')' statement_or_null
1445       { PRepeat*tmp = new PRepeat($3, $5);
1446         FILE_NAME(tmp, @1);
1447         $$ = tmp;
1448       }
1449
1450   | K_while '(' expression ')' statement_or_null
1451       { PWhile*tmp = new PWhile($3, $5);
1452         FILE_NAME(tmp, @1);
1453         $$ = tmp;
1454       }
1455
1456   | K_do statement_or_null K_while '(' expression ')' ';'
1457       { PDoWhile*tmp = new PDoWhile($5, $2);
1458         FILE_NAME(tmp, @1);
1459         $$ = tmp;
1460       }
1461
1462       // When matching a foreach loop, implicitly create a named block
1463       // to hold the definitions for the index variables.
1464   | K_foreach '(' IDENTIFIER '[' loop_variables ']' ')'
1465       { static unsigned foreach_counter = 0;
1466         char for_block_name[64];
1467         snprintf(for_block_name, sizeof for_block_name, "$ivl_foreach%u", foreach_counter);
1468         foreach_counter += 1;
1469
1470         PBlock*tmp = pform_push_block_scope(for_block_name, PBlock::BL_SEQ);
1471         FILE_NAME(tmp, @1);
1472         current_block_stack.push(tmp);
1473
1474         pform_make_foreach_declarations(@1, $5);
1475       }
1476     statement_or_null
1477       { PForeach*tmp_for = pform_make_foreach(@1, $3, $5, $9);
1478
1479         pform_pop_scope();
1480         vector<Statement*>tmp_for_list(1);
1481         tmp_for_list[0] = tmp_for;
1482         PBlock*tmp_blk = current_block_stack.top();
1483         current_block_stack.pop();
1484         tmp_blk->set_statement(tmp_for_list);
1485         $$ = tmp_blk;
1486       }
1487
1488   /* Error forms for loop statements. */
1489
1490   | K_for '(' lpvalue '=' expression ';' expression ';' error ')'
1491     statement_or_null
1492       { $$ = 0;
1493         yyerror(@1, "error: Error in for loop step assignment.");
1494       }
1495
1496   | K_for '(' lpvalue '=' expression ';' error ';' for_step ')'
1497     statement_or_null
1498       { $$ = 0;
1499         yyerror(@1, "error: Error in for loop condition expression.");
1500       }
1501
1502   | K_for '(' error ')' statement_or_null
1503       { $$ = 0;
1504         yyerror(@1, "error: Incomprehensible for loop.");
1505       }
1506
1507   | K_while '(' error ')' statement_or_null
1508       { $$ = 0;
1509         yyerror(@1, "error: Error in while loop condition.");
1510       }
1511
1512   | K_do statement_or_null K_while '(' error ')' ';'
1513       { $$ = 0;
1514         yyerror(@1, "error: Error in do/while loop condition.");
1515       }
1516
1517   | K_foreach '(' IDENTIFIER '[' error ']' ')' statement_or_null
1518       { $$ = 0;
1519         yyerror(@4, "error: Errors in foreach loop variables list.");
1520       }
1521   ;
1522
1523
1524 /* TODO: Replace register_variable_list with list_of_variable_decl_assignments. */
1525 list_of_variable_decl_assignments /* IEEE1800-2005 A.2.3 */
1526   : variable_decl_assignment
1527       { list<decl_assignment_t*>*tmp = new list<decl_assignment_t*>;
1528         tmp->push_back($1);
1529         $$ = tmp;
1530       }
1531   | list_of_variable_decl_assignments ',' variable_decl_assignment
1532       { list<decl_assignment_t*>*tmp = $1;
1533         tmp->push_back($3);
1534         $$ = tmp;
1535       }
1536   ;
1537
1538 variable_decl_assignment /* IEEE1800-2005 A.2.3 */
1539   : IDENTIFIER dimensions_opt
1540       { decl_assignment_t*tmp = new decl_assignment_t;
1541         tmp->name = lex_strings.make($1);
1542         if ($2) {
1543               tmp->index = *$2;
1544               delete $2;
1545         }
1546         delete[]$1;
1547         $$ = tmp;
1548       }
1549   | IDENTIFIER '=' expression
1550       { decl_assignment_t*tmp = new decl_assignment_t;
1551         tmp->name = lex_strings.make($1);
1552         tmp->expr .reset($3);
1553         delete[]$1;
1554         $$ = tmp;
1555       }
1556   | IDENTIFIER '=' K_new '(' ')'
1557       { decl_assignment_t*tmp = new decl_assignment_t;
1558         tmp->name = lex_strings.make($1);
1559         PENewClass*expr = new PENewClass;
1560         FILE_NAME(expr, @3);
1561         tmp->expr .reset(expr);
1562         delete[]$1;
1563         $$ = tmp;
1564       }
1565   ;
1566
1567
1568 loop_variables /* IEEE1800-2005: A.6.8 */
1569   : loop_variables ',' IDENTIFIER
1570       { list<perm_string>*tmp = $1;
1571         tmp->push_back(lex_strings.make($3));
1572         delete[]$3;
1573         $$ = tmp;
1574       }
1575   | IDENTIFIER
1576       { list<perm_string>*tmp = new list<perm_string>;
1577         tmp->push_back(lex_strings.make($1));
1578         delete[]$1;
1579         $$ = tmp;
1580       }
1581   ;
1582
1583 method_qualifier /* IEEE1800-2005: A.1.8 */
1584   : K_virtual
1585   | class_item_qualifier
1586   ;
1587
1588 method_qualifier_opt
1589   : method_qualifier
1590   |
1591   ;
1592
1593 modport_declaration /* IEEE1800-2012: A.2.9 */
1594   : K_modport
1595       { if (!pform_in_interface())
1596               yyerror(@1, "error: modport declarations are only allowed "
1597                           "in interfaces.");
1598       }
1599     modport_item_list ';'
1600
1601 modport_item_list
1602   : modport_item
1603   | modport_item_list ',' modport_item
1604   ;
1605
1606 modport_item
1607   : IDENTIFIER
1608       { pform_start_modport_item(@1, $1); }
1609     '(' modport_ports_list ')'
1610       { pform_end_modport_item(@1); }
1611   ;
1612
1613   /* The modport_ports_list is a LALR(2) grammar. When the parser sees a
1614      ',' it needs to look ahead to the next token to decide whether it is
1615      a continuation of the preceding modport_ports_declaration, or the
1616      start of a new modport_ports_declaration. bison only supports LALR(1),
1617      so we have to handcraft a mini parser for this part of the syntax.
1618      last_modport_port holds the state for this mini parser.*/
1619
1620 modport_ports_list
1621   : modport_ports_declaration
1622   | modport_ports_list ',' modport_ports_declaration
1623   | modport_ports_list ',' modport_simple_port
1624       { if (last_modport_port.type == MP_SIMPLE) {
1625               pform_add_modport_port(@3, last_modport_port.direction,
1626                                      $3->name, $3->parm);
1627         } else {
1628               yyerror(@3, "error: modport expression not allowed here.");
1629         }
1630         delete $3;
1631       }
1632   | modport_ports_list ',' modport_tf_port
1633       { if (last_modport_port.type != MP_TF)
1634               yyerror(@3, "error: task/function declaration not allowed here.");
1635       }
1636   | modport_ports_list ',' IDENTIFIER
1637       { if (last_modport_port.type == MP_SIMPLE) {
1638               pform_add_modport_port(@3, last_modport_port.direction,
1639                                      lex_strings.make($3), 0);
1640         } else if (last_modport_port.type != MP_TF) {
1641               yyerror(@3, "error: list of identifiers not allowed here.");
1642         }
1643         delete[] $3;
1644       }
1645   | modport_ports_list ','
1646       { yyerror(@2, "error: NULL port declarations are not allowed"); }
1647   ;
1648
1649 modport_ports_declaration
1650   : attribute_list_opt port_direction IDENTIFIER
1651       { last_modport_port.type = MP_SIMPLE;
1652         last_modport_port.direction = $2;
1653         pform_add_modport_port(@3, $2, lex_strings.make($3), 0);
1654         delete[] $3;
1655         delete $1;
1656       }
1657   | attribute_list_opt port_direction modport_simple_port
1658       { last_modport_port.type = MP_SIMPLE;
1659         last_modport_port.direction = $2;
1660         pform_add_modport_port(@3, $2, $3->name, $3->parm);
1661         delete $3;
1662         delete $1;
1663       }
1664   | attribute_list_opt import_export IDENTIFIER
1665       { last_modport_port.type = MP_TF;
1666         last_modport_port.is_import = $2;
1667         yyerror(@3, "sorry: modport task/function ports are not yet supported.");
1668         delete[] $3;
1669         delete $1;
1670       }
1671   | attribute_list_opt import_export modport_tf_port
1672       { last_modport_port.type = MP_TF;
1673         last_modport_port.is_import = $2;
1674         yyerror(@3, "sorry: modport task/function ports are not yet supported.");
1675         delete $1;
1676       }
1677   | attribute_list_opt K_clocking IDENTIFIER
1678       { last_modport_port.type = MP_CLOCKING;
1679         last_modport_port.direction = NetNet::NOT_A_PORT;
1680         yyerror(@3, "sorry: modport clocking declaration is not yet supported.");
1681         delete[] $3;
1682         delete $1;
1683       }
1684   ;
1685
1686 modport_simple_port
1687   : '.' IDENTIFIER '(' expression ')'
1688       { named_pexpr_t*tmp = new named_pexpr_t;
1689         tmp->name = lex_strings.make($2);
1690         tmp->parm = $4;
1691         delete[]$2;
1692         $$ = tmp;
1693       }
1694   ;
1695
1696 modport_tf_port
1697   : K_task IDENTIFIER
1698   | K_task IDENTIFIER '(' tf_port_list_opt ')'
1699   | K_function data_type_or_implicit_or_void IDENTIFIER
1700   | K_function data_type_or_implicit_or_void IDENTIFIER '(' tf_port_list_opt ')'
1701   ;
1702
1703 non_integer_type /* IEEE1800-2005: A.2.2.1 */
1704   : K_real { $$ = real_type_t::REAL; }
1705   | K_realtime { $$ = real_type_t::REAL; }
1706   | K_shortreal { $$ = real_type_t::SHORTREAL; }
1707   ;
1708
1709 number  : BASED_NUMBER
1710              { $$ = $1; based_size = 0;}
1711         | DEC_NUMBER
1712              { $$ = $1; based_size = 0;}
1713         | DEC_NUMBER BASED_NUMBER
1714              { $$ = pform_verinum_with_size($1,$2, @2.text, @2.first_line);
1715                based_size = 0; }
1716         | UNBASED_NUMBER
1717              { $$ = $1; based_size = 0;}
1718         | DEC_NUMBER UNBASED_NUMBER
1719              { yyerror(@1, "error: Unbased SystemVerilog literal cannot have "
1720                            "a size.");
1721                $$ = $1; based_size = 0;}
1722         ;
1723
1724 open_range_list /* IEEE1800-2005 A.2.11 */
1725   : open_range_list ',' value_range
1726   | value_range
1727   ;
1728
1729 package_declaration /* IEEE1800-2005 A.1.2 */
1730   : K_package lifetime_opt IDENTIFIER ';'
1731       { pform_start_package_declaration(@1, $3, $2); }
1732     timeunits_declaration_opt
1733       { pform_set_scope_timescale(@1); }
1734     package_item_list_opt
1735     K_endpackage endlabel_opt
1736       { pform_end_package_declaration(@1);
1737         // If an end label is present make sure it match the package name.
1738         if ($10) {
1739               if (strcmp($3,$10) != 0) {
1740                     yyerror(@10, "error: End label doesn't match package name");
1741               }
1742               delete[]$10;
1743         }
1744         delete[]$3;
1745       }
1746   ;
1747
1748 module_package_import_list_opt
1749   :
1750   | package_import_list
1751   ;
1752
1753 package_import_list
1754   : package_import_declaration
1755   | package_import_list package_import_declaration
1756   ;
1757
1758 package_import_declaration /* IEEE1800-2005 A.2.1.3 */
1759   : K_import package_import_item_list ';'
1760       { }
1761   ;
1762
1763 package_import_item
1764   : PACKAGE_IDENTIFIER K_SCOPE_RES IDENTIFIER
1765       { pform_package_import(@2, $1, $3);
1766         delete[]$3;
1767       }
1768   | PACKAGE_IDENTIFIER K_SCOPE_RES '*'
1769       { pform_package_import(@2, $1, 0);
1770       }
1771   ;
1772
1773 package_import_item_list
1774   : package_import_item_list',' package_import_item
1775   | package_import_item
1776   ;
1777
1778 package_item /* IEEE1800-2005 A.1.10 */
1779   : timeunits_declaration
1780   | K_parameter param_type parameter_assign_list ';'
1781   | K_localparam param_type localparam_assign_list ';'
1782   | type_declaration
1783   | function_declaration
1784   | task_declaration
1785   | data_declaration
1786   | class_declaration
1787   ;
1788
1789 package_item_list
1790   : package_item_list package_item
1791   | package_item
1792   ;
1793
1794 package_item_list_opt : package_item_list | ;
1795
1796 port_direction /* IEEE1800-2005 A.1.3 */
1797   : K_input  { $$ = NetNet::PINPUT; }
1798   | K_output { $$ = NetNet::POUTPUT; }
1799   | K_inout  { $$ = NetNet::PINOUT; }
1800   | K_ref
1801       { $$ = NetNet::PREF;
1802         if (!gn_system_verilog()) {
1803               yyerror(@1, "error: Reference ports (ref) require SystemVerilog.");
1804               $$ = NetNet::PINPUT;
1805         }
1806       }
1807   ;
1808
1809   /* port_direction_opt is used in places where the port direction is
1810      optional. The default direction is selected by the context,
1811      which needs to notice the PIMPLICIT direction. */
1812
1813 port_direction_opt
1814   : port_direction { $$ = $1; }
1815   |                { $$ = NetNet::PIMPLICIT; }
1816   ;
1817
1818 property_expr /* IEEE1800-2012 A.2.10 */
1819   : expression
1820   ;
1821
1822 procedural_assertion_statement /* IEEE1800-2012 A.6.10 */
1823   : K_assert '(' expression ')' statement %prec less_than_K_else
1824       { yyerror(@1, "sorry: Simple immediate assertion statements not implemented.");
1825         $$ = 0;
1826       }
1827   | K_assert '(' expression ')' K_else statement
1828       { yyerror(@1, "sorry: Simple immediate assertion statements not implemented.");
1829         $$ = 0;
1830       }
1831   | K_assert '(' expression ')' statement K_else statement
1832       { yyerror(@1, "sorry: Simple immediate assertion statements not implemented.");
1833         $$ = 0;
1834       }
1835   ;
1836
1837   /* The property_qualifier rule is as literally described in the LRM,
1838      but the use is usually as { property_qualifier }, which is
1839      implemented by the property_qualifier_opt rule below. */
1840
1841 property_qualifier /* IEEE1800-2005 A.1.8 */
1842   : class_item_qualifier
1843   | random_qualifier
1844   ;
1845
1846 property_qualifier_opt /* IEEE1800-2005 A.1.8: ... { property_qualifier } */
1847   : property_qualifier_list { $$ = $1; }
1848   | { $$ = property_qualifier_t::make_none(); }
1849   ;
1850
1851 property_qualifier_list /* IEEE1800-2005 A.1.8 */
1852   : property_qualifier_list property_qualifier { $$ = $1 | $2; }
1853   | property_qualifier { $$ = $1; }
1854   ;
1855
1856   /* The property_spec rule uses some helper rules to implement this
1857      rule from the LRM:
1858      [ clocking_event ] [ disable iff ( expression_or_dist ) ] property_expr
1859      This does it is a YACC friendly way. */
1860
1861 property_spec /* IEEE1800-2012 A.2.10 */
1862   : clocking_event_opt property_spec_disable_iff_opt property_expr
1863   ;
1864
1865 property_spec_disable_iff_opt /* */
1866   : K_disable K_iff '(' expression ')'
1867   |
1868   ;
1869
1870 random_qualifier /* IEEE1800-2005 A.1.8 */
1871   : K_rand { $$ = property_qualifier_t::make_rand(); }
1872   | K_randc { $$ = property_qualifier_t::make_randc(); }
1873   ;
1874
1875   /* real and realtime are exactly the same so save some code
1876    * with a common matching rule. */
1877 real_or_realtime
1878         : K_real
1879         | K_realtime
1880         ;
1881
1882 signing /* IEEE1800-2005: A.2.2.1 */
1883   : K_signed   { $$ = true; }
1884   | K_unsigned { $$ = false; }
1885   ;
1886
1887 simple_type_or_string /* IEEE1800-2005: A.2.2.1 */
1888   : integer_vector_type
1889       { ivl_variable_type_t use_vtype = $1;
1890         bool reg_flag = false;
1891         if (use_vtype == IVL_VT_NO_TYPE) {
1892               use_vtype = IVL_VT_LOGIC;
1893               reg_flag = true;
1894         }
1895         vector_type_t*tmp = new vector_type_t(use_vtype, false, 0);
1896         tmp->reg_flag = reg_flag;
1897         FILE_NAME(tmp, @1);
1898         $$ = tmp;
1899       }
1900   | non_integer_type
1901       { real_type_t*tmp = new real_type_t($1);
1902         FILE_NAME(tmp, @1);
1903         $$ = tmp;
1904       }
1905   | atom2_type
1906       { atom2_type_t*tmp = new atom2_type_t($1, true);
1907         FILE_NAME(tmp, @1);
1908         $$ = tmp;
1909       }
1910   | K_integer
1911       { list<pform_range_t>*pd = make_range_from_width(integer_width);
1912         vector_type_t*tmp = new vector_type_t(IVL_VT_LOGIC, true, pd);
1913         tmp->reg_flag = true;
1914         tmp->integer_flag = true;
1915         $$ = tmp;
1916       }
1917   | K_time
1918       { list<pform_range_t>*pd = make_range_from_width(64);
1919         vector_type_t*tmp = new vector_type_t(IVL_VT_LOGIC, false, pd);
1920         tmp->reg_flag = !gn_system_verilog();
1921         $$ = tmp;
1922       }
1923   | TYPE_IDENTIFIER
1924       { $$ = $1.type;
1925         delete[]$1.text;
1926       }
1927   | PACKAGE_IDENTIFIER K_SCOPE_RES
1928       { lex_in_package_scope($1); }
1929     TYPE_IDENTIFIER
1930       { lex_in_package_scope(0);
1931         $$ = $4.type;
1932         delete[]$4.text;
1933       }
1934   | K_string
1935       { string_type_t*tmp = new string_type_t;
1936         FILE_NAME(tmp, @1);
1937         $$ = tmp;
1938       }
1939   ;
1940
1941 statement /* IEEE1800-2005: A.6.4 */
1942   : attribute_list_opt statement_item
1943       { pform_bind_attributes($2->attributes, $1);
1944         $$ = $2;
1945       }
1946   ;
1947
1948   /* Many places where statements are allowed can actually take a
1949      statement or a null statement marked with a naked semi-colon. */
1950
1951 statement_or_null /* IEEE1800-2005: A.6.4 */
1952   : statement
1953       { $$ = $1; }
1954   | attribute_list_opt ';'
1955       { $$ = 0; }
1956   ;
1957
1958 stream_expression
1959   : expression
1960   ;
1961
1962 stream_expression_list
1963   : stream_expression_list ',' stream_expression
1964   | stream_expression
1965   ;
1966
1967 stream_operator
1968   : K_LS
1969   | K_RS
1970   ;
1971
1972 streaming_concatenation /* IEEE1800-2005: A.8.1 */
1973   : '{' stream_operator '{' stream_expression_list '}' '}'
1974       { /* streaming concatenation is a SystemVerilog thing. */
1975         if (gn_system_verilog()) {
1976               yyerror(@2, "sorry: Streaming concatenation not supported.");
1977               $$ = 0;
1978         } else {
1979               yyerror(@2, "error: Streaming concatenation requires SystemVerilog");
1980               $$ = 0;
1981         }
1982       }
1983   ;
1984
1985   /* The task declaration rule matches the task declaration
1986      header, then pushes the function scope. This causes the
1987      definitions in the task_body to take on the scope of the task
1988      instead of the module. */
1989
1990 task_declaration /* IEEE1800-2005: A.2.7 */
1991
1992   : K_task lifetime_opt IDENTIFIER ';'
1993       { assert(current_task == 0);
1994         current_task = pform_push_task_scope(@1, $3, $2);
1995       }
1996     task_item_list_opt
1997     statement_or_null_list_opt
1998     K_endtask
1999       { current_task->set_ports($6);
2000         current_task_set_statement(@3, $7);
2001         pform_set_this_class(@3, current_task);
2002         pform_pop_scope();
2003         current_task = 0;
2004         if ($7 && $7->size() > 1 && !gn_system_verilog()) {
2005               yyerror(@7, "error: Task body with multiple statements requires SystemVerilog.");
2006         }
2007         delete $7;
2008       }
2009     endlabel_opt
2010       { // Last step: check any closing name. This is done late so
2011         // that the parser can look ahead to detect the present
2012         // endlabel_opt but still have the pform_endmodule() called
2013         // early enough that the lexor can know we are outside the
2014         // module.
2015         if ($10) {
2016               if (strcmp($3,$10) != 0) {
2017                     yyerror(@10, "error: End label doesn't match task name");
2018               }
2019               if (! gn_system_verilog()) {
2020                     yyerror(@10, "error: Task end labels require "
2021                                  "SystemVerilog.");
2022               }
2023               delete[]$10;
2024         }
2025         delete[]$3;
2026       }
2027
2028   | K_task lifetime_opt IDENTIFIER '('
2029       { assert(current_task == 0);
2030         current_task = pform_push_task_scope(@1, $3, $2);
2031       }
2032     tf_port_list ')' ';'
2033     block_item_decls_opt
2034     statement_or_null_list_opt
2035     K_endtask
2036       { current_task->set_ports($6);
2037         current_task_set_statement(@3, $10);
2038         pform_set_this_class(@3, current_task);
2039         pform_pop_scope();
2040         current_task = 0;
2041         if ($10) delete $10;
2042       }
2043     endlabel_opt
2044       { // Last step: check any closing name. This is done late so
2045         // that the parser can look ahead to detect the present
2046         // endlabel_opt but still have the pform_endmodule() called
2047         // early enough that the lexor can know we are outside the
2048         // module.
2049         if ($13) {
2050               if (strcmp($3,$13) != 0) {
2051                     yyerror(@13, "error: End label doesn't match task name");
2052               }
2053               if (! gn_system_verilog()) {
2054                     yyerror(@13, "error: Task end labels require "
2055                                  "SystemVerilog.");
2056               }
2057               delete[]$13;
2058         }
2059         delete[]$3;
2060       }
2061
2062   | K_task lifetime_opt IDENTIFIER '(' ')' ';'
2063       { assert(current_task == 0);
2064         current_task = pform_push_task_scope(@1, $3, $2);
2065       }
2066     block_item_decls_opt
2067     statement_or_null_list
2068     K_endtask
2069       { current_task->set_ports(0);
2070         current_task_set_statement(@3, $9);
2071         pform_set_this_class(@3, current_task);
2072         if (! current_task->method_of()) {
2073               cerr << @3 << ": warning: task definition for \"" << $3
2074                    << "\" has an empty port declaration list!" << endl;
2075         }
2076         pform_pop_scope();
2077         current_task = 0;
2078         if ($9->size() > 1 && !gn_system_verilog()) {
2079               yyerror(@9, "error: Task body with multiple statements requires SystemVerilog.");
2080         }
2081         delete $9;
2082       }
2083     endlabel_opt
2084       { // Last step: check any closing name. This is done late so
2085         // that the parser can look ahead to detect the present
2086         // endlabel_opt but still have the pform_endmodule() called
2087         // early enough that the lexor can know we are outside the
2088         // module.
2089         if ($12) {
2090               if (strcmp($3,$12) != 0) {
2091                     yyerror(@12, "error: End label doesn't match task name");
2092               }
2093               if (! gn_system_verilog()) {
2094                     yyerror(@12, "error: Task end labels require "
2095                                  "SystemVerilog.");
2096               }
2097               delete[]$12;
2098         }
2099         delete[]$3;
2100       }
2101
2102   | K_task lifetime_opt IDENTIFIER error K_endtask
2103       {
2104         if (current_task) {
2105               pform_pop_scope();
2106               current_task = 0;
2107         }
2108       }
2109     endlabel_opt
2110       { // Last step: check any closing name. This is done late so
2111         // that the parser can look ahead to detect the present
2112         // endlabel_opt but still have the pform_endmodule() called
2113         // early enough that the lexor can know we are outside the
2114         // module.
2115         if ($7) {
2116               if (strcmp($3,$7) != 0) {
2117                     yyerror(@7, "error: End label doesn't match task name");
2118               }
2119               if (! gn_system_verilog()) {
2120                     yyerror(@7, "error: Task end labels require "
2121                                  "SystemVerilog.");
2122               }
2123               delete[]$7;
2124         }
2125         delete[]$3;
2126       }
2127
2128   ;
2129
2130
2131 tf_port_declaration /* IEEE1800-2005: A.2.7 */
2132   : port_direction K_reg_opt unsigned_signed_opt dimensions_opt list_of_identifiers ';'
2133       { vector<pform_tf_port_t>*tmp = pform_make_task_ports(@1, $1,
2134                                                 $2 ? IVL_VT_LOGIC :
2135                                                      IVL_VT_NO_TYPE,
2136                                                 $3, $4, $5);
2137         $$ = tmp;
2138       }
2139
2140   /* When the port is an integer, infer a signed vector of the integer
2141      shape. Generate a range ([31:0]) to make it work. */
2142
2143   | port_direction K_integer list_of_identifiers ';'
2144       { list<pform_range_t>*range_stub = make_range_from_width(integer_width);
2145         vector<pform_tf_port_t>*tmp = pform_make_task_ports(@1, $1, IVL_VT_LOGIC, true,
2146                                                     range_stub, $3, true);
2147         $$ = tmp;
2148       }
2149
2150   /* Ports can be time with a width of [63:0] (unsigned). */
2151
2152   | port_direction K_time list_of_identifiers ';'
2153       { list<pform_range_t>*range_stub = make_range_from_width(64);
2154         vector<pform_tf_port_t>*tmp = pform_make_task_ports(@1, $1, IVL_VT_LOGIC, false,
2155                                                    range_stub, $3);
2156         $$ = tmp;
2157       }
2158
2159   /* Ports can be real or realtime. */
2160
2161   | port_direction real_or_realtime list_of_identifiers ';'
2162       { vector<pform_tf_port_t>*tmp = pform_make_task_ports(@1, $1, IVL_VT_REAL, true,
2163                                                    0, $3);
2164         $$ = tmp;
2165       }
2166
2167
2168   /* Ports can be string. */
2169
2170   | port_direction K_string list_of_identifiers ';'
2171       { vector<pform_tf_port_t>*tmp = pform_make_task_ports(@1, $1, IVL_VT_STRING, true,
2172                                                    0, $3);
2173         $$ = tmp;
2174       }
2175
2176   ;
2177
2178
2179   /* These rules for tf_port_item are slightly expanded from the
2180      strict rules in the LRM to help with LALR parsing.
2181
2182      NOTE: Some of these rules should be folded into the "data_type"
2183      variant which uses the data_type rule to match data type
2184      declarations. That some rules do not use the data_type production
2185      is a consequence of legacy. */
2186
2187 tf_port_item /* IEEE1800-2005: A.2.7 */
2188
2189   : port_direction_opt data_type_or_implicit IDENTIFIER dimensions_opt tf_port_item_expr_opt
2190       { vector<pform_tf_port_t>*tmp;
2191         NetNet::PortType use_port_type = $1;
2192         if ((use_port_type == NetNet::PIMPLICIT) && (gn_system_verilog() || ($2 == 0)))
2193               use_port_type = port_declaration_context.port_type;
2194         perm_string name = lex_strings.make($3);
2195         list<perm_string>* ilist = list_from_identifier($3);
2196
2197         if (use_port_type == NetNet::PIMPLICIT) {
2198               yyerror(@1, "error: missing task/function port direction.");
2199               use_port_type = NetNet::PINPUT; // for error recovery
2200         }
2201         if (($2 == 0) && ($1==NetNet::PIMPLICIT)) {
2202                 // Detect special case this is an undecorated
2203                 // identifier and we need to get the declaration from
2204                 // left context.
2205               if ($4 != 0) {
2206                     yyerror(@4, "internal error: How can there be an unpacked range here?\n");
2207               }
2208               tmp = pform_make_task_ports(@3, use_port_type,
2209                                           port_declaration_context.data_type,
2210                                           ilist);
2211
2212         } else {
2213                 // Otherwise, the decorations for this identifier
2214                 // indicate the type. Save the type for any right
2215                 // context that may come later.
2216               port_declaration_context.port_type = use_port_type;
2217               if ($2 == 0) {
2218                     $2 = new vector_type_t(IVL_VT_LOGIC, false, 0);
2219                     FILE_NAME($2, @3);
2220               }
2221               port_declaration_context.data_type = $2;
2222               tmp = pform_make_task_ports(@3, use_port_type, $2, ilist);
2223         }
2224         if ($4 != 0) {
2225               pform_set_reg_idx(name, $4);
2226         }
2227
2228         $$ = tmp;
2229         if ($5) {
2230               assert(tmp->size()==1);
2231               tmp->front().defe = $5;
2232         }
2233       }
2234
2235   /* Rules to match error cases... */
2236
2237   | port_direction_opt data_type_or_implicit IDENTIFIER error
2238       { yyerror(@3, "error: Error in task/function port item after port name %s.", $3);
2239         yyerrok;
2240         $$ = 0;
2241       }
2242   ;
2243
2244   /* This rule matches the [ = <expression> ] part of the tf_port_item rules. */
2245
2246 tf_port_item_expr_opt
2247   : '=' expression
2248       { if (! gn_system_verilog()) {
2249               yyerror(@1, "error: Task/function default arguments require "
2250                           "SystemVerilog.");
2251         }
2252         $$ = $2;
2253       }
2254   |   { $$ = 0; }
2255   ;
2256
2257 tf_port_list /* IEEE1800-2005: A.2.7 */
2258   :   { port_declaration_context.port_type = gn_system_verilog() ? NetNet::PINPUT : NetNet::PIMPLICIT;
2259         port_declaration_context.data_type = 0;
2260       }
2261     tf_port_item_list
2262       { $$ = $2; }
2263   ;
2264
2265 tf_port_item_list
2266   : tf_port_item_list ',' tf_port_item
2267       { vector<pform_tf_port_t>*tmp;
2268         if ($1 && $3) {
2269               size_t s1 = $1->size();
2270               tmp = $1;
2271               tmp->resize(tmp->size()+$3->size());
2272               for (size_t idx = 0 ; idx < $3->size() ; idx += 1)
2273                     tmp->at(s1+idx) = $3->at(idx);
2274               delete $3;
2275         } else if ($1) {
2276               tmp = $1;
2277         } else {
2278               tmp = $3;
2279         }
2280         $$ = tmp;
2281       }
2282
2283   | tf_port_item
2284       { $$ = $1; }
2285
2286   /* Rules to handle some errors in tf_port_list items. */
2287
2288   | error ',' tf_port_item
2289       { yyerror(@2, "error: Syntax error in task/function port declaration.");
2290         $$ = $3;
2291       }
2292   | tf_port_item_list ','
2293       { yyerror(@2, "error: NULL port declarations are not allowed.");
2294         $$ = $1;
2295       }
2296   | tf_port_item_list ';'
2297       { yyerror(@2, "error: ';' is an invalid port declaration separator.");
2298         $$ = $1;
2299       }
2300   ;
2301
2302 timeunits_declaration /* IEEE1800-2005: A.1.2 */
2303   : K_timeunit TIME_LITERAL ';'
2304       { pform_set_timeunit($2, allow_timeunit_decl); }
2305   | K_timeunit TIME_LITERAL '/' TIME_LITERAL ';'
2306       { bool initial_decl = allow_timeunit_decl && allow_timeprec_decl;
2307         pform_set_timeunit($2, initial_decl);
2308         pform_set_timeprec($4, initial_decl);
2309       }
2310   | K_timeprecision TIME_LITERAL ';'
2311       { pform_set_timeprec($2, allow_timeprec_decl); }
2312   ;
2313
2314   /* Allow zero, one, or two declarations. The second declaration might
2315      be a repeat declaration, but the pform functions take care of that. */
2316 timeunits_declaration_opt
2317   : /* empty */           %prec no_timeunits_declaration
2318   | timeunits_declaration %prec one_timeunits_declaration
2319   | timeunits_declaration timeunits_declaration
2320   ;
2321
2322 value_range /* IEEE1800-2005: A.8.3 */
2323   : expression
2324       { }
2325   | '[' expression ':' expression ']'
2326       { }
2327   ;
2328
2329 variable_dimension /* IEEE1800-2005: A.2.5 */
2330   : '[' expression ':' expression ']'
2331       { list<pform_range_t> *tmp = new list<pform_range_t>;
2332         pform_range_t index ($2,$4);
2333         tmp->push_back(index);
2334         $$ = tmp;
2335       }
2336   | '[' expression ']'
2337       { // SystemVerilog canonical range
2338         if (!gn_system_verilog()) {
2339               warn_count += 1;
2340               cerr << @2 << ": warning: Use of SystemVerilog [size] dimension. "
2341                    << "Use at least -g2005-sv to remove this warning." << endl;
2342         }
2343         list<pform_range_t> *tmp = new list<pform_range_t>;
2344         pform_range_t index;
2345         index.first = new PENumber(new verinum((uint64_t)0, integer_width));
2346         index.second = new PEBinary('-', $2, new PENumber(new verinum((uint64_t)1, integer_width)));
2347         tmp->push_back(index);
2348         $$ = tmp;
2349       }
2350   | '[' ']'
2351       { list<pform_range_t> *tmp = new list<pform_range_t>;
2352         pform_range_t index (0,0);
2353         tmp->push_back(index);
2354         $$ = tmp;
2355       }
2356   | '[' '$' ']'
2357       { // SystemVerilog queue
2358         list<pform_range_t> *tmp = new list<pform_range_t>;
2359         pform_range_t index (new PENull,0);
2360         if (!gn_system_verilog()) {
2361               yyerror("error: Queue declarations require SystemVerilog.");
2362         }
2363         tmp->push_back(index);
2364         $$ = tmp;
2365       }
2366   ;
2367
2368 variable_lifetime
2369   : lifetime
2370       { if (!gn_system_verilog()) {
2371               yyerror(@1, "error: overriding the default variable lifetime "
2372                           "requires SystemVerilog.");
2373         } else if ($1 != pform_peek_scope()->default_lifetime) {
2374               yyerror(@1, "sorry: overriding the default variable lifetime "
2375                           "is not yet supported.");
2376         }
2377         var_lifetime = $1;
2378       }
2379   ;
2380
2381   /* Verilog-2001 supports attribute lists, which can be attached to a
2382      variety of different objects. The syntax inside the (* *) is a
2383      comma separated list of names or names with assigned values. */
2384 attribute_list_opt
2385   : attribute_instance_list
2386       { $$ = $1; }
2387   |
2388       { $$ = 0; }
2389   ;
2390
2391 attribute_instance_list
2392   : K_PSTAR K_STARP { $$ = 0; }
2393   | K_PSTAR attribute_list K_STARP { $$ = $2; }
2394   | attribute_instance_list K_PSTAR K_STARP { $$ = $1; }
2395   | attribute_instance_list K_PSTAR attribute_list K_STARP
2396       { list<named_pexpr_t>*tmp = $1;
2397         if (tmp) {
2398             tmp->splice(tmp->end(), *$3);
2399             delete $3;
2400             $$ = tmp;
2401         } else $$ = $3;
2402       }
2403   ;
2404
2405 attribute_list
2406   : attribute_list ',' attribute
2407       { list<named_pexpr_t>*tmp = $1;
2408         tmp->push_back(*$3);
2409         delete $3;
2410         $$ = tmp;
2411       }
2412   | attribute
2413       { list<named_pexpr_t>*tmp = new list<named_pexpr_t>;
2414         tmp->push_back(*$1);
2415         delete $1;
2416         $$ = tmp;
2417       }
2418   ;
2419
2420
2421 attribute
2422         : IDENTIFIER
2423                 { named_pexpr_t*tmp = new named_pexpr_t;
2424                   tmp->name = lex_strings.make($1);
2425                   tmp->parm = 0;
2426                   delete[]$1;
2427                   $$ = tmp;
2428                 }
2429         | IDENTIFIER '=' expression
2430                 { PExpr*tmp = $3;
2431                   named_pexpr_t*tmp2 = new named_pexpr_t;
2432                   tmp2->name = lex_strings.make($1);
2433                   tmp2->parm = tmp;
2434                   delete[]$1;
2435                   $$ = tmp2;
2436                 }
2437         ;
2438
2439
2440   /* The block_item_decl is used in function definitions, task
2441      definitions, module definitions and named blocks. Wherever a new
2442      scope is entered, the source may declare new registers and
2443      integers. This rule matches those declarations. The containing
2444      rule has presumably set up the scope. */
2445
2446 block_item_decl
2447
2448   /* variable declarations. Note that data_type can be 0 if we are
2449      recovering from an error. */
2450
2451   : data_type register_variable_list ';'
2452       { if ($1) pform_set_data_type(@1, $1, $2, NetNet::REG, attributes_in_context);
2453       }
2454
2455   | variable_lifetime data_type register_variable_list ';'
2456       { if ($2) pform_set_data_type(@2, $2, $3, NetNet::REG, attributes_in_context);
2457         var_lifetime = LexicalScope::INHERITED;
2458       }
2459
2460   | K_reg data_type register_variable_list ';'
2461       { if ($2) pform_set_data_type(@2, $2, $3, NetNet::REG, attributes_in_context);
2462       }
2463
2464   | variable_lifetime K_reg data_type register_variable_list ';'
2465       { if ($3) pform_set_data_type(@3, $3, $4, NetNet::REG, attributes_in_context);
2466         var_lifetime = LexicalScope::INHERITED;
2467       }
2468
2469   | K_event event_variable_list ';'
2470       { if ($2) pform_make_events($2, @1.text, @1.first_line);
2471       }
2472
2473   | K_parameter param_type parameter_assign_list ';'
2474   | K_localparam param_type localparam_assign_list ';'
2475
2476   /* Blocks can have type declarations. */
2477
2478   | type_declaration
2479
2480   /* Recover from errors that happen within variable lists. Use the
2481      trailing semi-colon to resync the parser. */
2482
2483   | K_integer error ';'
2484       { yyerror(@1, "error: syntax error in integer variable list.");
2485         yyerrok;
2486       }
2487
2488   | K_time error ';'
2489       { yyerror(@1, "error: syntax error in time variable list.");
2490         yyerrok;
2491       }
2492
2493   | K_parameter error ';'
2494       { yyerror(@1, "error: syntax error in parameter list.");
2495         yyerrok;
2496       }
2497   | K_localparam error ';'
2498       { yyerror(@1, "error: syntax error localparam list.");
2499         yyerrok;
2500       }
2501   ;
2502
2503 block_item_decls
2504         : block_item_decl
2505         | block_item_decls block_item_decl
2506         ;
2507
2508 block_item_decls_opt
2509         : block_item_decls { $$ = true; }
2510         | { $$ = false; }
2511         ;
2512
2513   /* Type declarations are parsed here. The rule actions call pform
2514      functions that add the declaration to the current lexical scope. */
2515 type_declaration
2516   : K_typedef data_type IDENTIFIER dimensions_opt ';'
2517       { perm_string name = lex_strings.make($3);
2518         pform_set_typedef(name, $2, $4);
2519         delete[]$3;
2520       }
2521
2522   /* If the IDENTIFIER already is a typedef, it is possible for this
2523      code to override the definition, but only if the typedef is
2524      inherited from a different scope. */
2525   | K_typedef data_type TYPE_IDENTIFIER ';'
2526       { perm_string name = lex_strings.make($3.text);
2527         if (pform_test_type_identifier_local(name)) {
2528               yyerror(@3, "error: Typedef identifier \"%s\" is already a type name.", $3.text);
2529
2530         } else {
2531               pform_set_typedef(name, $2, NULL);
2532         }
2533         delete[]$3.text;
2534       }
2535
2536   /* These are forward declarations... */
2537
2538   | K_typedef K_class  IDENTIFIER ';'
2539       { // Create a synthetic typedef for the class name so that the
2540         // lexor detects the name as a type.
2541         perm_string name = lex_strings.make($3);
2542         class_type_t*tmp = new class_type_t(name);
2543         FILE_NAME(tmp, @3);
2544         pform_set_typedef(name, tmp, NULL);
2545         delete[]$3;
2546       }
2547   | K_typedef K_enum   IDENTIFIER ';'
2548       { yyerror(@1, "sorry: Enum forward declarations not supported yet."); }
2549   | K_typedef K_struct IDENTIFIER ';'
2550       { yyerror(@1, "sorry: Struct forward declarations not supported yet."); }
2551   | K_typedef K_union  IDENTIFIER ';'
2552       { yyerror(@1, "sorry: Union forward declarations not supported yet."); }
2553   | K_typedef          IDENTIFIER ';'
2554       { // Create a synthetic typedef for the class name so that the
2555         // lexor detects the name as a type.
2556         perm_string name = lex_strings.make($2);
2557         class_type_t*tmp = new class_type_t(name);
2558         FILE_NAME(tmp, @2);
2559         pform_set_typedef(name, tmp, NULL);
2560         delete[]$2;
2561       }
2562
2563   | K_typedef error ';'
2564       { yyerror(@2, "error: Syntax error in typedef clause.");
2565         yyerrok;
2566       }
2567
2568   ;
2569
2570   /* The structure for an enumeration data type is the keyword "enum",
2571      followed by the enumeration values in curly braces. Also allow
2572      for an optional base type. The default base type is "int", but it
2573      can be any of the integral or vector types. */
2574
2575 enum_data_type
2576   : K_enum '{' enum_name_list '}'
2577       { enum_type_t*enum_type = new enum_type_t;
2578         FILE_NAME(enum_type, @1);
2579         enum_type->names .reset($3);
2580         enum_type->base_type = IVL_VT_BOOL;
2581         enum_type->signed_flag = true;
2582         enum_type->integer_flag = false;
2583         enum_type->range.reset(make_range_from_width(32));
2584         $$ = enum_type;
2585       }
2586   | K_enum atom2_type signed_unsigned_opt '{' enum_name_list '}'
2587       { enum_type_t*enum_type = new enum_type_t;
2588         FILE_NAME(enum_type, @1);
2589         enum_type->names .reset($5);
2590         enum_type->base_type = IVL_VT_BOOL;
2591         enum_type->signed_flag = $3;
2592         enum_type->integer_flag = false;
2593         enum_type->range.reset(make_range_from_width($2));
2594         $$ = enum_type;
2595       }
2596   | K_enum K_integer signed_unsigned_opt '{' enum_name_list '}'
2597       { enum_type_t*enum_type = new enum_type_t;
2598         FILE_NAME(enum_type, @1);
2599         enum_type->names .reset($5);
2600         enum_type->base_type = IVL_VT_LOGIC;
2601         enum_type->signed_flag = $3;
2602         enum_type->integer_flag = true;
2603         enum_type->range.reset(make_range_from_width(integer_width));
2604         $$ = enum_type;
2605       }
2606   | K_enum K_logic unsigned_signed_opt dimensions_opt '{' enum_name_list '}'
2607       { enum_type_t*enum_type = new enum_type_t;
2608         FILE_NAME(enum_type, @1);
2609         enum_type->names .reset($6);
2610         enum_type->base_type = IVL_VT_LOGIC;
2611         enum_type->signed_flag = $3;
2612         enum_type->integer_flag = false;
2613         enum_type->range.reset($4 ? $4 : make_range_from_width(1));
2614         $$ = enum_type;
2615       }
2616   | K_enum K_reg unsigned_signed_opt dimensions_opt '{' enum_name_list '}'
2617       { enum_type_t*enum_type = new enum_type_t;
2618         FILE_NAME(enum_type, @1);
2619         enum_type->names .reset($6);
2620         enum_type->base_type = IVL_VT_LOGIC;
2621         enum_type->signed_flag = $3;
2622         enum_type->integer_flag = false;
2623         enum_type->range.reset($4 ? $4 : make_range_from_width(1));
2624         $$ = enum_type;
2625       }
2626   | K_enum K_bit unsigned_signed_opt dimensions_opt '{' enum_name_list '}'
2627       { enum_type_t*enum_type = new enum_type_t;
2628         FILE_NAME(enum_type, @1);
2629         enum_type->names .reset($6);
2630         enum_type->base_type = IVL_VT_BOOL;
2631         enum_type->signed_flag = $3;
2632         enum_type->integer_flag = false;
2633         enum_type->range.reset($4 ? $4 : make_range_from_width(1));
2634         $$ = enum_type;
2635       }
2636   ;
2637
2638 enum_name_list
2639   : enum_name
2640       { $$ = $1;
2641       }
2642   | enum_name_list ',' enum_name
2643       { list<named_pexpr_t>*lst = $1;
2644         lst->splice(lst->end(), *$3);
2645         delete $3;
2646         $$ = lst;
2647       }
2648   ;
2649
2650 pos_neg_number
2651   : number
2652       { $$ = $1;
2653       }
2654   | '-' number
2655       { verinum tmp = -(*($2));
2656         *($2) = tmp;
2657         $$ = $2;
2658       }
2659   ;
2660
2661 enum_name
2662   : IDENTIFIER
2663       { perm_string name = lex_strings.make($1);
2664         delete[]$1;
2665         $$ = make_named_number(name);
2666       }
2667   | IDENTIFIER '[' pos_neg_number ']'
2668       { perm_string name = lex_strings.make($1);
2669         long count = check_enum_seq_value(@1, $3, false);
2670         delete[]$1;
2671         $$ = make_named_numbers(name, 0, count-1);
2672         delete $3;
2673       }
2674   | IDENTIFIER '[' pos_neg_number ':' pos_neg_number ']'
2675       { perm_string name = lex_strings.make($1);
2676         $$ = make_named_numbers(name, check_enum_seq_value(@1, $3, true),
2677                                       check_enum_seq_value(@1, $5, true));
2678         delete[]$1;
2679         delete $3;
2680         delete $5;
2681       }
2682   | IDENTIFIER '=' expression
2683       { perm_string name = lex_strings.make($1);
2684         delete[]$1;
2685         $$ = make_named_number(name, $3);
2686       }
2687   | IDENTIFIER '[' pos_neg_number ']' '=' expression
2688       { perm_string name = lex_strings.make($1);
2689         long count = check_enum_seq_value(@1, $3, false);
2690         $$ = make_named_numbers(name, 0, count-1, $6);
2691         delete[]$1;
2692         delete $3;
2693       }
2694   | IDENTIFIER '[' pos_neg_number ':' pos_neg_number ']' '=' expression
2695       { perm_string name = lex_strings.make($1);
2696         $$ = make_named_numbers(name, check_enum_seq_value(@1, $3, true),
2697                                       check_enum_seq_value(@1, $5, true), $8);
2698         delete[]$1;
2699         delete $3;
2700         delete $5;
2701       }
2702   ;
2703
2704 struct_data_type
2705   : K_struct K_packed_opt '{' struct_union_member_list '}'
2706       { struct_type_t*tmp = new struct_type_t;
2707         FILE_NAME(tmp, @1);
2708         tmp->packed_flag = $2;
2709         tmp->union_flag = false;
2710         tmp->members .reset($4);
2711         $$ = tmp;
2712       }
2713   | K_union K_packed_opt '{' struct_union_member_list '}'
2714       { struct_type_t*tmp = new struct_type_t;
2715         FILE_NAME(tmp, @1);
2716         tmp->packed_flag = $2;
2717         tmp->union_flag = true;
2718         tmp->members .reset($4);
2719         $$ = tmp;
2720       }
2721   | K_struct K_packed_opt '{' error '}'
2722       { yyerror(@3, "error: Errors in struct member list.");
2723         yyerrok;
2724         struct_type_t*tmp = new struct_type_t;
2725         FILE_NAME(tmp, @1);
2726         tmp->packed_flag = $2;
2727         tmp->union_flag = false;
2728         $$ = tmp;
2729       }
2730   | K_union K_packed_opt '{' error '}'
2731       { yyerror(@3, "error: Errors in union member list.");
2732         yyerrok;
2733         struct_type_t*tmp = new struct_type_t;
2734         FILE_NAME(tmp, @1);
2735         tmp->packed_flag = $2;
2736         tmp->union_flag = true;
2737         $$ = tmp;
2738       }
2739   ;
2740
2741   /* This is an implementation of the rule snippet:
2742        struct_union_member { struct_union_member }
2743      that is used in the rule matching struct and union types
2744      in IEEE 1800-2012 A.2.2.1. */
2745 struct_union_member_list
2746   : struct_union_member_list struct_union_member
2747       { list<struct_member_t*>*tmp = $1;
2748         tmp->push_back($2);
2749         $$ = tmp;
2750       }
2751   | struct_union_member
2752       { list<struct_member_t*>*tmp = new list<struct_member_t*>;
2753         tmp->push_back($1);
2754         $$ = tmp;
2755       }
2756   ;
2757
2758 struct_union_member /* IEEE 1800-2012 A.2.2.1 */
2759   : attribute_list_opt data_type list_of_variable_decl_assignments ';'
2760       { struct_member_t*tmp = new struct_member_t;
2761         FILE_NAME(tmp, @2);
2762         tmp->type  .reset($2);
2763         tmp->names .reset($3);
2764         $$ = tmp;
2765       }
2766   | error ';'
2767       { yyerror(@2, "Error in struct/union member.");
2768         yyerrok;
2769         $$ = 0;
2770       }
2771   ;
2772
2773 case_item
2774         : expression_list_proper ':' statement_or_null
2775                 { PCase::Item*tmp = new PCase::Item;
2776                   tmp->expr = *$1;
2777                   tmp->stat = $3;
2778                   delete $1;
2779                   $$ = tmp;
2780                 }
2781         | K_default ':' statement_or_null
2782                 { PCase::Item*tmp = new PCase::Item;
2783                   tmp->stat = $3;
2784                   $$ = tmp;
2785                 }
2786         | K_default  statement_or_null
2787                 { PCase::Item*tmp = new PCase::Item;
2788                   tmp->stat = $2;
2789                   $$ = tmp;
2790                 }
2791         | error ':' statement_or_null
2792                 { yyerror(@2, "error: Incomprehensible case expression.");
2793                   yyerrok;
2794                 }
2795         ;
2796
2797 case_items
2798         : case_items case_item
2799                 { svector<PCase::Item*>*tmp;
2800                   tmp = new svector<PCase::Item*>(*$1, $2);
2801                   delete $1;
2802                   $$ = tmp;
2803                 }
2804         | case_item
2805                 { svector<PCase::Item*>*tmp = new svector<PCase::Item*>(1);
2806                   (*tmp)[0] = $1;
2807                   $$ = tmp;
2808                 }
2809         ;
2810
2811 charge_strength
2812         : '(' K_small ')'
2813         | '(' K_medium ')'
2814         | '(' K_large ')'
2815         ;
2816
2817 charge_strength_opt
2818         : charge_strength
2819         |
2820         ;
2821
2822 defparam_assign
2823         : hierarchy_identifier '=' expression
2824                 { pform_set_defparam(*$1, $3);
2825                   delete $1;
2826                 }
2827         ;
2828
2829 defparam_assign_list
2830   : defparam_assign
2831   | dimensions defparam_assign
2832       { yyerror(@1, "error: defparam may not include a range.");
2833         delete $1;
2834       }
2835   | defparam_assign_list ',' defparam_assign
2836         ;
2837
2838 delay1
2839         : '#' delay_value_simple
2840                 { list<PExpr*>*tmp = new list<PExpr*>;
2841                   tmp->push_back($2);
2842                   $$ = tmp;
2843                 }
2844         | '#' '(' delay_value ')'
2845                 { list<PExpr*>*tmp = new list<PExpr*>;
2846                   tmp->push_back($3);
2847                   $$ = tmp;
2848                 }
2849         ;
2850
2851 delay3
2852         : '#' delay_value_simple
2853                 { list<PExpr*>*tmp = new list<PExpr*>;
2854                   tmp->push_back($2);
2855                   $$ = tmp;
2856                 }
2857         | '#' '(' delay_value ')'
2858                 { list<PExpr*>*tmp = new list<PExpr*>;
2859                   tmp->push_back($3);
2860                   $$ = tmp;
2861                 }
2862         | '#' '(' delay_value ',' delay_value ')'
2863                 { list<PExpr*>*tmp = new list<PExpr*>;
2864                   tmp->push_back($3);
2865                   tmp->push_back($5);
2866                   $$ = tmp;
2867                 }
2868         | '#' '(' delay_value ',' delay_value ',' delay_value ')'
2869                 { list<PExpr*>*tmp = new list<PExpr*>;
2870                   tmp->push_back($3);
2871                   tmp->push_back($5);
2872                   tmp->push_back($7);
2873                   $$ = tmp;
2874                 }
2875         ;
2876
2877 delay3_opt
2878         : delay3 { $$ = $1; }
2879         |        { $$ = 0; }
2880         ;
2881
2882 delay_value_list
2883   : delay_value
2884       { list<PExpr*>*tmp = new list<PExpr*>;
2885         tmp->push_back($1);
2886         $$ = tmp;
2887       }
2888   | delay_value_list ',' delay_value
2889       { list<PExpr*>*tmp = $1;
2890         tmp->push_back($3);
2891         $$ = tmp;
2892       }
2893   ;
2894
2895 delay_value
2896         : expression
2897                 { PExpr*tmp = $1;
2898                   $$ = tmp;
2899                 }
2900         | expression ':' expression ':' expression
2901                 { $$ = pform_select_mtm_expr($1, $3, $5); }
2902         ;
2903
2904
2905 delay_value_simple
2906         : DEC_NUMBER
2907                 { verinum*tmp = $1;
2908                   if (tmp == 0) {
2909                         yyerror(@1, "internal error: delay.");
2910                         $$ = 0;
2911                   } else {
2912                         $$ = new PENumber(tmp);
2913                         FILE_NAME($$, @1);
2914                   }
2915                   based_size = 0;
2916                 }
2917         | REALTIME
2918                 { verireal*tmp = $1;
2919                   if (tmp == 0) {
2920                         yyerror(@1, "internal error: delay.");
2921                         $$ = 0;
2922                   } else {
2923                         $$ = new PEFNumber(tmp);
2924                         FILE_NAME($$, @1);
2925                   }
2926                 }
2927         | IDENTIFIER
2928                 { PEIdent*tmp = new PEIdent(lex_strings.make($1));
2929                   FILE_NAME(tmp, @1);
2930                   $$ = tmp;
2931                   delete[]$1;
2932                 }
2933         | TIME_LITERAL
2934                 { int unit;
2935
2936                   based_size = 0;
2937                   $$         = 0;
2938                   if ($1 == 0 || !get_time_unit($1, unit))
2939                         yyerror(@1, "internal error: delay.");
2940                   else {
2941                         double p = pow(10.0,
2942                                        (double)(unit - pform_get_timeunit()));
2943                         double time = atof($1) * p;
2944
2945                         verireal *v = new verireal(time);
2946                         $$ = new PEFNumber(v);
2947                         FILE_NAME($$, @1);
2948                   }
2949                 }
2950         ;
2951
2952   /* The discipline and nature declarations used to take no ';' after
2953      the identifier. The 2.3 LRM adds the ';', but since there are
2954      programs written to the 2.1 and 2.2 standard that don't, we
2955      choose to make the ';' optional in this context. */
2956 optional_semicolon : ';' | ;
2957
2958 discipline_declaration
2959   : K_discipline IDENTIFIER optional_semicolon
2960       { pform_start_discipline($2); }
2961     discipline_items K_enddiscipline
2962       { pform_end_discipline(@1); delete[] $2; }
2963   ;
2964
2965 discipline_items
2966   : discipline_items discipline_item
2967   | discipline_item
2968   ;
2969
2970 discipline_item
2971   : K_domain K_discrete ';'
2972       { pform_discipline_domain(@1, IVL_DIS_DISCRETE); }
2973   | K_domain K_continuous ';'
2974       { pform_discipline_domain(@1, IVL_DIS_CONTINUOUS); }
2975   | K_potential IDENTIFIER ';'
2976       { pform_discipline_potential(@1, $2); delete[] $2; }
2977   | K_flow IDENTIFIER ';'
2978       { pform_discipline_flow(@1, $2); delete[] $2; }
2979   ;
2980
2981 nature_declaration
2982   : K_nature IDENTIFIER optional_semicolon
2983       { pform_start_nature($2); }
2984     nature_items
2985     K_endnature
2986       { pform_end_nature(@1); delete[] $2; }
2987   ;
2988
2989 nature_items
2990   : nature_items nature_item
2991   | nature_item
2992   ;
2993
2994 nature_item
2995   : K_units '=' STRING ';'
2996       { delete[] $3; }
2997   | K_abstol '=' expression ';'
2998   | K_access '=' IDENTIFIER ';'
2999       { pform_nature_access(@1, $3); delete[] $3; }
3000   | K_idt_nature '=' IDENTIFIER ';'
3001       { delete[] $3; }
3002   | K_ddt_nature '=' IDENTIFIER ';'
3003       { delete[] $3; }
3004   ;
3005
3006 config_declaration
3007   : K_config IDENTIFIER ';'
3008     K_design lib_cell_identifiers ';'
3009     list_of_config_rule_statements
3010     K_endconfig
3011       { cerr << @1 << ": sorry: config declarations are not supported and "
3012                 "will be skipped." << endl;
3013         delete[] $2;
3014       }
3015   ;
3016
3017 lib_cell_identifiers
3018   : /* The BNF implies this can be blank, but I'm not sure exactly what
3019      * this means. */
3020   | lib_cell_identifiers lib_cell_id
3021   ;
3022
3023 list_of_config_rule_statements
3024   : /* config rules are optional. */
3025   | list_of_config_rule_statements config_rule_statement
3026   ;
3027
3028 config_rule_statement
3029   : K_default K_liblist list_of_libraries ';'
3030   | K_instance hierarchy_identifier K_liblist list_of_libraries ';'
3031       { delete $2; }
3032   | K_instance hierarchy_identifier K_use lib_cell_id opt_config ';'
3033       { delete $2; }
3034   | K_cell lib_cell_id K_liblist list_of_libraries ';'
3035   | K_cell lib_cell_id K_use lib_cell_id opt_config ';'
3036   ;
3037
3038 opt_config
3039   : /* The use clause takes an optional :config. */
3040   | ':' K_config
3041   ;
3042
3043 lib_cell_id
3044   : IDENTIFIER
3045       { delete[] $1; }
3046   | IDENTIFIER '.' IDENTIFIER
3047       { delete[] $1; delete[] $3; }
3048   ;
3049
3050 list_of_libraries
3051   : /* A NULL library means use the parents cell library. */
3052   | list_of_libraries IDENTIFIER
3053       { delete[] $2; }
3054   ;
3055
3056 drive_strength
3057         : '(' dr_strength0 ',' dr_strength1 ')'
3058                 { $$.str0 = $2.str0;
3059                   $$.str1 = $4.str1;
3060                 }
3061         | '(' dr_strength1 ',' dr_strength0 ')'
3062                 { $$.str0 = $4.str0;
3063                   $$.str1 = $2.str1;
3064                 }
3065         | '(' dr_strength0 ',' K_highz1 ')'
3066                 { $$.str0 = $2.str0;
3067                   $$.str1 = IVL_DR_HiZ;
3068                 }
3069         | '(' dr_strength1 ',' K_highz0 ')'
3070                 { $$.str0 = IVL_DR_HiZ;
3071                   $$.str1 = $2.str1;
3072                 }
3073         | '(' K_highz1 ',' dr_strength0 ')'
3074                 { $$.str0 = $4.str0;
3075                   $$.str1 = IVL_DR_HiZ;
3076                 }
3077         | '(' K_highz0 ',' dr_strength1 ')'
3078                 { $$.str0 = IVL_DR_HiZ;
3079                   $$.str1 = $4.str1;
3080                 }
3081         ;
3082
3083 drive_strength_opt
3084         : drive_strength { $$ = $1; }
3085         |                { $$.str0 = IVL_DR_STRONG; $$.str1 = IVL_DR_STRONG; }
3086         ;
3087
3088 dr_strength0
3089         : K_supply0 { $$.str0 = IVL_DR_SUPPLY; }
3090         | K_strong0 { $$.str0 = IVL_DR_STRONG; }
3091         | K_pull0   { $$.str0 = IVL_DR_PULL; }
3092         | K_weak0   { $$.str0 = IVL_DR_WEAK; }
3093         ;
3094
3095 dr_strength1
3096         : K_supply1 { $$.str1 = IVL_DR_SUPPLY; }
3097         | K_strong1 { $$.str1 = IVL_DR_STRONG; }
3098         | K_pull1   { $$.str1 = IVL_DR_PULL; }
3099         | K_weak1   { $$.str1 = IVL_DR_WEAK; }
3100         ;
3101
3102 clocking_event_opt /* */
3103   : event_control
3104   |
3105   ;
3106
3107 event_control /* A.K.A. clocking_event */
3108         : '@' hierarchy_identifier
3109                 { PEIdent*tmpi = new PEIdent(*$2);
3110                   PEEvent*tmpe = new PEEvent(PEEvent::ANYEDGE, tmpi);
3111                   PEventStatement*tmps = new PEventStatement(tmpe);
3112                   FILE_NAME(tmps, @1);
3113                   $$ = tmps;
3114                   delete $2;
3115                 }
3116         | '@' '(' event_expression_list ')'
3117                 { PEventStatement*tmp = new PEventStatement(*$3);
3118                   FILE_NAME(tmp, @1);
3119                   delete $3;
3120                   $$ = tmp;
3121                 }
3122         | '@' '(' error ')'
3123                 { yyerror(@1, "error: Malformed event control expression.");
3124                   $$ = 0;
3125                 }
3126         ;
3127
3128 event_expression_list
3129         : event_expression
3130                 { $$ = $1; }
3131         | event_expression_list K_or event_expression
3132                 { svector<PEEvent*>*tmp = new svector<PEEvent*>(*$1, *$3);
3133                   delete $1;
3134                   delete $3;
3135                   $$ = tmp;
3136                 }
3137         | event_expression_list ',' event_expression
3138                 { svector<PEEvent*>*tmp = new svector<PEEvent*>(*$1, *$3);
3139                   delete $1;
3140                   delete $3;
3141                   $$ = tmp;
3142                 }
3143         ;
3144
3145 event_expression
3146         : K_posedge expression
3147                 { PEEvent*tmp = new PEEvent(PEEvent::POSEDGE, $2);
3148                   FILE_NAME(tmp, @1);
3149                   svector<PEEvent*>*tl = new svector<PEEvent*>(1);
3150                   (*tl)[0] = tmp;
3151                   $$ = tl;
3152                 }
3153         | K_negedge expression
3154                 { PEEvent*tmp = new PEEvent(PEEvent::NEGEDGE, $2);
3155                   FILE_NAME(tmp, @1);
3156                   svector<PEEvent*>*tl = new svector<PEEvent*>(1);
3157                   (*tl)[0] = tmp;
3158                   $$ = tl;
3159                 }
3160         | expression
3161                 { PEEvent*tmp = new PEEvent(PEEvent::ANYEDGE, $1);
3162                   FILE_NAME(tmp, @1);
3163                   svector<PEEvent*>*tl = new svector<PEEvent*>(1);
3164                   (*tl)[0] = tmp;
3165                   $$ = tl;
3166                 }
3167         ;
3168
3169   /* A branch probe expression applies a probe function (potential or
3170      flow) to a branch. The branch may be implicit as a pair of nets
3171      or explicit as a named branch. Elaboration will check that the
3172      function name really is a nature attribute identifier. */
3173 branch_probe_expression
3174   : IDENTIFIER '(' IDENTIFIER ',' IDENTIFIER ')'
3175       { $$ = pform_make_branch_probe_expression(@1, $1, $3, $5); }
3176   | IDENTIFIER '(' IDENTIFIER ')'
3177       { $$ = pform_make_branch_probe_expression(@1, $1, $3); }
3178   ;
3179
3180 expression
3181   : expr_primary_or_typename
3182       { $$ = $1; }
3183   | inc_or_dec_expression
3184       { $$ = $1; }
3185   | inside_expression
3186       { $$ = $1; }
3187   | '+' attribute_list_opt expr_primary %prec UNARY_PREC
3188       { $$ = $3; }
3189   | '-' attribute_list_opt expr_primary %prec UNARY_PREC
3190       { PEUnary*tmp = new PEUnary('-', $3);
3191         FILE_NAME(tmp, @3);
3192         $$ = tmp;
3193       }
3194   | '~' attribute_list_opt expr_primary %prec UNARY_PREC
3195       { PEUnary*tmp = new PEUnary('~', $3);
3196         FILE_NAME(tmp, @3);
3197         $$ = tmp;
3198       }
3199   | '&' attribute_list_opt expr_primary %prec UNARY_PREC
3200       { PEUnary*tmp = new PEUnary('&', $3);
3201         FILE_NAME(tmp, @3);
3202         $$ = tmp;
3203       }
3204   | '!' attribute_list_opt expr_primary %prec UNARY_PREC
3205       { PEUnary*tmp = new PEUnary('!', $3);
3206         FILE_NAME(tmp, @3);
3207         $$ = tmp;
3208       }
3209   | '|' attribute_list_opt expr_primary %prec UNARY_PREC
3210       { PEUnary*tmp = new PEUnary('|', $3);
3211         FILE_NAME(tmp, @3);
3212         $$ = tmp;
3213       }
3214   | '^' attribute_list_opt expr_primary %prec UNARY_PREC
3215       { PEUnary*tmp = new PEUnary('^', $3);
3216         FILE_NAME(tmp, @3);
3217         $$ = tmp;
3218       }
3219   | '~' '&' attribute_list_opt expr_primary %prec UNARY_PREC
3220       { yyerror(@1, "error: '~' '&'  is not a valid expression. "
3221                 "Please use operator '~&' instead.");
3222         $$ = 0;
3223       }
3224   | '~' '|' attribute_list_opt expr_primary %prec UNARY_PREC
3225       { yyerror(@1, "error: '~' '|'  is not a valid expression. "
3226                 "Please use operator '~|' instead.");
3227         $$ = 0;
3228       }
3229   | '~' '^' attribute_list_opt expr_primary %prec UNARY_PREC
3230       { yyerror(@1, "error: '~' '^'  is not a valid expression. "
3231                 "Please use operator '~^' instead.");
3232         $$ = 0;
3233       }
3234   | K_NAND attribute_list_opt expr_primary %prec UNARY_PREC
3235       { PEUnary*tmp = new PEUnary('A', $3);
3236         FILE_NAME(tmp, @3);
3237         $$ = tmp;
3238       }
3239   | K_NOR attribute_list_opt expr_primary %prec UNARY_PREC
3240       { PEUnary*tmp = new PEUnary('N', $3);
3241         FILE_NAME(tmp, @3);
3242         $$ = tmp;
3243       }
3244   | K_NXOR attribute_list_opt expr_primary %prec UNARY_PREC
3245       { PEUnary*tmp = new PEUnary('X', $3);
3246         FILE_NAME(tmp, @3);
3247         $$ = tmp;
3248       }
3249   | '!' error %prec UNARY_PREC
3250       { yyerror(@1, "error: Operand of unary ! "
3251                 "is not a primary expression.");
3252         $$ = 0;
3253       }
3254   | '^' error %prec UNARY_PREC
3255       { yyerror(@1, "error: Operand of reduction ^ "
3256                 "is not a primary expression.");
3257         $$ = 0;
3258       }
3259   | expression '^' attribute_list_opt expression
3260       { PEBinary*tmp = new PEBinary('^', $1, $4);
3261         FILE_NAME(tmp, @2);
3262         $$ = tmp;
3263       }
3264   | expression K_POW attribute_list_opt expression
3265       { PEBinary*tmp = new PEBPower('p', $1, $4);
3266         FILE_NAME(tmp, @2);
3267         $$ = tmp;
3268       }
3269   | expression '*' attribute_list_opt expression
3270       { PEBinary*tmp = new PEBinary('*', $1, $4);
3271         FILE_NAME(tmp, @2);
3272         $$ = tmp;
3273       }
3274   | expression '/' attribute_list_opt expression
3275       { PEBinary*tmp = new PEBinary('/', $1, $4);
3276         FILE_NAME(tmp, @2);
3277         $$ = tmp;
3278       }
3279   | expression '%' attribute_list_opt expression
3280       { PEBinary*tmp = new PEBinary('%', $1, $4);
3281         FILE_NAME(tmp, @2);
3282         $$ = tmp;
3283       }
3284   | expression '+' attribute_list_opt expression
3285       { PEBinary*tmp = new PEBinary('+', $1, $4);
3286         FILE_NAME(tmp, @2);
3287         $$ = tmp;
3288       }
3289   | expression '-' attribute_list_opt expression
3290       { PEBinary*tmp = new PEBinary('-', $1, $4);
3291         FILE_NAME(tmp, @2);
3292         $$ = tmp;
3293       }
3294   | expression '&' attribute_list_opt expression
3295       { PEBinary*tmp = new PEBinary('&', $1, $4);
3296         FILE_NAME(tmp, @2);
3297         $$ = tmp;
3298       }
3299   | expression '|' attribute_list_opt expression
3300       { PEBinary*tmp = new PEBinary('|', $1, $4);
3301         FILE_NAME(tmp, @2);
3302         $$ = tmp;
3303       }
3304   | expression K_NAND attribute_list_opt expression
3305       { PEBinary*tmp = new PEBinary('A', $1, $4);
3306         FILE_NAME(tmp, @2);
3307         $$ = tmp;
3308       }
3309   | expression K_NOR attribute_list_opt expression
3310       { PEBinary*tmp = new PEBinary('O', $1, $4);
3311         FILE_NAME(tmp, @2);
3312         $$ = tmp;
3313       }
3314   | expression K_NXOR attribute_list_opt expression
3315       { PEBinary*tmp = new PEBinary('X', $1, $4);
3316         FILE_NAME(tmp, @2);
3317         $$ = tmp;
3318       }
3319   | expression '<' attribute_list_opt expression
3320       { PEBinary*tmp = new PEBComp('<', $1, $4);
3321         FILE_NAME(tmp, @2);
3322         $$ = tmp;
3323       }
3324   | expression '>' attribute_list_opt expression
3325       { PEBinary*tmp = new PEBComp('>', $1, $4);
3326         FILE_NAME(tmp, @2);
3327         $$ = tmp;
3328       }
3329   | expression K_LS attribute_list_opt expression
3330       { PEBinary*tmp = new PEBShift('l', $1, $4);
3331         FILE_NAME(tmp, @2);
3332         $$ = tmp;
3333       }
3334   | expression K_RS attribute_list_opt expression
3335       { PEBinary*tmp = new PEBShift('r', $1, $4);
3336         FILE_NAME(tmp, @2);
3337         $$ = tmp;
3338       }
3339   | expression K_RSS attribute_list_opt expression
3340       { PEBinary*tmp = new PEBShift('R', $1, $4);
3341         FILE_NAME(tmp, @2);
3342         $$ = tmp;
3343       }
3344   | expression K_EQ attribute_list_opt expression
3345       { PEBinary*tmp = new PEBComp('e', $1, $4);
3346         FILE_NAME(tmp, @2);
3347         $$ = tmp;
3348       }
3349   | expression K_CEQ attribute_list_opt expression
3350       { PEBinary*tmp = new PEBComp('E', $1, $4);
3351         FILE_NAME(tmp, @2);
3352         $$ = tmp;
3353       }
3354   | expression K_WEQ attribute_list_opt expression
3355       { PEBinary*tmp = new PEBComp('w', $1, $4);
3356         FILE_NAME(tmp, @2);
3357         $$ = tmp;
3358       }
3359   | expression K_LE attribute_list_opt expression
3360       { PEBinary*tmp = new PEBComp('L', $1, $4);
3361         FILE_NAME(tmp, @2);
3362         $$ = tmp;
3363       }
3364   | expression K_GE attribute_list_opt expression
3365       { PEBinary*tmp = new PEBComp('G', $1, $4);
3366         FILE_NAME(tmp, @2);
3367         $$ = tmp;
3368       }
3369   | expression K_NE attribute_list_opt expression
3370       { PEBinary*tmp = new PEBComp('n', $1, $4);
3371         FILE_NAME(tmp, @2);
3372         $$ = tmp;
3373       }
3374   | expression K_CNE attribute_list_opt expression
3375       { PEBinary*tmp = new PEBComp('N', $1, $4);
3376         FILE_NAME(tmp, @2);
3377         $$ = tmp;
3378       }
3379   | expression K_WNE attribute_list_opt expression
3380       { PEBinary*tmp = new PEBComp('W', $1, $4);
3381         FILE_NAME(tmp, @2);
3382         $$ = tmp;
3383       }
3384   | expression K_LOR attribute_list_opt expression
3385       { PEBinary*tmp = new PEBLogic('o', $1, $4);
3386         FILE_NAME(tmp, @2);
3387         $$ = tmp;
3388       }
3389   | expression K_LAND attribute_list_opt expression
3390       { PEBinary*tmp = new PEBLogic('a', $1, $4);
3391         FILE_NAME(tmp, @2);
3392         $$ = tmp;
3393       }
3394   | expression '?' attribute_list_opt expression ':' expression
3395       { PETernary*tmp = new PETernary($1, $4, $6);
3396         FILE_NAME(tmp, @2);
3397         $$ = tmp;
3398       }
3399   ;
3400
3401 expr_mintypmax
3402         : expression
3403                 { $$ = $1; }
3404         | expression ':' expression ':' expression
3405                 { switch (min_typ_max_flag) {
3406                       case MIN:
3407                         $$ = $1;
3408                         delete $3;
3409                         delete $5;
3410                         break;
3411                       case TYP:
3412                         delete $1;
3413                         $$ = $3;
3414                         delete $5;
3415                         break;
3416                       case MAX:
3417                         delete $1;
3418                         delete $3;
3419                         $$ = $5;
3420                         break;
3421                   }
3422                   if (min_typ_max_warn > 0) {
3423                         cerr << $$->get_fileline() << ": warning: choosing ";
3424                         switch (min_typ_max_flag) {
3425                             case MIN:
3426                               cerr << "min";
3427                               break;
3428                             case TYP:
3429                               cerr << "typ";
3430                               break;
3431                             case MAX:
3432                               cerr << "max";
3433                               break;
3434                         }
3435                         cerr << " expression." << endl;
3436                         min_typ_max_warn -= 1;
3437                   }
3438                 }
3439         ;
3440
3441
3442   /* Many contexts take a comma separated list of expressions. Null
3443      expressions can happen anywhere in the list, so there are two
3444      extra rules in expression_list_with_nuls for parsing and
3445      installing those nulls.
3446
3447      The expression_list_proper rules do not allow null items in the
3448      expression list, so can be used where nul expressions are not allowed. */
3449
3450 expression_list_with_nuls
3451   : expression_list_with_nuls ',' expression
3452       { list<PExpr*>*tmp = $1;
3453         tmp->push_back($3);
3454         $$ = tmp;
3455       }
3456   | expression
3457       { list<PExpr*>*tmp = new list<PExpr*>;
3458         tmp->push_back($1);
3459         $$ = tmp;
3460       }
3461   |
3462       { list<PExpr*>*tmp = new list<PExpr*>;
3463         tmp->push_back(0);
3464         $$ = tmp;
3465       }
3466   | expression_list_with_nuls ','
3467       { list<PExpr*>*tmp = $1;
3468         tmp->push_back(0);
3469         $$ = tmp;
3470       }
3471         ;
3472
3473 expression_list_proper
3474   : expression_list_proper ',' expression
3475       { list<PExpr*>*tmp = $1;
3476         tmp->push_back($3);
3477         $$ = tmp;
3478       }
3479   | expression
3480       { list<PExpr*>*tmp = new list<PExpr*>;
3481         tmp->push_back($1);
3482         $$ = tmp;
3483       }
3484   ;
3485
3486 expr_primary_or_typename
3487   : expr_primary
3488
3489   /* There are a few special cases (notably $bits argument) where the
3490      expression may be a type name. Let the elaborator sort this out. */
3491   | TYPE_IDENTIFIER
3492       { PETypename*tmp = new PETypename($1.type);
3493         FILE_NAME(tmp,@1);
3494         $$ = tmp;
3495         delete[]$1.text;
3496       }
3497
3498   ;
3499
3500 expr_primary
3501   : number
3502       { assert($1);
3503         PENumber*tmp = new PENumber($1);
3504         FILE_NAME(tmp, @1);
3505         $$ = tmp;
3506       }
3507   | REALTIME
3508       { PEFNumber*tmp = new PEFNumber($1);
3509         FILE_NAME(tmp, @1);
3510         $$ = tmp;
3511       }
3512   | STRING
3513       { PEString*tmp = new PEString($1);
3514         FILE_NAME(tmp, @1);
3515         $$ = tmp;
3516       }
3517   | TIME_LITERAL
3518       { int unit;
3519
3520           based_size = 0;
3521           $$         = 0;
3522           if ($1 == 0 || !get_time_unit($1, unit))
3523               yyerror(@1, "internal error: delay.");
3524           else {
3525               double p = pow(10.0, (double)(unit - pform_get_timeunit()));
3526               double time = atof($1) * p;
3527
3528               verireal *v = new verireal(time);
3529               $$ = new PEFNumber(v);
3530               FILE_NAME($$, @1);
3531           }
3532       }
3533   | SYSTEM_IDENTIFIER
3534       { perm_string tn = lex_strings.make($1);
3535         PECallFunction*tmp = new PECallFunction(tn);
3536         FILE_NAME(tmp, @1);
3537         $$ = tmp;
3538         delete[]$1;
3539       }
3540
3541   /* The hierarchy_identifier rule matches simple identifiers as well as
3542      indexed arrays and part selects */
3543
3544   | hierarchy_identifier
3545       { PEIdent*tmp = pform_new_ident(*$1);
3546         FILE_NAME(tmp, @1);
3547         $$ = tmp;
3548         delete $1;
3549       }
3550
3551   | PACKAGE_IDENTIFIER K_SCOPE_RES hierarchy_identifier
3552       { $$ = pform_package_ident(@2, $1, $3);
3553         delete $3;
3554       }
3555
3556   /* An identifier followed by an expression list in parentheses is a
3557      function call. If a system identifier, then a system function
3558      call. It can also be a call to a class method (function). */
3559
3560   | hierarchy_identifier '(' expression_list_with_nuls ')'
3561       { list<PExpr*>*expr_list = $3;
3562         strip_tail_items(expr_list);
3563         PECallFunction*tmp = pform_make_call_function(@1, *$1, *expr_list);
3564         delete $1;
3565         $$ = tmp;
3566       }
3567   | implicit_class_handle '.' hierarchy_identifier '(' expression_list_with_nuls ')'
3568       { pform_name_t*t_name = $1;
3569         while (! $3->empty()) {
3570               t_name->push_back($3->front());
3571               $3->pop_front();
3572         }
3573         list<PExpr*>*expr_list = $5;
3574         strip_tail_items(expr_list);
3575         PECallFunction*tmp = pform_make_call_function(@1, *t_name, *expr_list);
3576         delete $1;
3577         delete $3;
3578         $$ = tmp;
3579       }
3580   | SYSTEM_IDENTIFIER '(' expression_list_proper ')'
3581       { perm_string tn = lex_strings.make($1);
3582         PECallFunction*tmp = new PECallFunction(tn, *$3);
3583         FILE_NAME(tmp, @1);
3584         delete[]$1;
3585         $$ = tmp;
3586       }
3587   | PACKAGE_IDENTIFIER K_SCOPE_RES IDENTIFIER '(' expression_list_proper ')'
3588       { perm_string use_name = lex_strings.make($3);
3589         PECallFunction*tmp = new PECallFunction($1, use_name, *$5);
3590         FILE_NAME(tmp, @3);
3591         delete[]$3;
3592         $$ = tmp;
3593       }
3594   | SYSTEM_IDENTIFIER '('  ')'
3595       { perm_string tn = lex_strings.make($1);
3596         const vector<PExpr*>empty;
3597         PECallFunction*tmp = new PECallFunction(tn, empty);
3598         FILE_NAME(tmp, @1);
3599         delete[]$1;
3600         $$ = tmp;
3601         if (!gn_system_verilog()) {
3602               yyerror(@1, "error: Empty function argument list requires SystemVerilog.");
3603         }
3604       }
3605
3606   | implicit_class_handle
3607       { PEIdent*tmp = new PEIdent(*$1);
3608         FILE_NAME(tmp,@1);
3609         delete $1;
3610         $$ = tmp;
3611       }
3612
3613   | implicit_class_handle '.' hierarchy_identifier
3614       { pform_name_t*t_name = $1;
3615         while (! $3->empty()) {
3616               t_name->push_back($3->front());
3617               $3->pop_front();
3618         }
3619         PEIdent*tmp = new PEIdent(*t_name);
3620         FILE_NAME(tmp,@1);
3621         delete $1;
3622         delete $3;
3623         $$ = tmp;
3624       }
3625
3626   /* Many of the VAMS built-in functions are available as builtin
3627      functions with $system_function equivalents. */
3628
3629   | K_acos '(' expression ')'
3630       { perm_string tn = perm_string::literal("$acos");
3631         PECallFunction*tmp = make_call_function(tn, $3);
3632         FILE_NAME(tmp,@1);
3633         $$ = tmp;
3634       }
3635
3636   | K_acosh '(' expression ')'
3637       { perm_string tn = perm_string::literal("$acosh");
3638         PECallFunction*tmp = make_call_function(tn, $3);
3639         FILE_NAME(tmp,@1);
3640         $$ = tmp;
3641       }
3642
3643   | K_asin '(' expression ')'
3644       { perm_string tn = perm_string::literal("$asin");
3645         PECallFunction*tmp = make_call_function(tn, $3);
3646         FILE_NAME(tmp,@1);
3647         $$ = tmp;
3648       }
3649
3650   | K_asinh '(' expression ')'
3651       { perm_string tn = perm_string::literal("$asinh");
3652         PECallFunction*tmp = make_call_function(tn, $3);
3653         FILE_NAME(tmp,@1);
3654         $$ = tmp;
3655       }
3656
3657   | K_atan '(' expression ')'
3658       { perm_string tn = perm_string::literal("$atan");
3659         PECallFunction*tmp = make_call_function(tn, $3);
3660         FILE_NAME(tmp,@1);
3661         $$ = tmp;
3662       }
3663
3664   | K_atanh '(' expression ')'
3665       { perm_string tn = perm_string::literal("$atanh");
3666         PECallFunction*tmp = make_call_function(tn, $3);
3667         FILE_NAME(tmp,@1);
3668         $$ = tmp;
3669       }
3670
3671   | K_atan2 '(' expression ',' expression ')'
3672       { perm_string tn = perm_string::literal("$atan2");
3673         PECallFunction*tmp = make_call_function(tn, $3, $5);
3674         FILE_NAME(tmp,@1);
3675         $$ = tmp;
3676       }
3677
3678   | K_ceil '(' expression ')'
3679       { perm_string tn = perm_string::literal("$ceil");
3680         PECallFunction*tmp = make_call_function(tn, $3);
3681         FILE_NAME(tmp,@1);
3682         $$ = tmp;
3683       }
3684
3685   | K_cos '(' expression ')'
3686       { perm_string tn = perm_string::literal("$cos");
3687         PECallFunction*tmp = make_call_function(tn, $3);
3688         FILE_NAME(tmp,@1);
3689         $$ = tmp;
3690       }
3691
3692   | K_cosh '(' expression ')'
3693       { perm_string tn = perm_string::literal("$cosh");
3694         PECallFunction*tmp = make_call_function(tn, $3);
3695         FILE_NAME(tmp,@1);
3696         $$ = tmp;
3697       }
3698
3699   | K_exp '(' expression ')'
3700       { perm_string tn = perm_string::literal("$exp");
3701         PECallFunction*tmp = make_call_function(tn, $3);
3702         FILE_NAME(tmp,@1);
3703         $$ = tmp;
3704       }
3705
3706   | K_floor '(' expression ')'
3707       { perm_string tn = perm_string::literal("$floor");
3708         PECallFunction*tmp = make_call_function(tn, $3);
3709         FILE_NAME(tmp,@1);
3710         $$ = tmp;
3711       }
3712
3713   | K_hypot '(' expression ',' expression ')'
3714       { perm_string tn = perm_string::literal("$hypot");
3715         PECallFunction*tmp = make_call_function(tn, $3, $5);
3716         FILE_NAME(tmp,@1);
3717         $$ = tmp;
3718       }
3719
3720   | K_ln '(' expression ')'
3721       { perm_string tn = perm_string::literal("$ln");
3722         PECallFunction*tmp = make_call_function(tn, $3);
3723         FILE_NAME(tmp,@1);
3724         $$ = tmp;
3725       }
3726
3727   | K_log '(' expression ')'
3728       { perm_string tn = perm_string::literal("$log10");
3729         PECallFunction*tmp = make_call_function(tn, $3);
3730         FILE_NAME(tmp,@1);
3731         $$ = tmp;
3732       }
3733
3734   | K_pow '(' expression ',' expression ')'
3735       { perm_string tn = perm_string::literal("$pow");
3736         PECallFunction*tmp = make_call_function(tn, $3, $5);
3737         FILE_NAME(tmp,@1);
3738         $$ = tmp;
3739       }
3740
3741   | K_sin '(' expression ')'
3742       { perm_string tn = perm_string::literal("$sin");
3743         PECallFunction*tmp = make_call_function(tn, $3);
3744         FILE_NAME(tmp,@1);
3745         $$ = tmp;
3746       }
3747
3748   | K_sinh '(' expression ')'
3749       { perm_string tn = perm_string::literal("$sinh");
3750         PECallFunction*tmp = make_call_function(tn, $3);
3751         FILE_NAME(tmp,@1);
3752         $$ = tmp;
3753       }
3754
3755   | K_sqrt '(' expression ')'
3756       { perm_string tn = perm_string::literal("$sqrt");
3757         PECallFunction*tmp = make_call_function(tn, $3);
3758         FILE_NAME(tmp,@1);
3759         $$ = tmp;
3760       }
3761
3762   | K_tan '(' expression ')'
3763       { perm_string tn = perm_string::literal("$tan");
3764         PECallFunction*tmp = make_call_function(tn, $3);
3765         FILE_NAME(tmp,@1);
3766         $$ = tmp;
3767       }
3768
3769   | K_tanh '(' expression ')'
3770       { perm_string tn = perm_string::literal("$tanh");
3771         PECallFunction*tmp = make_call_function(tn, $3);
3772         FILE_NAME(tmp,@1);
3773         $$ = tmp;
3774       }
3775
3776   /* These mathematical functions are conveniently expressed as unary
3777      and binary expressions. They behave much like unary/binary
3778      operators, even though they are parsed as functions.  */
3779
3780   | K_abs '(' expression ')'
3781       { PEUnary*tmp = new PEUnary('m', $3);
3782         FILE_NAME(tmp,@1);
3783         $$ = tmp;
3784       }
3785
3786   | K_max '(' expression ',' expression ')'
3787       { PEBinary*tmp = new PEBinary('M', $3, $5);
3788         FILE_NAME(tmp,@1);
3789         $$ = tmp;
3790       }
3791
3792   | K_min '(' expression ',' expression ')'
3793       { PEBinary*tmp = new PEBinary('m', $3, $5);
3794         FILE_NAME(tmp,@1);
3795         $$ = tmp;
3796       }
3797
3798   /* Parenthesized expressions are primaries. */
3799
3800   | '(' expr_mintypmax ')'
3801       { $$ = $2; }
3802
3803   /* Various kinds of concatenation expressions. */
3804
3805   | '{' expression_list_proper '}'
3806       { PEConcat*tmp = new PEConcat(*$2);
3807         FILE_NAME(tmp, @1);
3808         delete $2;
3809         $$ = tmp;
3810       }
3811   | '{' expression '{' expression_list_proper '}' '}'
3812       { PExpr*rep = $2;
3813         PEConcat*tmp = new PEConcat(*$4, rep);
3814         FILE_NAME(tmp, @1);
3815         delete $4;
3816         $$ = tmp;
3817       }
3818   | '{' expression '{' expression_list_proper '}' error '}'
3819       { PExpr*rep = $2;
3820         PEConcat*tmp = new PEConcat(*$4, rep);
3821         FILE_NAME(tmp, @1);
3822         delete $4;
3823         $$ = tmp;
3824         yyerror(@5, "error: Syntax error between internal '}' "
3825                 "and closing '}' of repeat concatenation.");
3826         yyerrok;
3827       }
3828
3829   | '{' '}'
3830       { // This is the empty queue syntax.
3831         if (gn_system_verilog()) {
3832               list<PExpr*> empty_list;
3833               PEConcat*tmp = new PEConcat(empty_list);
3834               FILE_NAME(tmp, @1);
3835               $$ = tmp;
3836         } else {
3837               yyerror(@1, "error: Concatenations are not allowed to be empty.");
3838               $$ = 0;
3839         }
3840       }
3841
3842   /* Cast expressions are primaries */
3843
3844   | expr_primary "'" '(' expression ')'
3845       { PExpr*base = $4;
3846         if (gn_system_verilog()) {
3847               PECastSize*tmp = new PECastSize($1, base);
3848               FILE_NAME(tmp, @1);
3849               $$ = tmp;
3850         } else {
3851               yyerror(@1, "error: Size cast requires SystemVerilog.");
3852               $$ = base;
3853         }
3854       }
3855
3856   | simple_type_or_string "'" '(' expression ')'
3857       { PExpr*base = $4;
3858         if (gn_system_verilog()) {