source: vis_dev/vl2mv-2.3/src/parser/verilog.y @ 38

Last change on this file since 38 was 18, checked in by cecile, 13 years ago

vl2mv added

File size: 79.8 KB
Line 
1/*
2
3  Copyright (c) 1992, 1993
4        Regents of the University of California
5  All rights reserved.
6
7  Use and copying of this software and preparation of derivative works
8  based upon this software are permitted.  However, any distribution of
9  this software or derivative works must include the above copyright
10  notice.
11
12  This software is made available AS IS, and neither the Electronics
13  Research Laboratory or the Universify of California make any
14  warranty about the software, its performance or its conformity to
15  any specification.
16
17  Author: Szu-Tsung Cheng, stcheng@ic.Berkeley.EDU
18          10/92
19          10/93
20
21  $Header: /projects/development/hsv/CVSRepository/vl2mv/src/parser/verilog.y,v 1.7 2009/03/16 20:57:20 fabio Exp $
22
23
24*/
25
26
27%{
28
29#include <stdio.h>
30#include "util.h"
31#include "list.h"
32#include "st.h"
33#include "array.h"
34#include "set.h"
35#include "stack.h"
36#include "vl_defs.h"
37#include "vl_types.h"
38#include "vlr_int.h"
39#include "vl_create.h"
40#include "vl_write.h"
41#include "vl_create.h"
42#include "verilog.h"
43
44
45
46
47
48#define NOND_SET "NDset"
49
50extern vl_descPtr mod_list;
51extern char yyid[];
52extern char brep[];
53extern int bexp0, bexp1;
54extern char last_macro[];
55extern st_table *macros;
56extern int compatibleChecking;
57extern char yytypetoken[];
58extern int instantiateAll;
59
60int YYTrace=0;
61
62char *vl_filename = "<stdin>";
63struct vl_desc *vl_description = NIL(struct vl_desc);
64struct vl_module *vl_currentModule=NIL(vl_module);
65struct vl_primitive *vl_currentPrimitive=NIL(vl_primitive);
66struct vl_function *vl_currentFunction=NIL(vl_function);
67lsList vl_module_stack;
68lsList vl_cur_type_stack;
69st_table *aux_st=NIL(st_table);
70char modName[MAXSTRLEN];
71char *cp;
72short eventType;
73int enum_val=0;
74int reserve_type_name=1;
75int task_mode=0;
76int timed_statement = 0;
77static int c_assign=0;
78
79EXTERN int yylex ARGS(());
80
81%}
82
83
84%union {
85    int             ival;
86    char            *charp;
87    typestructPtr   type;
88    lsList          lstp;
89    vl_bassign_stmtPtr      basgn;
90    vl_begin_end_stmtPtr    seqstmt;
91    vl_case_itemPtr caseitem;
92    vl_cont_assignPtr       casgn;
93    vl_declPtr      bascdcl;
94    vl_delayPtr     dlay;
95    vl_descPtr      desc;
96    vl_event_exprPtr        evnt;
97    vl_exprPtr      expr;
98    vl_fork_join_stmtPtr    parstmt;
99    vl_functionPtr  func;
100    vl_gate_instPtr gtinst;
101    vl_gate_inst_listPtr    gtlist;
102    vl_id_rangePtr  idrng;
103    vl_lvalPtr      lval;
104    vl_mod_prim_inst_listPtr modlist;
105    vl_modulePtr    modu;
106    vl_netdeclPtr   netdcl;
107    vl_paramdeclPtr paradcl;
108    vl_portPtr      port;
109    vl_port_connectPtr      connect;
110    vl_prim_entryPtr        ntry;
111    vl_primitivePtr prim;
112    vl_procstmtPtr  prcstmt;
113    vl_rangePtr     rang;
114    vl_range_or_typePtr     rngtyp;
115    vl_rangedeclPtr rangdcl;
116    vl_taskPtr      task;
117    vl_task_enable_stmtPtr  taskenablestmt;
118    vl_typePtr      typedcl;
119    vl_type_specifierPtr typespc;
120    vl_enumeratorPtr        enumtr;
121    vl_enum_typePtr         enumtp;
122    multi_concatPtr         mconcat;
123}
124
125
126%start source_text
127
128
129%token YYIDE
130%token YYINUMBER
131%token YYRNUMBER
132%token YYSTRING
133%token YYALLPATH
134%token YYALWAYS
135%token YYAND
136%token YYASSIGN
137%token YYBEGIN
138%token YYBUF
139%token YYBUFIF0
140%token YYBUFIF1
141%token YYCASE
142%token YYCASEX
143%token YYCASEZ
144%token YYCMOS
145%token YYCONDITIONAL
146%token YYDEASSIGN
147%token YYDEFAULT
148%token YYDEFPARAM
149%token YYDISABLE
150%token YYELSE
151%token YYEDGE
152%token YYEND
153%token YYENDCASE
154%token YYENDMODULE
155%token YYENDFUNCTION
156%token YYENDPRIMITIVE
157%token YYENDSPECIFY
158%token YYENDTABLE
159%token YYENDTASK
160%token YYENUM
161%token YYEVENT
162%token YYFOR
163%token YYFOREVER
164%token YYFORK
165%token YYFUNCTION
166%token YYGEQ
167%token YYHIGHZ0
168%token YYHIGHZ1
169%token YYIF
170%token YYINITIAL
171%token YYINOUT
172%token YYINPUT
173%token YYINTEGER
174%token YYJOIN
175%token YYLARGE
176%token YYLEADTO
177%token YYLEQ
178%token YYLOGAND
179%token YYCASEEQUALITY
180%token YYCASEINEQUALITY
181%token YYLOGNAND
182%token YYLOGNOR
183%token YYLOGOR
184%token YYLOGXNOR
185%token YYLOGEQUALITY
186%token YYLOGINEQUALITY
187%token YYLSHIFT
188%token YYMACROMODULE
189%token YYMEDIUM
190%token YYMODULE
191%token YYMREG
192%token YYNAND
193%token YYNBASSIGN
194%token YYNEGEDGE
195%token YYNMOS
196%token YYNOR
197%token YYNOT
198%token YYNOTIF0
199%token YYNOTIF1
200%token YYOR
201%token YYOUTPUT
202%token YYPARAMETER
203%token YYPMOS
204%token YYPOSEDGE
205%token YYPRIMITIVE
206%token YYPULL0
207%token YYPULL1
208%token YYPULLUP
209%token YYPULLDOWN
210%token YYRCMOS
211%token YYREAL
212%token YYREG
213%token YYREPEAT
214%token YYRIGHTARROW
215%token YYRNMOS
216%token YYRPMOS
217%token YYRSHIFT
218%token YYRTRAN
219%token YYRTRANIF0
220%token YYRTRANIF1
221%token YYSCALARED
222%token YYSMALL
223%token YYSPECIFY
224%token YYSPECPARAM
225%token YYSTRONG0
226%token YYSTRONG1
227%token YYSUPPLY0
228%token YYSUPPLY1
229%token YYSWIRE
230%token YYTABLE
231%token YYTASK
232%token YYTESLATIMER
233%token YYTIME
234%token YYTRAN
235%token YYTRANIF0
236%token YYTRANIF1
237%token YYTRI
238%token YYTRI0
239%token YYTRI1
240%token YYTRIAND
241%token YYTRIOR
242%token YYTRIREG
243%token YYuTYPE
244%token YYTYPEDEF
245%token YYVECTORED
246%token YYWAIT
247%token YYWAND
248%token YYWEAK0
249%token YYWEAK1
250%token YYWHILE
251%token YYWIRE
252%token YYWOR
253%token YYXNOR
254%token YYXOR
255%token YYsysSETUP
256%token YYsysID
257%token YYsysND
258
259%right YYCONDITIONAL
260%right '?' ':'
261%left YYOR
262%left YYLOGOR
263%left YYLOGAND
264%left '|'
265%left '^' YYLOGXNOR
266%left '&'
267%left YYLOGEQUALITY YYLOGINEQUALITY YYCASEEQUALITY YYCASEINEQUALITY
268%left '<' YYLEQ '>' YYGEQ YYNBASSIGN
269%left YYLSHIFT YYRSHIFT
270%left '+' '-'
271%left '*' '/' '%'
272%right '~' '!' YYUNARYOPERATOR
273
274%type <desc> source_text
275%type <desc> description
276%type <modu> module
277%type <prim> primitive
278%type <lstp> port_list_opt port_list
279%type <port> port
280%type <lstp> port_expression_opt port_expression
281%type <lstp> port_ref_list
282%type <idrng> port_reference
283%type <rang> port_reference_arg
284%type <type> module_item
285%type <lstp> module_item_clr
286%type <paradcl> parameter_declaration
287%type <rangdcl> input_declaration output_declaration inout_declaration
288%type <rangdcl> reg_declaration
289%type <netdcl>  net_declaration
290%type <bascdcl> time_declaration event_declaration
291%type <bascdcl> integer_declaration real_declaration
292%type <gtlist>  gate_instantiation
293%type <type> module_or_primitive_instantiation
294%type <paradcl> parameter_override
295%type <casgn>   continuous_assign
296%type <prcstmt> initial_statement always_statement
297%type <task> task
298%type <func> function
299%type <lstp> variable_list primitive_declaration_eclr
300%type <lstp> table_definition
301%type <lstp> table_entries combinational_entry_eclr sequential_entry_eclr
302%type <ntry> combinational_entry sequential_entry
303%type <lstp> input_list level_symbol_or_edge_eclr
304%type <ival> output_symbol state next_state
305%type <ival> level_symbol edge level_symbol_or_edge edge_symbol
306%type <type> primitive_declaration
307%type <lstp> tf_declaration_clr tf_declaration_eclr
308%type <lstp> statement_opt
309%type <rngtyp>  range_or_type_opt range_or_type
310%type <rang> range
311%type <type> tf_declaration
312%type <lstp> assignment_list
313%type <rang> range_opt
314%type <expr> expression
315%type <ival> drive_strength_opt drive_strength
316%type <ival> charge_strength_opt charge_strength
317%type <ival> nettype
318%type <rang> expandrange_opt expandrange
319%type <dlay> delay_opt delay
320%type <lstp> register_variable_list
321%type <lstp> name_of_event_list
322%type <idrng>  identifier
323%type <idrng>  register_variable
324%type <charp>  name_of_register
325%type <idrng>  name_of_event
326%type <ival> strength0 strength1
327%type <basgn>  assignment
328%type <lstp> drive_delay_clr gate_instance_list
329%type <ival> gatetype drive_delay
330%type <gtinst> gate_instance
331%type <lstp> terminal_list
332%type <idrng>  name_of_gate_instance name_of_module_or_primitive
333%type <expr> terminal
334%type <lstp> module_or_primitive_option_clr
335%type <ival> module_or_primitive_option
336%type <lstp> module_or_primitive_instance_list
337%type <dlay> delay_or_parameter_value_assignment
338%type <type> module_or_primitive_instance
339%type <lstp> module_connection_list module_port_connection_list
340%type <lstp> named_port_connection_list
341%type <connect> module_port_connection named_port_connection
342%type <type> statement
343%type <lstp> statement_clr case_item_eclr
344%type <caseitem> case_item
345%type <dlay> delay_control
346%type <evnt> event_control
347%type <lval> lvalue
348%type <lstp> expression_list
349%type <seqstmt>  seq_block
350%type <parstmt>  par_block
351%type <idrng> name_of_block
352%type <lstp> block_declaration_clr
353%type <type> block_declaration
354%type <taskenablestmt>  task_enable
355%type <lstp> concatenation
356%type <lstp> mintypmax_expression_list
357%type <expr> mintypmax_expression
358%type <expr> primary
359%type <expr> function_call
360%type <evnt> event_expression ored_event_expression
361%type <typedcl> type_declaration type_decorator_opt
362%type <charp> type_name enum_name
363%type <typespc> type_specifier
364%type <lstp> enum_lst_opt enumerator_list
365%type <enumtp> enum_specifier
366%type <enumtr> enumerator
367%type <lstp> nondeterminism_list
368%type <mconcat> multiple_concatenation
369
370/* The rules for if-then-else statements produce one harmless
371 * shift-reduce conflict. */
372%expect 1
373
374%%
375
376
377
378source_text
379        :
380          {
381              YYTRACE("source_text:");
382              if (vl_description == NIL(struct vl_desc)) {
383                  $$ = vl_description = mod_list = vl_create_desc("stdin");
384              }
385          }
386        | source_text description
387          {
388              YYTRACE("source_text: source_text description");
389          }
390        ;
391
392description
393        : module
394          {
395              YYTRACE("description: module");
396          }
397        | primitive
398          {
399              YYTRACE("description: primitive");
400          }
401        | type_declaration
402          {
403              YYTRACE("module_item: type_declaration");
404          }
405        ;
406
407type_declaration
408        : YYTYPEDEF type_specifier type_name ';'
409          {
410              YYTRACE("type_declaration: YYTYPEDEF typesepcifier type_name ';'");
411              vl_create_typedecl($3, $2);
412              if (compatibleChecking)
413                  yyerror("type mechanism is not allowed");
414          }
415        ;
416
417module
418        : YYMODULE YYIDE
419          {
420              vl_id_rangePtr idptr;
421
422
423              if (!empty_file_stack() && !instantiateAll && mod_list)
424                  st_insert(mod_list->mod_holes,vlStrdup(yyid),0);
425
426              idptr = vl_create_id_range(vlStrdup(yyid), NIL(vl_range));
427              vl_currentModule = vl_create_module(idptr, LS_NIL, LS_NIL);
428              (void)push_stack(vl_module_stack, (void*)vl_currentModule);
429              set_eliminate(idptr->name, mod_list->mp_undefined);
430          }
431          port_list_opt ';'
432          {
433              vl_currentModule->ports = $4;
434          }
435          module_item_clr
436          YYENDMODULE
437          {
438              YYTRACE("module: YYMODULE YYIDE port_list_opt ';' module_item_clr YYENDMODULE");
439              vl_currentModule->mod_items = $7;
440              $$ = vl_currentModule;
441              (void**)pop_stack(vl_module_stack, (void**)&vl_currentModule);
442              vl_currentModule = (vl_module*)(void*)top_stack(vl_module_stack);
443              assert(vl_currentModule == NIL(vl_module));
444          }
445        | YYMACROMODULE YYIDE port_list_opt ';'
446                module_item_clr
447          YYENDMODULE
448          {
449              YYTRACE("module: YYMACROMODULE YYIDE port_list_opt ';' module_item_clr YYENDMODULE");
450              TODO("module: YYMACROMODULE YYIDE port_list_opt ';' module_item_clr YYENDMODULE");
451          }
452        ;
453
454port_list_opt
455        :
456          {
457              YYTRACE("port_list_opt:");
458              $$ = LS_NIL;
459          }
460        | '(' port_list ')'
461          {
462              YYTRACE("port_list_opt: '(' port_list ')'");
463              $$ = $2;
464          }
465        ;
466
467port_list
468        : port
469          {
470              lsHandle handle;
471
472              YYTRACE("port_list: port");
473              $$ = lsCreate();
474              lsNewEnd($$, (lsGeneric)$1, &handle);
475          }
476        | port_list ',' port
477          {
478              lsHandle handle;
479
480              YYTRACE("port_list: port_list ',' port");
481              lsNewEnd($1, (lsGeneric)$3, &handle);
482              $$ = $1;
483          }
484        ;
485
486port
487        : port_expression_opt
488          {
489              YYTRACE("port: port_expression_opt");
490              $$ = vl_create_port(ModulePort, NIL(vl_id_range), $1);
491          }
492        | '.' YYIDE
493          {
494              $<idrng>$ = vl_create_id_range(vlStrdup(yyid), NIL(vl_range));
495          }
496          '(' port_expression_opt ')'
497          {
498              YYTRACE("port: ',' YYIDE '(' port_expression_opt ')'");
499              $$ = vl_create_port(NamedPort, $<idrng>3, $5);
500          }
501        ;
502
503port_expression_opt
504        :
505           {
506               YYTRACE("port_expression_opt:");
507               $$ = LS_NIL;
508           }
509        |  port_expression
510           {
511               YYTRACE("port_expression_opt: port_expression");
512           }
513        ;
514
515port_expression
516        : port_reference
517          {
518              lsHandle handle;
519
520              YYTRACE("port_expression: port_reference");
521              $$ = lsCreate();
522              lsNewEnd($$, (lsGeneric)$1, &handle);
523          }
524        | '{' port_ref_list '}'
525          {
526              YYTRACE("port_expression: '{' port_ref_list '}'");
527              $$ = $2;
528          }
529        ;
530
531port_ref_list
532        : port_reference
533          {
534              lsHandle handle;
535
536              YYTRACE("port_ref_list: port_reference");
537              $$ = lsCreate();
538              lsNewEnd($$, (lsGeneric)$1, &handle);
539          }
540        | port_ref_list ',' port_reference
541          {
542              lsHandle handle;
543
544              YYTRACE("port_ref_list: port_ref_list ',' port_reference");
545              lsNewEnd($1, (lsGeneric)$3, &handle);
546              $$ = $1;
547          }
548        ;
549
550port_reference
551        : YYIDE
552          {
553              $<idrng>$ = vl_create_id_range(vlStrdup(yyid), NIL(vl_range));
554          }
555          port_reference_arg
556          {
557              YYTRACE("port_reference: YYIDE port_reference_arg");
558              $$ = vl_create_id_range($<idrng>2->name, $3);
559          }
560        ;
561
562port_reference_arg
563        :
564          {
565              YYTRACE("port_reference_arg:");
566              $$ = vl_create_range(NIL(vl_expr), NIL(vl_expr));
567          }
568        | '[' expression ']'
569          {
570              YYTRACE("port_reference_arg: '[' expression ']'");
571              $$ = vl_create_range($2, NIL(vl_expr));
572          }
573        | '[' expression ':' expression ']'
574          {
575              YYTRACE("port_reference_arg: '[' expression ':' expression ']'");
576              $$ = vl_create_range($2, $4);
577          }
578        ;
579
580module_item_clr
581        :
582          {
583              YYTRACE("module_item_clr:");
584              $$ = lsCreate();
585          }
586        | module_item_clr module_item
587          {
588              lsHandle handle;
589              int decomposed_assign = 0;
590              lsHandle assignHandle;
591              lsGen assignGen;
592              vl_cont_assign *cont_assign, *new_cont_assign;
593              lsList new_assigns;
594              vl_bassign_stmt *assign;
595
596              YYTRACE("module_item_clr: module_item_clr module_item");
597              if (((vl_decl*)$2)->type == ContAssign)
598                  if (lsLength(((vl_cont_assign*)$2)->assigns) > 1) {
599                      decomposed_assign = 1;
600                      cont_assign = (vl_cont_assign*)$2;
601                      for (assignGen=lsStart(((vl_cont_assign*)$2)->assigns);
602                           lsNext(assignGen,(lsGeneric*)&assign,&assignHandle)
603                               != LS_NOMORE; ) {
604                          new_assigns = lsCreate();
605                          lsNewEnd(new_assigns, (lsGeneric)assign, 0);
606                          new_cont_assign =
607                              vl_create_cont_assign_stmt(cont_assign->strength,
608                                                         cont_assign->delay,
609                                                         new_assigns);
610                          lsNewEnd($1, (lsGeneric)new_cont_assign, 0);
611                      }
612                      lsFinish(assignGen);
613                      lsDestroy(cont_assign->assigns, 0);
614                      vl_chk_free((char*)$2);
615                  }
616              if (!decomposed_assign)
617                  lsNewEnd($1, (lsGeneric)$2, &handle);
618              $$ = $1;
619          }
620        ;
621
622module_item
623        : parameter_declaration
624          {
625              YYTRACE("module_item: parameter_declaration");
626              $$ = (typestructPtr)$1;
627          }
628        | input_declaration
629          {
630              YYTRACE("module_item: input_declaration");
631              $$ = (typestructPtr)$1;
632          }
633        | output_declaration
634          {
635              YYTRACE("module_item: output_declaration");
636              $$ = (typestructPtr)$1;
637          }
638        | inout_declaration
639          {
640              YYTRACE("module_item: inout_declaration");
641              $$ = (typestructPtr)$1;
642          }
643        | net_declaration
644          {
645              YYTRACE("module_item: net_declaration");
646              $$ = (typestructPtr)$1;
647          }
648        | reg_declaration
649          {
650              YYTRACE("module_item: reg_declaration");
651              $$ = (typestructPtr)$1;
652          }
653        | time_declaration
654          {
655              YYTRACE("module_item: time_declaration");
656              $$ = (typestructPtr)$1;
657          }
658        | integer_declaration
659          {
660              YYTRACE("module_item: integer_declaration");
661              $$ = (typestructPtr)$1;
662          }
663        | real_declaration
664          {
665              YYTRACE("module_item: real_declaration");
666              $$ = (typestructPtr)$1;
667          }
668        | event_declaration
669          {
670              YYTRACE("module_item: event_declaration");
671              $$ = (typestructPtr)$1;
672          }
673        | gate_instantiation
674          {
675              YYTRACE("module_item: gate_instantiation");
676              $$ = (typestructPtr)$1;
677          }
678        | module_or_primitive_instantiation
679          {
680              YYTRACE("module_item: module_or_primitive_instantiation");
681              $$ = (typestructPtr)$1;
682          }
683        | parameter_override
684          {
685              YYTRACE("module_item: parameter_override");
686              $$ = (typestructPtr)$1;
687          }
688        | continuous_assign
689          {
690              YYTRACE("module_item: continous_assign");
691              $$ = (typestructPtr)$1;
692          }
693        | specify_block
694          {
695              YYTRACE("module_item: specify_block");
696              $$ = $<type>1;
697          }
698        | initial_statement
699          {
700              YYTRACE("module_item: initial_statement");
701              $$ = (typestructPtr)$1;
702          }
703        | always_statement
704          {
705              YYTRACE("module_item: always_statement");
706              $$ = (typestructPtr)$1;
707          }
708        | task
709          {
710              YYTRACE("module_item: task");
711              $$ = (typestructPtr)$1;
712          }
713        | function
714          {
715              YYTRACE("module_item: function");
716              $$ = (typestructPtr)$1;
717          }
718        ;
719
720primitive
721        : YYPRIMITIVE YYIDE
722          {
723              vl_id_rangePtr idptr;
724
725              idptr = vl_create_id_range(vlStrdup(yyid), NIL(vl_range));
726              vl_currentPrimitive = vl_create_primitive(idptr,
727                                                        LS_NIL,
728                                                        LS_NIL,
729                                                        LS_NIL);
730              set_eliminate(idptr->name, mod_list->mp_undefined);
731          }
732          '(' port_list ')' ';'
733                primitive_declaration_eclr
734                table_definition
735          YYENDPRIMITIVE
736          {
737              YYTRACE("primitive: YYPRMITIVE YYIDE '(' variable_list ')' ';' primitive_declaration_eclr table_definition YYENDPRIMITIVE");
738              vl_currentPrimitive->ports = $5;
739              vl_currentPrimitive->decls = $8;
740              vl_currentPrimitive->entries = $9;
741              $$ = vl_currentPrimitive;
742              vl_currentPrimitive = NIL(vl_primitive);
743          }
744        ;
745
746primitive_declaration_eclr
747        : primitive_declaration
748          {
749              lsHandle handle;
750
751              YYTRACE("primitive_declaration_eclr: primitive_declaration");
752              $$ = lsCreate();
753              lsNewEnd($$, (lsGeneric)$1, &handle);
754          }
755        | primitive_declaration_eclr primitive_declaration
756          {
757              lsHandle handle;
758
759              YYTRACE("primitive_declaration_eclr: primitive_declaration_eclr primitive_declaration");
760              lsNewEnd($1, (lsGeneric)$2, &handle);
761              $$ = $1;
762          }
763        ;
764
765primitive_declaration
766        : output_declaration
767          {
768              YYTRACE("primitive_declaration: output_declaration");
769              $$ = (typestructPtr)$1;
770          }
771        | reg_declaration
772          {
773              YYTRACE("primitive_decalration: reg_declaration");
774              $$ = (typestructPtr)$1;
775          }
776        | input_declaration
777          {
778              YYTRACE("primitive_decalration: input_declaration");
779              $$ = (typestructPtr)$1;
780          }
781        ;
782
783table_definition
784        : YYTABLE table_entries YYENDTABLE
785          {
786              YYTRACE("table_definition: YYTABLE table_entries YYENDTABLE");
787              $$ = $2;
788          }
789        ;
790
791table_entries
792        : combinational_entry_eclr
793          {
794              YYTRACE("table_definition: combinational_entry_eclr");
795              vl_currentPrimitive->type = CombPrimDecl;
796          }
797        | sequential_entry_eclr
798          {
799              YYTRACE("table_definition: sequential_entry_eclr");
800              vl_currentPrimitive->type = SeqPrimDecl;
801          }
802        ;
803
804combinational_entry_eclr
805        : combinational_entry
806          {
807              YYTRACE("combinational_entry_eclr: combinational_entry");
808              $$ = lsCreate();
809              lsNewEnd($$, (lsGeneric)$1, LS_NH);
810          }
811        | combinational_entry_eclr combinational_entry
812          {
813              YYTRACE("combinational_entry_eclr: combinational_entry_eclr combinational_entry");
814              lsNewEnd($1, (lsGeneric)$2, LS_NH);
815              $$ = $1;
816          }
817        ;
818
819combinational_entry
820        : input_list ':' output_symbol ';'
821          {
822              YYTRACE("combinational_entry: input_list ':' output_symbol ';'");
823              $$ = vl_create_prim_entry($1, PrimNone, $3);
824          }
825        ;
826
827sequential_entry_eclr
828        : sequential_entry
829          {
830              YYTRACE("sequential_entry_eclr: sequential_entry");
831              $$ = lsCreate();
832              lsNewEnd($$, (lsGeneric)$1, LS_NH);
833          }
834        | sequential_entry_eclr sequential_entry
835          {
836              YYTRACE("sequential_entry_eclr: sequential_entry_eclr sequential_entry");
837              lsNewEnd($1, (lsGeneric)$2, LS_NH);
838              $$ = $1;
839          }
840        ;
841
842sequential_entry
843        : input_list ':' state ':' next_state ';'
844          {
845              YYTRACE("sequential_entry: input_list ':' state ':' next_state ';'");
846              $$ = vl_create_prim_entry($1, $3, $5);
847          }
848        ;
849
850input_list
851        : level_symbol_or_edge_eclr
852          {
853              YYTRACE("input_list: level_symbol_or_edge_eclr");
854          }
855        ;
856
857level_symbol_or_edge_eclr
858        : level_symbol_or_edge
859          {
860              YYTRACE("level_symbol_or_edge_eclr: level_symbol_or_edge");
861              $$ = lsCreate();
862              lsNewEnd($$, (lsGeneric)$1, LS_NH);
863          }
864        | level_symbol_or_edge_eclr level_symbol_or_edge
865          {
866              YYTRACE("level_symbol_or_edge_eclr: level_symbol_or_edge_eclr level_symbol_or_edge");
867              lsNewEnd($1, (lsGeneric)$2, LS_NH);
868              $$ = $1;
869          }
870        ;
871
872level_symbol_or_edge
873        : level_symbol
874          {
875              YYTRACE("level_symbol_or_edge: level_symbol");
876          }
877        | edge
878          {
879              YYTRACE("level_symbol_or_edge: edge");
880          }
881        ;
882
883edge
884        : '(' level_symbol level_symbol ')'
885          {
886              YYTRACE("edge: '(' level_symbol level_symbol ')'");
887              switch ($2) {
888              case Prim0: $$ = ($3==PrimX) ? Prim0X : PrimR; break;
889              case Prim1: $$ = ($3==PrimX) ? Prim1X : PrimF; break;
890              case PrimX:
891                  $$ = ($3==Prim1) ? PrimX1 : ($3==Prim0) ? PrimX0 : PrimXB;
892                  break;
893              case PrimB: $$ = ($3==PrimX) ? PrimBX : PrimBB; break;
894              case PrimQ:
895                  $$ = ($3==Prim1) ? PrimQ1 : ($3==Prim0) ? PrimQ0 : PrimQB;
896                  break;
897              default: {
898                  char mesg[MAXSTRLEN];
899
900                  sprintf(mesg, "Unknown edge symbol (%d,%d)", $2, $3);
901                  compile_error(mesg);
902              }
903              }
904          }
905        | edge_symbol
906          {
907              YYTRACE("edge: edge_symbol");
908          }
909        ;
910
911state
912        : level_symbol
913          {
914              YYTRACE("state: level_symbol");
915          }
916        ;
917
918next_state
919        : output_symbol
920          {
921              YYTRACE("next_state: output_symbol");
922          }
923        | '-'
924          {
925              YYTRACE("next_state: '_'");
926              $$ = PrimM;
927          }
928        ;
929
930output_symbol
931        : '0'
932          {
933              YYTRACE("output_symbol: '0'");
934              $$ = Prim0;
935          }
936        | '1'
937          {
938              YYTRACE("output_symbol: '1'");
939              $$ = Prim1;
940          }
941        | 'x'
942          {
943              YYTRACE("output_symbol: 'x'");
944              $$ = PrimX;
945          }
946        | 'X'
947          {
948              YYTRACE("output_symbol: 'X'");
949              $$ = PrimX;
950          }
951        ;
952
953level_symbol
954        : '0'
955          {
956              YYTRACE("level_symbol: '0'");
957              $$ = Prim0;
958          }
959        | '1'
960          {
961              YYTRACE("level_symbol: '1'");
962              $$ = Prim1;
963          }
964        | 'x'
965          {
966              YYTRACE("level_symbol: 'x'");
967              $$ = PrimX;
968          }
969        | 'X'
970          {
971              YYTRACE("level_symbol: 'X'");
972              $$ = PrimX;
973          }
974        | '?'
975          {
976              YYTRACE("level_symbol: '?'");
977              $$ = PrimQ;
978          }
979        | 'b'
980          {
981              YYTRACE("level_symbol: 'b'");
982              $$ = PrimB;
983          }
984        | 'B'
985          {
986              YYTRACE("level_symbol: 'B'");
987              $$ = PrimB;
988          }
989        ;
990
991edge_symbol
992        : 'r'
993          {
994              YYTRACE("edge_symbol: 'r'");
995              $$ = PrimR;
996          }
997        | 'R'
998          {
999              YYTRACE("edge_symbol: 'R'");
1000              $$ = PrimR;
1001          }
1002        | 'f'
1003          {
1004              YYTRACE("edge_symbol: 'f'");
1005              $$ = PrimF;
1006          }
1007        | 'F'
1008          {
1009              YYTRACE("edge_symbol: 'F'");
1010              $$ = PrimF;
1011          }
1012        | 'p'
1013          {
1014              YYTRACE("edge_symbol: 'p'");
1015              $$ = PrimP;
1016          }
1017        | 'P'
1018          {
1019              YYTRACE("edge_symbol: 'P'");
1020              $$ = PrimP;
1021          }
1022        | 'n'
1023          {
1024              YYTRACE("edge_symbol: 'n'");
1025              $$ = PrimN;
1026          }
1027        | 'N'
1028          {
1029              YYTRACE("edge_symbol: 'N'");
1030              $$ = PrimN;
1031          }
1032        | '*'
1033          {
1034              YYTRACE("edge_symbol: '*'");
1035              $$ = PrimS;
1036          }
1037        ;
1038
1039task
1040        : YYTASK YYIDE
1041          {
1042              $<idrng>$ = vl_create_id_range(vlStrdup(yyid), NIL(vl_range));
1043              task_mode = 1;
1044          }
1045          ';' tf_declaration_clr statement_opt
1046          YYENDTASK
1047          {
1048              YYTRACE("YYTASK YYIDE ';' tf_declaration_clr statement_opt YYENDTASK");
1049              $$ = vl_create_task($<idrng>3, $5, $6);
1050              task_mode = 0;
1051          }
1052        ;
1053
1054function
1055        : YYFUNCTION range_or_type_opt YYIDE
1056          {
1057              int bad_type=0;
1058
1059              $<idrng>$ = vl_create_id_range(vlStrdup(yyid), NIL(vl_range));
1060
1061              if (!$2) {
1062
1063                  vl_expr *zero;
1064                  zero = vl_create_expr(IntExpr, 0, (double)0.0,
1065                                        NIL(void), NIL(void), NIL(void));
1066                  $2 = vl_create_range_or_type(Range_Dcl,
1067                                               vl_create_range(zero,zero));
1068              } else if (!$2->range) {
1069                  bad_type = 1;
1070              }
1071
1072              if (bad_type) {
1073                  char buf[MAXSTRLEN];
1074                  sprintf(buf, "bit width of function '%s' is not known",yyid);
1075                  compile_error(buf);
1076              }
1077
1078              vl_currentFunction = vl_create_function(0, $2->range, $<idrng>$,
1079                                                      lsCreate(), lsCreate());
1080              vl_currentModule = (vl_module*)vl_currentFunction;
1081              push_stack(vl_module_stack, vl_currentModule);
1082          }
1083          ';' tf_declaration_eclr statement_opt
1084          YYENDFUNCTION
1085          {
1086              vl_id_range *func_out;
1087              short func_type=0;
1088              lsList out_ids;
1089
1090              YYTRACE("YYFUNCTION range_or_type_opt YYIDE ';' tf_declaration_eclr statement_opt YYENDFUNCTION");
1091              if ($2 == NIL(vl_range_or_type)) {
1092                  func_type = IntFuncDecl;
1093              } else {
1094                  switch ($2->type) {
1095                  case Range_Dcl: func_type = RangeFuncDecl; break;
1096                  case Integer_Dcl: func_type = IntFuncDecl; break;
1097                  case Real_Dcl: func_type = RealFuncDecl; break;
1098                  default: internal_error("unknown function type");
1099                  }
1100              }
1101
1102              func_out = vl_create_id_range($<idrng>4->name, NIL(vl_range));
1103              func_out->flags |= OutPort;
1104              out_ids = lsCreate();
1105              lsNewEnd(out_ids, (lsGeneric)func_out, 0);
1106              if ($2->type == Range_Dcl)
1107                  lsNewEnd($6, (lsGeneric)vl_create_rangedecl(NIL(vl_type),
1108                                                              RegDecl,
1109                                                              $2->range,
1110                                                              out_ids, 0),
1111                           0);
1112              else
1113                  lsNewEnd($6, (lsGeneric)vl_create_rangedecl(NIL(vl_type),
1114                                                              RegDecl,
1115                                                              NIL(vl_range),
1116                                                              out_ids, 0),
1117                           0);
1118
1119              ((vl_function*)vl_currentModule)->type = func_type;
1120              ((vl_function*)vl_currentModule)->decls = $6;
1121              ((vl_function*)vl_currentModule)->stmts = $7;
1122              $$ = (vl_function*)vl_currentModule;
1123              (void*)pop_stack(vl_module_stack, (void**)&vl_currentModule);
1124              vl_currentModule = (vl_module*)(void*)top_stack(vl_module_stack);
1125              lsNewBegin($$->ports, (lsGeneric)func_out, 0);
1126              vl_currentFunction = NIL(vl_function);
1127              assert(vl_currentModule != NIL(vl_module));
1128          }
1129        ;
1130
1131range_or_type_opt
1132        :
1133          {
1134              YYTRACE("range_or_type_opt:");
1135              $$ = NIL(vl_range_or_type);
1136          }
1137        | range_or_type
1138          {
1139              YYTRACE("range_or_type_opt: range_or_type");
1140              $$ = $1;
1141          }
1142        ;
1143
1144range_or_type
1145        : range
1146          {
1147              YYTRACE("range_or_type: range");
1148              $$ = vl_create_range_or_type(Range_Dcl, $1);
1149          }
1150        | YYINTEGER
1151          {
1152              YYTRACE("range_or_type: YYINTEGER");
1153              $$ = vl_create_range_or_type(Integer_Dcl, NIL(vl_range));
1154          }
1155        | YYREAL
1156          {
1157              YYTRACE("range_or_type: YYREAL");
1158              $$ = vl_create_range_or_type(Real_Dcl, NIL(vl_range));
1159          }
1160        ;
1161
1162tf_declaration_clr
1163        :
1164          {
1165              YYTRACE("tf_declaration_clr:");
1166              $$ = lsCreate();
1167          }
1168        | tf_declaration_clr tf_declaration
1169          {
1170              lsHandle handle;
1171
1172              YYTRACE("tf_declaration_clr: tf_declaration_clr tf_declaration");
1173              lsNewEnd($1, (lsGeneric)$2, &handle);
1174              $$ = $1;
1175          }
1176        ;
1177
1178tf_declaration_eclr
1179        : tf_declaration
1180          {
1181              lsHandle handle;
1182
1183              YYTRACE("tf_declaration_eclr: tf_declaration");
1184              $$ = lsCreate();
1185              lsNewEnd($$, (lsGeneric)$1, &handle);
1186          }
1187        | tf_declaration_eclr tf_declaration
1188          {
1189              lsHandle handle;
1190
1191              YYTRACE("tf_declaration_eclr: tf_decalration_eclr tf_declaration");
1192              lsNewEnd($1, (lsGeneric)$2, &handle);
1193              $$ = $1;
1194          }
1195        ;
1196
1197tf_declaration
1198        : parameter_declaration
1199          {
1200              YYTRACE("tf_declaration: parameter_decalration");
1201              $$ = (typestructPtr)$1;
1202          }
1203        | input_declaration
1204          {
1205              YYTRACE("tf_declaration: input_declaration");
1206              $$ = (typestructPtr)$1;
1207          }
1208        | output_declaration
1209          {
1210              YYTRACE("tf_declaration: output_declaration");
1211              $$ = (typestructPtr)$1;
1212          }
1213        | inout_declaration
1214          {
1215              YYTRACE("tf_declaration: inout_declaration");
1216              $$ = (typestructPtr)$1;
1217          }
1218        | reg_declaration
1219          {
1220              YYTRACE("tf_declaration: reg_declaration");
1221              $$ = (typestructPtr)$1;
1222          }
1223        | time_declaration
1224          {
1225              YYTRACE("tf_declaration: time_declaration");
1226              $$ = (typestructPtr)$1;
1227          }
1228        | integer_declaration
1229          {
1230              YYTRACE("tf_declaration: integer_declaration");
1231              $$ = (typestructPtr)$1;
1232          }
1233        | real_declaration
1234          {
1235              YYTRACE("tf_declaration: real_declaration");
1236              $$ = (typestructPtr)$1;
1237          }
1238        | event_declaration
1239          {
1240              YYTRACE("tf_declaration: event_declaration");
1241              $$ = (typestructPtr)$1;
1242          }
1243        ;
1244
1245type_name
1246        : YYIDE
1247          {
1248              YYTRACE("type_name: YYIDE");
1249              $$ = vlStrdup(yyid);
1250          }
1251        ;
1252
1253type_specifier
1254        : enum_specifier
1255          {
1256              YYTRACE("type_specifier: enum_specifier ';'");
1257              $$ = vl_create_type_specifier(EnumType, $1);
1258          }
1259        ;
1260
1261enum_specifier
1262        : YYENUM {enum_val=0;} enum_name enum_lst_opt
1263          {
1264              YYTRACE("enum_specifier: YYENUM enum_name enum_lst_opt");
1265              $$ = vl_create_enum_type($3, $4);
1266          }
1267        | YYENUM {enum_val=0;} '{' enumerator_list '}'
1268          {
1269              YYTRACE("enum_specifier: YYENUM '{' enumerator_list '}'");
1270              $$ = vl_create_enum_type(NIL(char), $4);
1271          }
1272        ;
1273
1274enum_name
1275        : YYIDE
1276          {
1277              YYTRACE("enum_name: YYIDE");
1278              $$ = vlStrdup(yyid);
1279          }
1280        ;
1281
1282enum_lst_opt
1283        : '{' enumerator_list '}'
1284          {
1285              YYTRACE("enum_lst_opt: '{' enumerator_list '}'");
1286              $$ = $2;
1287          }
1288        |
1289          {
1290              YYTRACE("enum_lst_opt: ");
1291              $$ = (lsList)0;
1292          }
1293        ;
1294
1295enumerator_list
1296        : enumerator
1297          {
1298              YYTRACE("enumerator_list: enumerator");
1299              $$ = lsCreate();
1300              lsNewEnd($$, (lsGeneric)$1, 0);
1301          }
1302        | enumerator_list ',' enumerator
1303          {
1304              YYTRACE("enumerator_list: enumerator_list ',' enumerator");
1305              lsNewEnd($$, (lsGeneric)$3, 0);
1306          }
1307        ;
1308
1309enumerator
1310        : YYIDE
1311          {
1312              YYTRACE("enumerator: YYIDE");
1313              $$ = vl_create_enumerator(vlStrdup(yyid), enum_val++);
1314          }
1315        | YYIDE {cp=vlStrdup(yyid);} '=' expression
1316          {
1317              YYTRACE("enumerator: YYIDE '=' expression");
1318              enum_val = vl_eval_expr($4);
1319              $$ = vl_create_enumerator(cp, enum_val++);
1320          }
1321        ;
1322
1323
1324
1325type_decorator_opt
1326        : YYuTYPE
1327          {
1328              vl_type *var_type;
1329              int mustBe1;
1330
1331              YYTRACE("type_decorator_opt: YYuTYPE");
1332              mustBe1 = st_lookup(mod_list->type_st, yyid, (char**)&var_type);
1333              assert(mustBe1);
1334              $$ = var_type;
1335          }
1336        |
1337          {
1338              YYTRACE("type_decorator_opt: ");
1339              $$ = NIL(vl_type);
1340          }
1341        ;
1342
1343parameter_declaration
1344        : YYPARAMETER assignment_list ';'
1345          {
1346              YYTRACE("parameter_declaration: YYPARAMETER assignment_list ';'");
1347              $$ = vl_create_paramdecl(ParamDecl, $2);
1348          }
1349        ;
1350
1351input_declaration
1352        : YYINPUT range_opt variable_list ';'
1353          {
1354              YYTRACE("input_declaration: YYINPUT range_opt variable_list ';'");
1355              $$ = vl_create_rangedecl(NIL(vl_type), InputDecl, $2, $3, 0);
1356          }
1357        ;
1358
1359output_declaration
1360        : YYOUTPUT range_opt variable_list ';'
1361          {
1362              YYTRACE("output_declaration: YYOUTPUT range_opt variable_list ';'");
1363              $$ = vl_create_rangedecl(NIL(vl_type), OutputDecl, $2, $3, 0);
1364          }
1365        ;
1366
1367inout_declaration
1368        : YYINOUT range_opt variable_list ';'
1369          {
1370              YYTRACE("inout_declaration: YYINOUT range_opt variable_list ';'");
1371              $$ = vl_create_rangedecl(NIL(vl_type), InoutDecl, $2, $3, 0);
1372          }
1373        ;
1374
1375net_declaration
1376        : type_decorator_opt nettype drive_strength_opt expandrange_opt delay_opt
1377            assignment_list ';'
1378          {
1379              YYTRACE("net_declaration: type_decorator_opt nettype drive_strength_opt expandrange_opt delay_opt assignment_list ';'");
1380              $$ = vl_create_netdecl_assigned($1, $2, $3, $4, $5, $6);
1381          }
1382        | type_decorator_opt nettype drive_strength_opt expandrange_opt delay_opt
1383            variable_list ';'
1384          {
1385              YYTRACE("net_declaration: type_decorator_opt nettype drive_strength_opt expandrange_opt delay_opt variable_list ';'");
1386              $$ = vl_create_netdecl($1, $2, $3, $4, $5, $6);
1387          }
1388        | type_decorator_opt YYTRIREG charge_strength_opt expandrange_opt delay_opt
1389            variable_list ';'
1390          {
1391              YYTRACE("net_declaration: type_decorator_opt YYTRIREG charge_strength_opt expandrange_opt delay_opt variable_list ';'");
1392              $$ = vl_create_netdecl($1, TriregDecl, $3, $4, $5, $6);
1393          }
1394        ;
1395
1396
1397nettype
1398        : YYSWIRE
1399          {
1400              YYTRACE("nettype: YYSWIRE");
1401              $$ = SWireDecl;
1402          }
1403        | YYWIRE
1404          {
1405              YYTRACE("nettype: YYWIRE");
1406              $$ = WireDecl;
1407          }
1408        | YYTRI
1409          {
1410              YYTRACE("nettype: YYTRI");
1411              $$ = TriDecl;
1412          }
1413        | YYTRI1
1414          {
1415              YYTRACE("nettype: YYTRI1");
1416              $$ = Tri1Decl;
1417          }
1418        | YYSUPPLY0
1419          {
1420              YYTRACE("nettype: YYSUPPLY0");
1421              $$ = Supply0Decl;
1422          }
1423        | YYWAND
1424          {
1425              YYTRACE("nettype: YYWAND");
1426              $$ = WandDecl;
1427          }
1428        | YYTRIAND
1429          {
1430              YYTRACE("nettype: YYTRIAND");
1431              $$ = TriandDecl;
1432          }
1433        | YYTRI0
1434          {
1435              YYTRACE("nettype: YYTRI0");
1436              $$ = Tri0Decl;
1437          }
1438        | YYSUPPLY1
1439          {
1440              YYTRACE("nettype: YYSUPPLY1");
1441              $$ = Supply1Decl;
1442          }
1443        | YYWOR
1444          {
1445              YYTRACE("nettype: YYWOR");
1446              $$ = WorDecl;
1447          }
1448        | YYTRIOR
1449          {
1450              YYTRACE("nettype: YYTRIOR");
1451              $$ = TriorDecl;
1452          }
1453        ;
1454
1455
1456expandrange_opt
1457        :
1458          {
1459              YYTRACE("expandrange_opt:");
1460              $$ = NIL(vl_range);
1461          }
1462        | expandrange
1463          {
1464              YYTRACE("expandrange_opt: expandrange");
1465              $$ = $1;
1466          }
1467        ;
1468
1469expandrange
1470        : range
1471          {
1472              YYTRACE("expandrange: range");
1473          }
1474        | YYSCALARED range
1475          {
1476              YYTRACE("expandrange: YYSCALARED range");
1477              $$ = $2;
1478          }
1479        | YYVECTORED range
1480          {
1481              YYTRACE("expandrange: YYVECTORED range");
1482              $$ = $2;
1483          }
1484        ;
1485
1486reg_declaration
1487        : type_decorator_opt YYREG range_opt register_variable_list ';'
1488          {
1489              YYTRACE("reg_declaration: type_decorator_opt YYREG range_opt register_variable_list ';'");
1490              $$ = vl_create_rangedecl($1, RegDecl, $3, $4, 0);
1491          }
1492        | type_decorator_opt YYMREG range_opt register_variable_list ';'
1493          {
1494              YYTRACE("reg_declaration: type_decorator_opt YYMREG range_opt register_variable_list ';'");
1495              $$ = vl_create_rangedecl($1, RegDecl, $3, $4, MVar);
1496          }
1497        ;
1498
1499time_declaration
1500        : YYTIME register_variable_list ';'
1501          {
1502              YYTRACE("time_declaration: YYTIME register_variable_list ';'");
1503              $$ = vl_create_basicdecl(TimeDecl, $2);
1504          }
1505        ;
1506
1507integer_declaration
1508        : YYINTEGER register_variable_list ';'
1509          {
1510              YYTRACE("integer_declaration: YYINTEGER register_variable_list ';'");
1511              $$ = vl_create_basicdecl(IntDecl, $2);
1512          }
1513        ;
1514
1515real_declaration
1516        : YYREAL variable_list ';'
1517          {
1518              YYTRACE("real_declaration: YYREAL variable_list ';'");
1519              $$ = vl_create_basicdecl(RealDecl, $2);
1520          }
1521        ;
1522
1523event_declaration
1524        : YYEVENT name_of_event_list ';'
1525          {
1526              YYTRACE("event_declaration: YYEVENT name_of_event_list ';'");
1527              $$ = vl_create_basicdecl(EventDecl, $2);
1528          }
1529        ;
1530
1531continuous_assign
1532        : YYASSIGN {reserve_type_name=0; c_assign=1;}
1533          drive_strength_opt delay_opt assignment_list ';'
1534          {
1535              YYTRACE("continuous_assign: YYASSIGN drive_strength_opt delay_opt assignment_list ';'");
1536              $$ = vl_create_cont_assign_stmt($3, $4, $5);
1537              reserve_type_name=1;
1538              c_assign=0;
1539          }
1540        ;
1541
1542parameter_override
1543        : YYDEFPARAM assignment_list ';'
1544          {
1545              YYTRACE("parameter_override: YYDEFPARAM assign_list ';'");
1546              $$ = vl_create_paramdecl(DefparamDecl, $2);
1547          }
1548        ;
1549
1550variable_list
1551        : identifier
1552          {
1553              lsHandle handle;
1554
1555              YYTRACE("variable_list: identifier");
1556              $$ = lsCreate();
1557              lsNewEnd($$, (lsGeneric)$1, &handle);
1558          }
1559        | variable_list ',' identifier
1560          {
1561              lsHandle handle;
1562
1563              YYTRACE("variable_list: variable_list ',' identifier");
1564              lsNewEnd($1, (lsGeneric)$3, &handle);
1565              $$ = $1;
1566          }
1567        ;
1568
1569register_variable_list
1570        : register_variable
1571          {
1572              lsHandle handle;
1573
1574              YYTRACE("register_variable_list: register_variable");
1575              $$ = lsCreate();
1576              lsNewEnd($$, (lsGeneric)$1, &handle);
1577          }
1578        | register_variable_list ',' register_variable
1579          {
1580              lsHandle handle;
1581
1582              YYTRACE("register_variable_list: register_variable_list ',' register_variable");
1583              lsNewEnd($1, (lsGeneric)$3, &handle);
1584              $$ = $1;
1585          }
1586        ;
1587
1588register_variable
1589        : name_of_register
1590          {
1591              YYTRACE("register_variable: name_of_register");
1592              $$ = vl_create_id_range($1, NIL(vl_range));
1593          }
1594        | name_of_register '[' expression ':' expression ']'
1595          {
1596              int lo, hi;
1597
1598              YYTRACE("register_variable: name_of_register '[' expression ':' expression ']'");
1599              lo = vl_eval_expr($3);
1600              hi = vl_eval_expr($5);
1601              if (lo > hi)
1602                  $$ = vl_create_id_range($1, vl_create_range($5, $3));
1603              else
1604                  $$ = vl_create_id_range($1, vl_create_range($3, $5));
1605          }
1606        ;
1607
1608name_of_register
1609        : YYIDE
1610          {
1611              YYTRACE("name_of_register: YYIDE");
1612              $$ = vlStrdup(yyid);
1613          }
1614        ;
1615
1616name_of_event_list
1617        : name_of_event
1618          {
1619              lsHandle handle;
1620
1621              YYTRACE("name_of_event_list: name_of_event");
1622              $$ = lsCreate();
1623              lsNewEnd($$, (lsGeneric)$1, &handle);
1624          }
1625        | name_of_event_list ',' name_of_event
1626          {
1627              lsHandle handle;
1628
1629              YYTRACE("name_of_event_list: name_of_event_list ',' name_of_event");
1630              lsNewEnd($1, (lsGeneric)$3, &handle);
1631              $$ = $1;
1632          }
1633        ;
1634
1635name_of_event
1636        : YYIDE
1637          {
1638              YYTRACE("name_of_event: YYIDE");
1639              $$ = vl_create_id_range(vlStrdup(yyid), NIL(vl_range));
1640          }
1641        ;
1642
1643charge_strength_opt
1644        :
1645          {
1646              YYTRACE("charge_strength_opt:");
1647              $$ = 0;
1648          }
1649        | charge_strength
1650          {
1651              YYTRACE("charge_strength_opt: charge_strength");
1652          }
1653        ;
1654
1655charge_strength
1656        : '(' YYSMALL ')'
1657          {
1658              YYTRACE("charge_strength: '(' YYSMALL ')'");
1659              $$ = Small;
1660          }
1661        | '(' YYMEDIUM ')'
1662          {
1663              YYTRACE("charge_strength: '(' YYMEDIUM ')'");
1664              $$ = Medium;
1665          }
1666        | '(' YYLARGE ')'
1667          {
1668              YYTRACE("charge_strength: '(' YYLARGE ')'");
1669              $$ = Large;
1670          }
1671        ;
1672
1673drive_strength_opt
1674        :
1675          {
1676              YYTRACE("drive_strength_opt:");
1677              $$ = 0;
1678          }
1679        | drive_strength
1680          {
1681              YYTRACE("drive_strength_opt: drive_strength");
1682              $$ = $1;
1683          }
1684        ;
1685
1686drive_strength
1687        : '(' strength0 ',' strength1 ')'
1688          {
1689              YYTRACE("drive_strength: '(' strength0 ',' strength1 ')'");
1690              $$ = drive_strength($2, $4);
1691          }
1692        | '(' strength1 ',' strength0 ')'
1693          {
1694              YYTRACE("drive_strength: '(' strength1 ',' strength0 ')'");
1695              $$ = drive_strength($4, $2);
1696          }
1697        ;
1698
1699strength0
1700        : YYSUPPLY0
1701          {
1702              YYTRACE("strength0: YYSUPPLY0");
1703              $$ = YYSUPPLY0;
1704          }
1705        | YYSTRONG0
1706          {
1707              YYTRACE("strength0: YYSTRONG0");
1708              $$ = YYSTRONG0;
1709          }
1710        | YYPULL0
1711          {
1712              YYTRACE("strength0: YYPULL0");
1713              $$ = YYPULL0;
1714          }
1715        | YYWEAK0
1716          {
1717              YYTRACE("strength0: YYWEAK0");
1718              $$ = YYWEAK0;
1719          }
1720        | YYHIGHZ0
1721          {
1722              YYTRACE("strength0: YYHIGHZ0");
1723              $$ = YYHIGHZ0;
1724          }
1725        ;
1726
1727strength1
1728        : YYSUPPLY1
1729          {
1730              YYTRACE("strength1: YYSUPPLY1");
1731              $$ = YYSUPPLY1;
1732          }
1733        | YYSTRONG1
1734          {
1735              YYTRACE("strength1: YYSTRONG1");
1736              $$ = YYSTRONG1;
1737          }
1738        | YYPULL1
1739          {
1740              YYTRACE("strength1: YYPULL1");
1741              $$ = YYPULL1;
1742          }
1743        | YYWEAK1
1744          {
1745              YYTRACE("strength1: YYWEAK1");
1746              $$ = YYWEAK1;
1747          }
1748        | YYHIGHZ1
1749          {
1750              YYTRACE("strength1: YYHIGHZ1");
1751              $$ = YYHIGHZ1;
1752          }
1753        ;
1754
1755range_opt
1756        :
1757          {
1758              YYTRACE("range_opt:");
1759              $$ = NIL(vl_range);
1760          }
1761        | range
1762          {
1763              YYTRACE("range_opt: range");
1764              $$ = $1;
1765          }
1766        ;
1767
1768range
1769        : '[' expression ':' expression ']'
1770          {
1771              YYTRACE("range: '[' expression ':' expression ']'");
1772              $$ = vl_create_range($2, $4);
1773          }
1774        ;
1775
1776assignment_list
1777        : assignment
1778          {
1779              lsHandle handle;
1780
1781              YYTRACE("assignment_list: assignment");
1782              $$ = lsCreate();
1783              lsNewEnd($$, (lsGeneric)$1, &handle);
1784          }
1785        | assignment_list ',' assignment
1786          {
1787              lsHandle handle;
1788
1789              YYTRACE("assignment_list: assignment_list ',' assignment");
1790              lsNewEnd($1, (lsGeneric)$3, &handle);
1791              $$ = $1;
1792          }
1793        ;
1794
1795
1796
1797gate_instantiation
1798        : gatetype drive_delay_clr gate_instance_list ';'
1799          {
1800              int strength=0;
1801              vl_delay *delay=NIL(vl_delay);
1802
1803              YYTRACE("gate_instantiation: gatetype drive_delay_clr gate_instance_list ';'");
1804
1805              extract_delay_strength($2, &delay, &strength);
1806              lsDestroy($2, NULL);
1807
1808
1809              $$ = vl_create_gate_inst_list($1, strength, delay, $3);
1810
1811              insert_instances($3, $$);
1812          }
1813        ;
1814
1815drive_delay_clr
1816        :
1817          {
1818              YYTRACE("drive_delay_clr:");
1819              $$ = lsCreate();
1820          }
1821        | drive_delay_clr drive_delay
1822          {
1823              lsHandle handle;
1824
1825              YYTRACE("drive_delay_clr: drive_delay_clr drive_delay");
1826              lsNewEnd($1, (lsGeneric)$2, &handle);
1827              $$ = $1;
1828          }
1829        ;
1830
1831drive_delay
1832        : drive_strength
1833          {
1834              YYTRACE("drive_delay: drive_strength");
1835              $$ = $1 << 2;
1836          }
1837        | delay
1838          {
1839              YYTRACE("drive_delay: delay");
1840
1841
1842
1843              $$ = (int)($1) | LEAST_SB;
1844          }
1845        ;
1846
1847gatetype
1848        : YYAND
1849          {
1850              YYTRACE("gatetype: YYAND");
1851              $$ = AndGate;
1852          }
1853        | YYNAND
1854          {
1855              YYTRACE("gatetype: YYNAND");
1856              $$ = NandGate;
1857          }
1858        | YYOR
1859          {
1860              YYTRACE("gatetype: YYOR");
1861              $$ = OrGate;
1862          }
1863        | YYNOR
1864          {
1865              YYTRACE("gatetype: YYNOR");
1866              $$ = NorGate;
1867          }
1868        | YYXOR
1869          {
1870              YYTRACE("gatetype: YYXOR");
1871              $$ = XorGate;
1872          }
1873        | YYXNOR
1874          {
1875              YYTRACE("gatetype: YYXNOR");
1876              $$ = XnorGate;
1877          }
1878        | YYBUF
1879          {
1880              YYTRACE("gatetype: YYBUF");
1881              $$ = BufGate;
1882          }
1883        | YYBUFIF0
1884          {
1885              YYTRACE("gatetype: YYBIFIF0");
1886              $$ = Bufif0Gate;
1887          }
1888        | YYBUFIF1
1889          {
1890              YYTRACE("gatetype: YYBIFIF1");
1891              $$ = Bufif1Gate;
1892          }
1893        | YYNOT
1894          {
1895              YYTRACE("gatetype: YYNOT");
1896              $$ = NotGate;
1897          }
1898        | YYNOTIF0
1899          {
1900              YYTRACE("gatetype: YYNOTIF0");
1901              $$ = Notif0Gate;
1902          }
1903        | YYNOTIF1
1904          {
1905              YYTRACE("gatetype: YYNOTIF1");
1906              $$ = Notif1Gate;
1907          }
1908        | YYPULLDOWN
1909          {
1910              YYTRACE("gatetype: YYPULLDOWN");
1911              $$ = PulldownGate;
1912          }
1913        | YYPULLUP
1914          {
1915              YYTRACE("gatetype: YYPULLUP");
1916              $$ = PullupGate;
1917          }
1918        | YYNMOS
1919          {
1920              YYTRACE("gatetype: YYNMOS");
1921              $$ = NmosGate;
1922          }
1923        | YYPMOS
1924          {
1925              YYTRACE("gatetype: YYPMOS");
1926              $$ = PmosGate;
1927          }
1928        | YYRNMOS
1929          {
1930              YYTRACE("gatetype: YYRNMOS");
1931              $$ = RnmosGate;
1932          }
1933        | YYRPMOS
1934          {
1935              YYTRACE("gatetype: YYRPMOS");
1936              $$ = RpmosGate;
1937          }
1938        | YYCMOS
1939          {
1940              YYTRACE("gatetype: YYCMOS");
1941              $$ = CmosGate;
1942          }
1943        | YYRCMOS
1944          {
1945              YYTRACE("gatetype: YYRCMOS");
1946              $$ = RcmosGate;
1947          }
1948        | YYTRAN
1949          {
1950              YYTRACE("gatetype: YYTRAN");
1951              $$ = TranGate;
1952          }
1953        | YYRTRAN
1954          {
1955              YYTRACE("gatetype: YYRTRAN");
1956              $$ = RtranGate;
1957          }
1958        | YYTRANIF0
1959          {
1960              YYTRACE("gatetype: YYTRANIF0");
1961              $$ = Tranif0Gate;
1962          }
1963        | YYRTRANIF0
1964          {
1965              YYTRACE("gatetype: YYRTRANIF0");
1966              $$ = Rtranif0Gate;
1967          }
1968        | YYTRANIF1
1969          {
1970              YYTRACE("gatetype: YYTRANIF1");
1971              $$ = Tranif1Gate;
1972          }
1973        | YYRTRANIF1
1974          {
1975              YYTRACE("gatetype: YYRTRANIF1");
1976              $$ = Rtranif1Gate;
1977          }
1978
1979
1980        | YYTESLATIMER
1981          {
1982              YYTRACE("gatetype: YYTESLATIMER");
1983              $$ = TeslaTimerGate;
1984          }
1985        ;
1986
1987gate_instance_list
1988        : gate_instance
1989          {
1990              lsHandle handle;
1991
1992              YYTRACE("gate_instance_list: gate_instance");
1993              $$ = lsCreate();
1994              lsNewEnd($$, (lsGeneric)$1, &handle);
1995          }
1996        | gate_instance_list ',' gate_instance
1997          {
1998              lsHandle handle;
1999
2000              YYTRACE("gate_instance_list: gate_instance_list ',' gate_instance");
2001              lsNewEnd($1, (lsGeneric)$3, &handle);
2002              $$ = $1;
2003          }
2004        ;
2005
2006gate_instance
2007        : '(' terminal_list ')'
2008          {
2009              YYTRACE("gate_instance: '(' terminal_list ')'");
2010              $$ = vl_create_gate_inst(NIL(vl_id_range), $2);
2011          }
2012        | name_of_gate_instance '(' terminal_list ')'
2013          {
2014              YYTRACE("gate_instance: name_of_gate_instance '(' terminal_list ')'");
2015              $$ = vl_create_gate_inst($1, $3);
2016          }
2017        ;
2018
2019name_of_gate_instance
2020        : YYIDE
2021          {
2022              YYTRACE("name_of_gate_instance: YYIDE");
2023              $$ = vl_create_id_range(vlStrdup(yyid), NIL(vl_range));
2024          }
2025        ;
2026
2027terminal_list
2028        : terminal
2029          {
2030              lsHandle handle;
2031
2032              YYTRACE("terminal_list: terminal");
2033              $$ = lsCreate();
2034              lsNewEnd($$, (lsGeneric)$1, &handle);
2035          }
2036        | terminal_list ',' terminal
2037          {
2038              lsHandle handle;
2039
2040              YYTRACE("terminal_list: terminal_list ',' terminal");
2041              lsNewEnd($1, (lsGeneric)$3, &handle);
2042              $$ = $1;
2043          }
2044        ;
2045
2046terminal
2047        : expression
2048          {
2049              YYTRACE("terminal: expression");
2050          }
2051        ;
2052
2053
2054
2055module_or_primitive_instantiation
2056        : name_of_module_or_primitive module_or_primitive_option_clr
2057             module_or_primitive_instance_list ';'
2058          {
2059              int strength=0;
2060              vl_delay *delay=NIL(vl_delay);
2061
2062              YYTRACE("module_or_primitive_instantiation: name_of_module_or_primitive module_or_primitive_option_clr module_or_primitive_instance_list ';'");
2063
2064              extract_delay_strength($2, &delay, &strength);
2065              lsDestroy($2, NULL);
2066
2067
2068              $$ = vl_add_find_mod_prim_instances($1, delay, strength, $3);
2069
2070              insert_instances($3, $$);
2071          }
2072        ;
2073
2074name_of_module_or_primitive
2075        : YYIDE
2076          {
2077              YYTRACE("name_of_module_or_primitive: YYIDE");
2078              $$ = vl_create_id_range(vlStrdup(yyid), NIL(vl_range));
2079          }
2080        ;
2081
2082module_or_primitive_option_clr
2083        :
2084          {
2085              YYTRACE("module_or_primitive_option_clr:");
2086              $$ = lsCreate();
2087          }
2088        | module_or_primitive_option_clr module_or_primitive_option
2089          {
2090              lsHandle handle;
2091
2092              YYTRACE("module_or_primitive_option_clr: module_or_primitive_option_clr module_or_primitive_option");
2093              lsNewEnd($1, (lsGeneric)$2, &handle);
2094              $$ = $1;
2095          }
2096        ;
2097
2098module_or_primitive_option
2099        : drive_strength
2100          {
2101              YYTRACE("module_or_primitive_option:");
2102              $$ = $1 << 2;
2103          }
2104        | delay_or_parameter_value_assignment
2105          {
2106              YYTRACE("module_or_primitive_option: delay");
2107
2108              $$ = (int)($1) | LEAST_SB;
2109          }
2110        ;
2111
2112delay_or_parameter_value_assignment
2113        : '#' YYINUMBER
2114          {
2115              vl_expr *expr;
2116
2117              YYTRACE("delay_or_parameter_value_assignment: '#' YYINUMBER");
2118              expr = vl_create_expr(IntExpr, atoi(yytext), (double)0.0,
2119                                    NIL(void), NIL(void), NIL(void));
2120              $$ = vl_create_delay(expr, NIL(vl_expr), NIL(vl_expr));
2121          }
2122        | '#' YYRNUMBER
2123          {
2124              vl_expr *expr;
2125
2126              YYTRACE("delay_or_parameter_value_assignment: '#' YYRNUMBER");
2127              expr = vl_create_expr(IntExpr, 0, atof(yytext),
2128                                    NIL(void), NIL(void), NIL(void));
2129              $$ = vl_create_delay(expr, NIL(vl_expr), NIL(vl_expr));
2130          }
2131        | '#' identifier
2132          {
2133              vl_expr *expr;
2134
2135              YYTRACE("delay_or_parameter_value_assignment: '#' identifier");
2136              expr = vl_create_expr(IDExpr, 0, (double)0.0,
2137                                    $2, NIL(void), NIL(void));
2138              $$ = vl_create_delay(expr, NIL(vl_expr), NIL(vl_expr));
2139          }
2140        | '#' '(' mintypmax_expression_list ')'
2141          {
2142              YYTRACE("delay_or_parameter_value_assignment: '#' '(' mintypmax_expression_list ')'");
2143              $$ = vl_create_delay(NIL(vl_expr), NIL(vl_expr), (vl_expr*)$3);
2144          }
2145        ;
2146
2147module_or_primitive_instance_list
2148        : module_or_primitive_instance
2149          {
2150              lsHandle handle;
2151
2152              YYTRACE("module_or_primitive_instance_list: module_or_primitive_instance");
2153              $$ = lsCreate();
2154              lsNewEnd($$, (lsGeneric)$1, &handle);
2155          }
2156        | module_or_primitive_instance_list ',' module_or_primitive_instance
2157          {
2158              lsHandle handle;
2159
2160              YYTRACE("module_or_primitive_instance_list: module_or_primitive_instance_list ',' module_or_primitive_instance");
2161              lsNewEnd($1, (lsGeneric)$3,  &handle);
2162              $$ = $1;
2163          }
2164        ;
2165
2166
2167module_or_primitive_instance
2168        : '(' module_connection_list ')'
2169          {
2170              YYTRACE("module_or_primitive_instance: '(' module_connection_list ')'");
2171              $$ = (typestructPtr)vl_create_mod_prim_inst(NIL(vl_id_range), $2);
2172          }
2173        | identifier '(' module_connection_list ')'
2174          {
2175              YYTRACE("module_or_primitive_instance: '(' module_connection_list ')'");
2176              $$ = (typestructPtr)vl_create_mod_prim_inst($1, $3);
2177          }
2178        ;
2179
2180module_connection_list
2181        : module_port_connection_list
2182          {
2183              YYTRACE("module_connection_list: module_port_connection_list");
2184          }
2185        | named_port_connection_list
2186          {
2187              YYTRACE("module_connection_list: named_port_connection_list");
2188          }
2189        ;
2190
2191module_port_connection_list
2192        : module_port_connection
2193          {
2194              lsHandle handle;
2195
2196              YYTRACE("module_port_connection_list: module_port_connection");
2197              $$ = lsCreate();
2198              lsNewEnd($$, (lsGeneric)$1, &handle);
2199          }
2200        | module_port_connection_list ',' module_port_connection
2201          {
2202              lsHandle handle;
2203
2204              YYTRACE("module_port_connection_list: module_port_connection_list ',' module_port_connection");
2205              lsNewEnd($1, (lsGeneric)$3, &handle);
2206              $$ = $1;
2207          }
2208        ;
2209
2210named_port_connection_list
2211        : named_port_connection
2212          {
2213              lsHandle handle;
2214
2215              YYTRACE("named_port_connection_list: named_port_connection");
2216              $$ = lsCreate();
2217              lsNewEnd($$, (lsGeneric)$<ival>1, &handle);
2218          }
2219        | named_port_connection_list ',' named_port_connection
2220          {
2221              lsHandle handle;
2222
2223              YYTRACE("named_port_connection_list: named_port_connection_list ',' name_port_connection");
2224              lsNewEnd($1, (lsGeneric)$<ival>3, &handle);
2225              $$ = $1;
2226          }
2227        ;
2228
2229module_port_connection
2230        :
2231          {
2232              YYTRACE("module_port_connection:");
2233              $$ = vl_create_port_connect(ModuleConnect,
2234                                          NIL(vl_id_range), NIL(vl_expr));
2235          }
2236        | expression
2237          {
2238              YYTRACE("module_port_connection: expression");
2239              $$ = vl_create_port_connect(ModuleConnect, NIL(vl_id_range), $1);
2240          }
2241        ;
2242
2243named_port_connection
2244        : '.' identifier '(' expression ')'
2245          {
2246              YYTRACE("named_port_connection: '.' identifier '(' expression ')'");
2247              $$ = vl_create_port_connect(NamedConnect, $2, $4);
2248          }
2249        ;
2250
2251
2252
2253initial_statement
2254        : YYINITIAL {reserve_type_name=0; timed_statement=0;} statement
2255          {
2256              YYTRACE("initial_statement: YYINITIAL statement");
2257              $$ = vl_create_procstmt(InitialStmt, $3);
2258              reserve_type_name=1;
2259              if (timed_statement) $$->flags |= TimedInitStmt;
2260          }
2261        ;
2262
2263always_statement
2264        : YYALWAYS {reserve_type_name=0;} statement
2265          {
2266              YYTRACE("always_statement: YYALWAYS statement");
2267              $$ = vl_create_procstmt(AlwaysStmt, $3);
2268              reserve_type_name=1;
2269          }
2270        ;
2271
2272statement_opt
2273        :
2274          {
2275              YYTRACE("statement_opt:");
2276              $$ = lsCreate();
2277          }
2278        | statement
2279          {
2280              lsHandle handle;
2281
2282              YYTRACE("statement_opt: statement");
2283              $$ = lsCreate();
2284              lsNewEnd($$, (lsGeneric)$1, &handle);
2285          }
2286        ;
2287
2288statement_clr
2289        :
2290          {
2291              YYTRACE("statement_clr:");
2292              $$ = lsCreate();
2293          }
2294        | statement_clr statement
2295          {
2296              lsHandle handle;
2297
2298              YYTRACE("statement_clr: statement_clr statement");
2299              lsNewEnd($1, (lsGeneric)$2, &handle);
2300              $$ = $1;
2301          }
2302        ;
2303
2304
2305statement
2306        : ';'
2307          {
2308              YYTRACE("statement: ';'");
2309              $$ = NIL(typestruct);
2310          }
2311        | assignment ';'
2312          {
2313              YYTRACE("statement: assignment ';'");
2314          }
2315        | YYIF '(' expression ')' statement
2316          {
2317              YYTRACE("statement: YYIF '(' expression ')' statement");
2318              $$ = (typestructPtr)vl_create_if_else_stmt($3, $5, NIL(typestruct));
2319          }
2320        | YYIF '(' expression ')' statement YYELSE statement
2321          {
2322              YYTRACE("statement: YYIF '(' expression ')' statement YYELSE statement");
2323              $$ = (typestructPtr)vl_create_if_else_stmt($3, $5, $7);
2324          }
2325        | YYCASE '(' expression ')' case_item_eclr YYENDCASE
2326          {
2327              YYTRACE("statement: YYCASE '(' expression ')' case_item_eclr YYENDCASE");
2328              $$ = (typestructPtr)vl_create_case_stmt(CaseStmt, $3, $5);
2329          }
2330        | YYCASEZ '(' expression ')' case_item_eclr YYENDCASE
2331          {
2332              YYTRACE("statement: YYCASEZ '(' expression ')' case_item_eclr YYENDCASE");
2333              $$ = (typestructPtr)vl_create_case_stmt(CasezStmt, $3, $5);
2334          }
2335        | YYCASEX '(' expression ')' case_item_eclr YYENDCASE
2336          {
2337              YYTRACE("statement: YYCASEX '(' expression ')' case_item_eclr YYENDCASE");
2338              $$ = (typestructPtr)vl_create_case_stmt(CasexStmt, $3, $5);
2339          }
2340        | YYFOREVER statement
2341          {
2342              YYTRACE("statement: YYFOREVER statement");
2343              $$ = (typestructPtr)vl_create_forever_stmt($2);
2344          }
2345        | YYREPEAT '(' expression ')' statement
2346          {
2347              YYTRACE("statement: YYREPEAT '(' expression ')' statement");
2348              $$ = (typestructPtr)vl_create_repeat_stmt($3, $5);
2349          }
2350        | YYWHILE '(' expression ')' statement
2351          {
2352              YYTRACE("statement: YYWHILE '(' expression ')' statement");
2353              $$ = (typestructPtr)vl_create_while_stmt($3, $5);
2354          }
2355        | YYFOR '(' assignment ';' expression ';' assignment ')' statement
2356          {
2357              YYTRACE("statement: YYFOR '(' assignment ';' expression ';' assignment ')' statement");
2358              $$ = (typestructPtr)vl_create_for_stmt($3, $5, $7, $9);
2359          }
2360        | delay_control statement
2361          {
2362              YYTRACE("statement: delay_control statement");
2363              $$ = (typestructPtr)vl_create_delay_control_stmt($1, $2);
2364          }
2365        | event_control statement
2366          {
2367              YYTRACE("statement: event_control statement");
2368              $$ = (typestructPtr)vl_create_event_control_stmt($1, $2);
2369          }
2370        | lvalue type_action '=' delay_control expression ';'
2371          {
2372              YYTRACE("statement: lvalue '=' delay_control expression ';'");
2373              $$ = (typestructPtr)vl_create_bassign_stmt(DelayBassignStmt, $1, $4, $5);
2374          }
2375        | lvalue type_action '=' event_control expression ';'
2376          {
2377              YYTRACE("statement: lvalue '=' event_control expression ';'");
2378              $$ = (typestructPtr)vl_create_bassign_stmt(EventBassignStmt, $1, $4, $5);
2379          }
2380        | lvalue type_action YYNBASSIGN delay_control expression ';'
2381          {
2382              YYTRACE("statement: lvalue YYNBASSIGN delay_control expression ';'");
2383              $$ = (typestructPtr)vl_create_bassign_stmt(DelayNbassignStmt, $1, $4, $5);
2384          }
2385        | lvalue type_action YYNBASSIGN event_control expression ';'
2386          {
2387              YYTRACE("statement: lvalue YYNBASSIGN event_control expression ';'");
2388              $$ = (typestructPtr)vl_create_bassign_stmt(EventNbassignStmt, $1, $4, $5);
2389          }
2390        | YYWAIT '(' expression ')' statement
2391          {
2392              YYTRACE("statement: YYWAIT '(' expression ')' statement");
2393              $$ = (typestructPtr)vl_create_wait_stmt($3, $5);
2394          }
2395        | YYRIGHTARROW name_of_event ';'
2396          {
2397              YYTRACE("statement: YYRIGHTARROW name_of_event ';'");
2398              $$ = (typestructPtr)vl_create_send_event_stmt($2);
2399          }
2400        | seq_block
2401          {
2402              YYTRACE("statement: seq_block");
2403          }
2404        | par_block
2405          {
2406              YYTRACE("statement: par_block");
2407          }
2408        | task_enable
2409          {
2410              YYTRACE("statement: task_enable");
2411          }
2412        | system_task_enable
2413          {
2414              YYTRACE("statement: system_task_enable");
2415              TODO("statement: system_task_enable");
2416              $$ = NIL(typestruct);
2417          }
2418        | YYDISABLE YYIDE
2419          {
2420              $<idrng>$ = vl_create_id_range(vlStrdup(yyid), NIL(vl_range));
2421          }
2422          ';'
2423          {
2424              YYTRACE("statement: YYDISABLE YYIDE ';'");
2425              $$ = (typestructPtr)vl_create_disable_stmt($<idrng>3);
2426          }
2427        | YYASSIGN assignment ';'
2428          {
2429              YYTRACE("statement: YYASSIGN assignment ';'");
2430              $2->type = AssignStmt;
2431              $$ = (typestructPtr)$2;
2432          }
2433        | YYDEASSIGN lvalue ';'
2434          {
2435              YYTRACE("statement: YYDEASSIGN lvalue ';'");
2436              $$ = (typestructPtr)vl_create_deassign_stmt($2);
2437          }
2438        ;
2439
2440assignment
2441        : lvalue type_action '=' expression
2442          {
2443              YYTRACE("assignment: lvalue '=' expression");
2444              associate_symbolic_value($1, $4);
2445              $$ = vl_create_bassign_stmt(BassignStmt, $1, NIL(void), $4);
2446              if (c_assign && $1->type != ConcatExpr) {
2447                  vl_id_range *id_sym;
2448                  if (!st_lookup(vl_currentModule->sig_st, $1->name->name, (char**)&id_sym))
2449                      compile_error("continuous assignment to undeclared var");
2450                  id_sym->flags |= WireVar;
2451              }
2452              pop_stack(vl_cur_type_stack, (void **) &aux_st);
2453          }
2454        | lvalue type_action YYNBASSIGN expression
2455          {
2456              YYTRACE("assignment: lvalue YYNBASSIGN expression");
2457              associate_symbolic_value($1, $4);
2458              $$ = vl_create_bassign_stmt(NbassignStmt, $1, NIL(void), $4);
2459              if (c_assign && $1->type != ConcatExpr) {
2460                  vl_id_range *id_sym;
2461                  if (!st_lookup(vl_currentModule->sig_st, $1->name->name, (char**)&id_sym))
2462                    compile_error("non-blocking assignment to undeclared var");
2463                  id_sym->flags |= WireVar;
2464              }
2465              pop_stack(vl_cur_type_stack, (void **) &aux_st);
2466          }
2467        ;
2468
2469type_action
2470        :
2471          {
2472              vl_id_range *id_sym;
2473
2474              if ($<lval>0->type != ConcatExpr) {
2475                  push_stack(vl_cur_type_stack, aux_st);
2476
2477                  if (st_lookup(vl_currentModule->sig_st,
2478                                $<lval>0->name->name, &id_sym))
2479                      if (id_sym->id_type)
2480                          aux_st =
2481                            id_sym->id_type->specifier->u.enum_type->domain_st;
2482                      else
2483                          aux_st = NIL(st_table);
2484                  else
2485                      aux_st = NIL(st_table);
2486              }
2487          }
2488        ;
2489
2490type_action_expr
2491        :
2492          { /* Partial patch: b = (v1 == a) ? v1 : v2, where v1 and v2
2493             * are enumerated values still compiled incorrectly. */
2494              vl_id_range *id_sym;
2495
2496              if ($<expr>-1->type != ConcatExpr) {
2497                  push_stack(vl_cur_type_stack, aux_st);
2498                  if ($<expr>-1->type == IDExpr) {
2499                      if (st_lookup(vl_currentModule->sig_st,
2500                                    $<expr>-1->u.name->name, &id_sym))
2501                          if (id_sym->id_type)
2502                              aux_st =
2503                                  id_sym->id_type->specifier->u.enum_type->domain_st;
2504                          else
2505                              aux_st = NIL(st_table);
2506                      else
2507                          aux_st = NIL(st_table);
2508                  }
2509                  else
2510                      aux_st = NIL(st_table);
2511              }
2512          }
2513        ;
2514
2515case_item_eclr
2516        : case_item
2517          {
2518              lsHandle handle;
2519
2520              YYTRACE("case_item_eclr: case_item");
2521              $$ = lsCreate();
2522              lsNewEnd($$, (lsGeneric)$1, &handle);
2523          }
2524        | case_item_eclr case_item
2525          {
2526              lsHandle handle;
2527
2528              YYTRACE("case_item_eclr: case_item_eclr case_item");
2529              lsNewEnd($1, (lsGeneric)$2, &handle);
2530              $$ = $1;
2531          }
2532        ;
2533
2534case_item
2535        : expression_list ':' statement
2536          {
2537              YYTRACE("case_item: expression_list ':' statement");
2538              $$ = vl_create_case_item(CaseItem, $1, $3);
2539          }
2540        | YYDEFAULT ':' statement
2541          {
2542              YYTRACE("case_item: YYDEFAULT ':' statement");
2543              $$ = vl_create_case_item(DefaultItem, (lsList)0, $3);
2544          }
2545        | YYDEFAULT statement
2546          {
2547              YYTRACE("case_item: YYDEFAULT statement");
2548              $$ = vl_create_case_item(DefaultItem, (lsList)0, $2);
2549          }
2550        ;
2551
2552seq_block
2553        : YYBEGIN statement_clr YYEND
2554          {
2555              YYTRACE("seq_block: YYBEGIN statement_clr YYEND");
2556              $$ = vl_create_begin_end_stmt(NIL(vl_id_range), LS_NH, $2);
2557          }
2558        | YYBEGIN ':' name_of_block block_declaration_clr statement_clr YYEND
2559          {
2560              YYTRACE("seq_block: YYBEGIN ':' name_of_block block_declaration_clr statement_clr YYEND");
2561              $$ = vl_create_begin_end_stmt($3, $4, $5);
2562          }
2563        ;
2564
2565par_block
2566        : YYFORK statement_clr YYJOIN
2567          {
2568              YYTRACE("par_block: YYFORK statement_clr YYJOIN");
2569              $$ = vl_create_fork_join_stmt(NIL(vl_id_range), LS_NH, $2);
2570              TODO("fork/join : dynamic process control");
2571          }
2572        | YYFORK ':' name_of_block block_declaration_clr statement_clr YYJOIN
2573          {
2574              YYTRACE("par_block: YYFORK ':' name_of_block block_declaration_clr statement_clr YYJOIN");
2575              $$ = vl_create_fork_join_stmt($3, $4, $5);
2576              TODO("fork/join : dynamic process control");
2577          }
2578        ;
2579
2580name_of_block
2581        : YYIDE
2582          {
2583              YYTRACE("name_of_block: YYIDE");
2584              $$ = vl_create_id_range(vlStrdup(yyid), NIL(vl_range));
2585          }
2586        ;
2587
2588block_declaration_clr
2589        :
2590          {
2591              YYTRACE("block_declaration_clr:");
2592              $$ = lsCreate();
2593          }
2594        | block_declaration_clr block_declaration
2595          {
2596              lsHandle handle;
2597
2598              YYTRACE("block_declaration_clr: block_declaration_clr block_declaration");
2599              lsNewEnd($1, (lsGeneric)$2, &handle);
2600              $$ = $1;
2601          }
2602        ;
2603
2604block_declaration
2605        : parameter_declaration
2606          {
2607              YYTRACE("block_declaration: parameter_declaration");
2608              $$ = (typestructPtr)$1;
2609          }
2610        | reg_declaration
2611          {
2612              YYTRACE("block_declaration: reg_declaration");
2613              $$ = (typestructPtr)$1;
2614          }
2615        | integer_declaration
2616          {
2617              YYTRACE("block_declaration: integer_declaration");
2618              $$ = (typestructPtr)$1;
2619          }
2620        | real_declaration
2621          {
2622              YYTRACE("block_declaration: real_declaration");
2623              $$ = (typestructPtr)$1;
2624          }
2625        | time_declaration
2626          {
2627              YYTRACE("block_delcaration: time_declaration");
2628              $$ = (typestructPtr)$1;
2629          }
2630        | event_declaration
2631          {
2632              YYTRACE("block_declaration: event_declaration");
2633              $$ = (typestructPtr)$1;
2634          }
2635        ;
2636
2637
2638task_enable
2639        : YYIDE
2640          {
2641              $<idrng>$ = vl_create_id_range(vlStrdup(yyid), NIL(vl_range));
2642          }
2643          ';'
2644          {
2645              YYTRACE("task_enable: YYIDE ';'");
2646              $$ = vl_create_task_enable_stmt(TaskEnableStmt, $<idrng>2, (lsList)0);
2647          }
2648        | YYIDE
2649          {
2650              $<idrng>$ = vl_create_id_range(vlStrdup(yyid), NIL(vl_range));
2651          }
2652         '(' expression_list ')' ';'
2653          {
2654              YYTRACE("task_enable: YYIDE '(' expression_list ')' ';'");
2655              $$ = vl_create_task_enable_stmt(TaskEnableStmt, $<idrng>2, $4);
2656          }
2657        ;
2658
2659system_task_enable
2660        : name_of_system_task ';'
2661          {
2662              YYTRACE("system_task_enable: name_of_system_task ';'");
2663          }
2664        | name_of_system_task '(' expression_list ')' ';'
2665          {
2666              YYTRACE("system_task_enable: name_of_system_task '(' expression_list ')'");
2667          }
2668        ;
2669
2670name_of_system_task
2671        : system_identifier
2672          {
2673              YYTRACE("name_of_system_task: system_identifier");
2674          }
2675        ;
2676
2677
2678
2679specify_block
2680        : YYSPECIFY specify_item_clr YYENDSPECIFY
2681          {
2682              YYTRACE("specify_block: YYSPECIFY specify_item_clr YYENDSPECIFY");
2683              TODO("specify_block: YYSPECIFY specify_item_clr YYENDSPECIFY");
2684          }
2685        ;
2686
2687specify_item_clr
2688        :
2689        | specify_item_clr specify_item
2690        ;
2691
2692specify_item
2693        : specparam_declaration
2694        | path_declaration
2695        | level_sensitive_path_declaration
2696        | edge_sensitive_path_declaration
2697        | system_timing_check
2698        ;
2699
2700specparam_declaration
2701        : YYSPECPARAM assignment_list ';'
2702        ;
2703
2704path_declaration
2705        : path_description '=' path_delay_value ';'
2706        ;
2707
2708
2709
2710path_description
2711        : '(' specify_terminal_descriptor YYLEADTO specify_terminal_descriptor ')'
2712        | '(' path_list YYALLPATH path_list_or_edge_sensitive_path_list ')'
2713        ;
2714
2715path_list
2716        : specify_terminal_descriptor
2717        | path_list ',' specify_terminal_descriptor
2718        ;
2719
2720specify_terminal_descriptor
2721        : YYIDE
2722        | YYIDE '[' expression ']'
2723        | YYIDE '[' expression ';' expression ']'
2724        ;
2725
2726path_list_or_edge_sensitive_path_list
2727        : path_list
2728        | '(' path_list ',' specify_terminal_descriptor
2729              polarity_operator YYCONDITIONAL
2730              expression ')'
2731        ;
2732
2733path_delay_value
2734        : path_delay_expression
2735        | '(' path_delay_expression ',' path_delay_expression ')'
2736        | '(' path_delay_expression ',' path_delay_expression ','
2737              path_delay_expression ')'
2738        | '(' path_delay_expression ',' path_delay_expression ','
2739              path_delay_expression ',' path_delay_expression ','
2740              path_delay_expression ',' path_delay_expression ')'
2741        ;
2742
2743path_delay_expression
2744        : expression
2745          {
2746          }
2747        ;
2748
2749system_timing_check
2750        : YYsysSETUP '(' ')' ';'
2751        ;
2752
2753level_sensitive_path_declaration
2754        : YYIF '(' expression ')'
2755            '(' specify_terminal_descriptor polarity_operator_opt YYLEADTO
2756                spec_terminal_desptr_or_edge_sensitive_spec_terminal_desptr
2757        | YYIF '(' expression ')'
2758            '(' path_list ',' specify_terminal_descriptor
2759                polarity_operator_opt YYALLPATH path_list ')'
2760                path_list '=' path_delay_value ';'
2761        ;
2762
2763spec_terminal_desptr_or_edge_sensitive_spec_terminal_desptr
2764        : specify_terminal_descriptor ')' path_list '=' path_delay_value ';'
2765        | '(' specify_terminal_descriptor polarity_operator YYCONDITIONAL
2766              expression ')' ')' '=' path_delay_value ';'
2767        ;
2768
2769polarity_operator_opt
2770        :
2771        | polarity_operator
2772        ;
2773
2774polarity_operator
2775        : '+'
2776        | '-'
2777        ;
2778
2779edge_sensitive_path_declaration
2780        : '(' specify_terminal_descriptor YYLEADTO
2781            '(' specify_terminal_descriptor polarity_operator YYCONDITIONAL
2782                expression ')' ')' '=' path_delay_value ';'
2783        | '(' edge_identifier specify_terminal_descriptor YYLEADTO
2784            '(' specify_terminal_descriptor polarity_operator YYCONDITIONAL
2785                expression ')' ')' '=' path_delay_value ';'
2786        | '(' edge_identifier specify_terminal_descriptor YYALLPATH
2787            '(' path_list ',' specify_terminal_descriptor
2788                polarity_operator YYCONDITIONAL
2789                expression ')' ')' '=' path_delay_value ';'
2790        | YYIF '(' expression ')'
2791            '(' specify_terminal_descriptor YYALLPATH
2792              '(' path_list ',' specify_terminal_descriptor
2793                  polarity_operator YYCONDITIONAL
2794                  expression ')' ')' '=' path_delay_value ';'
2795        | YYIF '(' expression ')'
2796            '(' edge_identifier specify_terminal_descriptor YYLEADTO
2797              '(' specify_terminal_descriptor polarity_operator YYCONDITIONAL
2798                  expression ')' ')' '=' path_delay_value ';'
2799        | YYIF '(' expression ')'
2800            '(' edge_identifier specify_terminal_descriptor YYALLPATH
2801              '(' path_list ',' specify_terminal_descriptor
2802                  polarity_operator YYCONDITIONAL
2803                  expression ')' ')' '=' path_delay_value ';'
2804        ;
2805
2806edge_identifier
2807        : YYPOSEDGE
2808        | YYNEGEDGE
2809        ;
2810
2811
2812
2813lvalue
2814        : identifier
2815          {
2816              YYTRACE("lvalue: YYIDE");
2817              $$ = vl_create_lval(IDExpr, $1,
2818                                  NIL(vl_range), (lsList)0);
2819          }
2820        | identifier '[' expression ']'
2821          {
2822              YYTRACE("lvalue: YYIDE '[' expression ']'");
2823              $$ = vl_create_lval(BitSelExpr, $1,
2824                                  vl_create_range($3, NIL(vl_expr)),
2825                                  (lsList)0);
2826          }
2827        | identifier '[' expression ':' expression ']'
2828          {
2829              YYTRACE("lvalue: YYIDE'[' expression ':' expression ']'");
2830              $$ = vl_create_lval(PartSelExpr, $1,
2831                                  vl_create_range($3, $5), (lsList)0);
2832          }
2833        | concatenation
2834          {
2835              YYTRACE("lvalue: concatenation");
2836              $$ = vl_create_lval(ConcatExpr, NIL(vl_id_range), NIL(vl_range), $1);
2837          }
2838        ;
2839
2840mintypmax_expression_list
2841        : mintypmax_expression
2842          {
2843              lsHandle handle;
2844
2845              YYTRACE("mintypmax_expression_list: mintypmax_expression");
2846              $$ = lsCreate();
2847              lsNewEnd($$, (lsGeneric)$1, &handle);
2848          }
2849        | mintypmax_expression_list ',' mintypmax_expression
2850          {
2851              lsHandle handle;
2852
2853              YYTRACE("mintypmax_expression_list: mintypmax_expression_list ',' mintypmax_expression");
2854              lsNewEnd($1, (lsGeneric)$3, &handle);
2855              $$ = $1;
2856          }
2857        ;
2858
2859mintypmax_expression
2860        : expression
2861          {
2862              YYTRACE("mintypmax_expression: expression");
2863              $$ = vl_create_expr(MinTypMaxExpr, 0, (double)0.0,
2864                                  $1, NIL(vl_expr), NIL(vl_expr));
2865          }
2866        | expression ':' expression
2867          {
2868              YYTRACE("mintypmax_expression: expression ':' expression");
2869              $$ = vl_create_expr(MinTypMaxExpr, 0, (double)0.0,
2870                                  $1, $3, NIL(vl_expr));
2871          }
2872        | expression ':' expression ':' expression
2873          {
2874              YYTRACE("mintypmax_expression: expression ':' expression ':' expression");
2875              $$ = vl_create_expr(MinTypMaxExpr, 0, (double)0.0,
2876                                  $1, $3, $5);
2877          }
2878        ;
2879
2880expression_list
2881        : expression
2882          {
2883              lsHandle handle;
2884
2885              YYTRACE("expression_list: expression");
2886              $$ = lsCreate();
2887              lsNewEnd($$, (lsGeneric)$1, &handle);
2888          }
2889        | expression_list ',' expression
2890          {
2891              lsHandle handle;
2892
2893              YYTRACE("expression_list: expression_list ',' expression");
2894              $$ = lsCreate();
2895              lsNewEnd($1, (lsGeneric)$3, &handle);
2896              $$ = $1;
2897          }
2898        ;
2899
2900expression
2901        : primary
2902          {
2903              YYTRACE("expression: primary");
2904          }
2905        | '+' primary %prec YYUNARYOPERATOR
2906          {
2907              YYTRACE("expression: '+' primary %prec YYUNARYOPERATOR");
2908              $$ = vl_create_expr(UplusExpr, 0, (double)0.0,
2909                                  $2, NIL(vl_expr), NIL(vl_expr));
2910          }
2911        | '-' primary %prec YYUNARYOPERATOR
2912          {
2913              YYTRACE("expression: '-' primary %prec YYUNARYOPERATOR");
2914              $$ = vl_create_expr(UminusExpr, 0, (double)0.0,
2915                                  $2, NIL(vl_expr), NIL(vl_expr));
2916
2917          }
2918        | '!' primary %prec YYUNARYOPERATOR
2919          {
2920              YYTRACE("expression: '!' primary %prec YYUNARYOPERATOR");
2921              $$ = vl_create_expr(UnotExpr, 0, (double)0.0,
2922                                  $2, NIL(vl_expr), NIL(vl_expr));
2923
2924          }
2925        | '~' primary %prec YYUNARYOPERATOR
2926          {
2927              YYTRACE("expression: '~' primary %prec YYUNARYOPERATOR");
2928              $$ = vl_create_expr(UcomplExpr, 0, (double)0.0,
2929                                  $2, NIL(vl_expr), NIL(vl_expr));
2930          }
2931        | '&' primary %prec YYUNARYOPERATOR
2932          {
2933              YYTRACE("expression: '&' primary %prec YYUNARYOPERATOR");
2934              $$ = vl_create_expr(UandExpr, 0, (double)0.0,
2935                                  $2, NIL(vl_expr), NIL(vl_expr));
2936          }
2937        | '|' primary %prec YYUNARYOPERATOR
2938          {
2939              YYTRACE("expression: '|' primary %prec YYUNARYOPERATOR");
2940              $$ = vl_create_expr(UorExpr, 0, (double)0.0,
2941                                  $2, NIL(vl_expr), NIL(vl_expr));
2942          }
2943        | '^' primary %prec YYUNARYOPERATOR
2944          {
2945              YYTRACE("expression: '^' primary %prec YYUNARYOPERATOR");
2946              $$ = vl_create_expr(UxorExpr, 0, (double)0.0,
2947                                  $2, NIL(vl_expr), NIL(vl_expr));
2948          }
2949        | YYLOGNAND primary %prec YYUNARYOPERATOR
2950          {
2951              YYTRACE("expression: YYLOGNAND primary %prec YYUNARYOPERATOR");
2952              $$ = vl_create_expr(UnandExpr, 0, (double)0.0,
2953                                  $2, NIL(vl_expr), NIL(vl_expr));
2954          }
2955        | YYLOGNOR primary %prec YYUNARYOPERATOR
2956          {
2957              YYTRACE("expression: YYLOGNOR primary %prec YYUNARYOPERATOR");
2958              $$ = vl_create_expr(UnorExpr, 0, (double)0.0,
2959                                  $2, NIL(vl_expr), NIL(vl_expr));
2960          }
2961        | YYLOGXNOR primary %prec YYUNARYOPERATOR
2962          {
2963              YYTRACE("expression: YYLOGXNOR primary %prec YYUNARYOPERATOR");
2964              $$ = vl_create_expr(UxnorExpr, 0, (double)0.0,
2965                                  $2, NIL(vl_expr), NIL(vl_expr));
2966          }
2967        | expression '+' expression
2968          {
2969              YYTRACE("expression: expression '+' expression");
2970              $$ = vl_create_expr(BplusExpr, 0, (double)0.0,
2971                                  $1, $3, NIL(vl_expr));
2972          }
2973        | expression '-' expression
2974          {
2975              YYTRACE("expression: expressio '-' expression");
2976              $$ = vl_create_expr(BminusExpr, 0, (double)0.0,
2977                                  $1, $3, NIL(vl_expr));
2978          }
2979        | expression '*' expression
2980          {
2981              YYTRACE("expression: expression '*' expression");
2982              $$ = vl_create_expr(BtimesExpr, 0, (double)0.0,
2983                                  $1, $3, NIL(vl_expr));
2984          }
2985        | expression '/' expression
2986          {
2987              YYTRACE("expression: expression '/' expression");
2988              $$ = vl_create_expr(BdivExpr, 0, (double)0.0,
2989                                  $1, $3, NIL(vl_expr));
2990          }
2991        | expression '%' expression
2992          {
2993              YYTRACE("expression: expression '%' expression");
2994              $$ = vl_create_expr(BremExpr, 0, (double)0.0,
2995                                  $1, $3, NIL(vl_expr));
2996          }
2997        | expression YYLOGEQUALITY type_action_expr expression
2998          {
2999              YYTRACE("expression: expression YYLOGEQUALITY expression");
3000              $$ = vl_create_expr(Beq2Expr, 0, (double)0.0,
3001                                  $1, $4, NIL(vl_expr));
3002              pop_stack(vl_cur_type_stack, (void **) &aux_st);
3003          }
3004        | expression YYLOGINEQUALITY type_action_expr expression
3005          {
3006              YYTRACE("expression: expression YYLOGINEQUALITY expression");
3007              $$ = vl_create_expr(Bneq2Expr, 0, (double)0.0,
3008                                  $1, $4, NIL(vl_expr));
3009              pop_stack(vl_cur_type_stack, (void **) &aux_st);
3010          }
3011        | expression YYCASEEQUALITY type_action_expr expression
3012          {
3013              YYTRACE("expression: expression YYCASEEQUALITY expression");
3014              $$ = vl_create_expr(Beq3Expr, 0, (double)0.0,
3015                                  $1, $4, NIL(vl_expr));
3016              pop_stack(vl_cur_type_stack, (void **) &aux_st);
3017          }
3018        | expression YYCASEINEQUALITY type_action_expr expression
3019          {
3020              YYTRACE("expression: expression YYCASEINEQUALITY expression");
3021              $$ = vl_create_expr(Bneq3Expr, 0, (double)0.0,
3022                                  $1, $4, NIL(vl_expr));
3023              pop_stack(vl_cur_type_stack, (void **) &aux_st);
3024          }
3025        | expression YYLOGAND expression
3026          {
3027              YYTRACE("expression: expression YYLOGAND expression");
3028              $$ = vl_create_expr(BlandExpr, 0, (double)0.0,
3029                                  $1, $3, NIL(vl_expr));
3030          }
3031        | expression YYLOGOR expression
3032          {
3033              YYTRACE("expression: expression YYLOGOR expression");
3034              $$ = vl_create_expr(BlorExpr, 0, (double)0.0,
3035                                  $1, $3, NIL(vl_expr));
3036          }
3037        | expression '<' expression
3038          {
3039              YYTRACE("expression: expression '<' expression");
3040              $$ = vl_create_expr(BltExpr, 0, (double)0.0,
3041                                  $1, $3, NIL(vl_expr));
3042          }
3043        | expression '>' expression
3044          {
3045              YYTRACE("expression: expression '>' expression");
3046              $$ = vl_create_expr(BgtExpr, 0, (double)0.0,
3047                                  $1, $3, NIL(vl_expr));
3048          }
3049        | expression '&' expression
3050          {
3051              YYTRACE("expression: expression '&' expression");
3052              $$ = vl_create_expr(BandExpr, 0, (double)0.0,
3053                                  $1, $3, NIL(vl_expr));
3054          }
3055        | expression '|' expression
3056          {
3057              YYTRACE("expression: expression '|' expression");
3058              $$ = vl_create_expr(BorExpr, 0, (double)0.0,
3059                                  $1, $3, NIL(vl_expr));
3060          }
3061        | expression '^' expression
3062          {
3063              YYTRACE("expression: expression '^' expression");
3064              $$ = vl_create_expr(BxorExpr, 0, (double)0.0,
3065                                  $1, $3, NIL(vl_expr));
3066          }
3067        | expression YYLEQ expression
3068          {
3069              YYTRACE("expression: expression YYLEQ expression");
3070              $$ = vl_create_expr(BleExpr, 0, (double)0.0,
3071                                  $1, $3, NIL(vl_expr));
3072          }
3073        | expression YYNBASSIGN expression
3074          {
3075              YYTRACE("expression: expression YYLEQ expression");
3076              $$ = vl_create_expr(BleExpr, 0, (double)0.0,
3077                                  $1, $3, NIL(vl_expr));
3078          }
3079        | expression YYGEQ expression
3080          {
3081              YYTRACE("expression: expression YYGEQ expression");
3082              $$ = vl_create_expr(BgeExpr, 0, (double)0.0,
3083                                  $1, $3, NIL(vl_expr));
3084          }
3085        | expression YYLSHIFT expression
3086          {
3087              YYTRACE("expression: expression YYLSHIFT expression");
3088              $$ = vl_create_expr(BlshiftExpr, 0, (double)0.0,
3089                                  $1, $3, NIL(vl_expr));
3090          }
3091        | expression YYRSHIFT expression
3092          {
3093              YYTRACE("expression: expression YYRSHIFT expression");
3094              $$ = vl_create_expr(BrshiftExpr, 0, (double)0.0,
3095                                  $1, $3, NIL(vl_expr));
3096          }
3097        | expression YYLOGXNOR expression
3098          {
3099              YYTRACE("expression: expression YYLOGXNOR expression");
3100              $$ = vl_create_expr(BxnorExpr, 0, (double)0.0,
3101                                  $1, $3, NIL(vl_expr));
3102          }
3103        | expression '?' expression ':' expression
3104          {
3105              YYTRACE("expression: expression '?' expression ':' expression");
3106              $$ = vl_create_expr(TcondExpr, 0, (double)0.0,
3107                                  $1, $3, $5);
3108          }
3109        | YYSTRING
3110          {
3111              YYTRACE("expression: YYSTRING");
3112              $$ = vl_create_expr(StringExpr, 0, (double)0.0,
3113                                  vlStrdup(yytext), NIL(vl_expr), NIL(vl_expr));
3114              TODO("<string> is not supported in generated FSMs");
3115          }
3116        ;
3117
3118primary
3119        : YYINUMBER
3120          {
3121              YYTRACE("primary: YYINUMBER");
3122              if (strchr(yytext, '\'')) {
3123                  $$ = vl_create_expr(BitExpr, 0, (double)0.0,
3124                           (void*)bexp1, (void*)bexp0, (void*)vlStrdup(brep));
3125              } else {
3126                  $$ = vl_create_expr(IntExpr, atoi(yytext), (double)0.0,
3127                                      NIL(vl_expr), NIL(vl_expr), NIL(vl_expr));
3128              }
3129          }
3130        | YYRNUMBER
3131          {
3132              YYTRACE("primary: YYRNUMBER");
3133              $$ = vl_create_expr(RealExpr, 0, atof(yytext),
3134                                  NIL(vl_expr), NIL(vl_expr), NIL(vl_expr));
3135          }
3136        | identifier
3137          {
3138              YYTRACE("primary: identifier");
3139              $$ = vl_create_expr(IDExpr, 0, (double)0.0,
3140                                  $1, NIL(vl_expr), NIL(vl_expr));
3141          }
3142        | identifier '[' expression ']'
3143          {
3144              YYTRACE("primary: identifier '[' expression ']'");
3145              $$ = vl_create_expr(BitSelExpr, 0, (double)0.0,
3146                                  vl_create_id_range($1->name,
3147                                    vl_create_range($3, NIL(vl_expr))),
3148                                  NIL(vl_expr), NIL(vl_expr));
3149          }
3150        | identifier '[' expression ':'  expression ']'
3151          {
3152              YYTRACE("primary: identifier '[' expression ':' expression ']'");
3153              $$ = vl_create_expr(BitSelExpr, 0, (double)0.0,
3154                                  vl_create_id_range($1->name,
3155                                    vl_create_range($3, $5)),
3156                                  NIL(vl_expr), NIL(vl_expr));
3157          }
3158        | concatenation
3159          {
3160              YYTRACE("primary: concatenation");
3161              $$ = vl_create_expr(ConcatExpr, 0, (double)0.0,
3162                                  $1, NIL(vl_expr), NIL(vl_expr));
3163          }
3164        | multiple_concatenation
3165          {
3166              YYTRACE("primary: multiple_concatenatin");
3167              $$ = vl_create_expr(ConcatExpr, 0, (double)0.0,
3168                                  $1->concat, $1->rep, NIL(vl_expr));
3169              vl_chk_free((char*)$1);
3170          }
3171        | function_call
3172          {
3173              YYTRACE("primary: function_call");
3174          }
3175        | '(' mintypmax_expression ')'
3176          {
3177              YYTRACE("primary: '(' mintypmax_expression ')'");
3178              $$ = $2;
3179          }
3180
3181        | YYsysID '(' nondeterminism_list ')'
3182          {
3183              YYTRACE("primary: YYsysID '(' nondeterminism_list ')'");
3184              TODO("System task (\"$sys-task(...)\")");
3185          }
3186        | YYsysND '(' nondeterminism_list ')'
3187          {
3188              $$ = vl_create_expr(NondExpr, 0, (double)0.0,
3189                                  $3, NIL(vl_expr), NIL(vl_expr));
3190              if ($$ == NIL(vl_expr))
3191                  yyerror("unsynchronized nondeterministic wire");
3192          }
3193        ;
3194
3195nondeterminism_list
3196        : event_control
3197          {
3198              YYTRACE("nondeterminism_list : event_control");
3199              $$ = lsCreate();
3200              lsNewEnd($$, (lsGeneric)$1, 0);
3201          }
3202        | expression
3203          {
3204              YYTRACE("nondeterminism_list : expression");
3205              $$ = lsCreate();
3206              lsNewEnd($$, (lsGeneric)$1, 0);
3207          }
3208        | nondeterminism_list ',' event_control
3209          {
3210              YYTRACE("nondeterminism_list : nondeterminism_list ',' event_control");
3211              lsNewEnd($$, (lsGeneric)$3, 0);
3212          }
3213        | nondeterminism_list ',' expression
3214          {
3215              YYTRACE("nondeterminism_list : nondeterminism_list ',' expression");
3216              lsNewEnd($$, (lsGeneric)$3, 0);
3217          }
3218        ;
3219
3220
3221
3222concatenation
3223        : '{' expression_list '}'
3224          {
3225              YYTRACE("concatenation: '{' expression_list '}'");
3226              $$ = $2;
3227          }
3228        ;
3229
3230multiple_concatenation
3231        : '{' expression '{' expression_list '}' '}'
3232            {
3233                YYTRACE("multiple_concatenation: '{' expression '{' expression_list '}' '}'");
3234                $$ = vl_create_mconcat($2,$4);
3235            }
3236        ;
3237
3238function_call
3239        : identifier '(' expression_list ')'
3240          {
3241              YYTRACE("function_call: identifier '(' expression_list ')'");
3242              $$ = vl_create_expr(FuncExpr, 0, (double)0.0,
3243                                  $1, $3, NIL(void));
3244          }
3245
3246        ;
3247
3248system_identifier
3249        : YYsysID
3250        ;
3251
3252
3253
3254identifier
3255        : YYIDE
3256          {
3257              YYTRACE("identifier: YYIDE");
3258              $$ = vl_create_id_range(vlStrdup(yyid), NIL(vl_range));
3259          }
3260        | identifier '.' YYIDE
3261          {
3262              YYTRACE("identifier: identifier '.' YYIDE");
3263              TODO("identifier: identifier '.' YYIDE --> cross hierarchy access");
3264          }
3265        ;
3266
3267delay_opt
3268        :
3269          {
3270              YYTRACE("delay_opt:");
3271              $$ = NIL(vl_delay);
3272          }
3273        | delay
3274          {
3275              YYTRACE("delay_opt: delay");
3276          }
3277        ;
3278
3279delay
3280        : '#' YYINUMBER
3281          {
3282              vl_expr *expr;
3283
3284              YYTRACE("delay: '#' YYINUMBER");
3285              expr = vl_create_expr(IntExpr, atoi(yytext), (double)0.0,
3286                                    NIL(void), NIL(void), NIL(void));
3287              $$ = vl_create_delay(expr, NIL(vl_expr), NIL(vl_expr));
3288          }
3289        | '#' YYRNUMBER
3290          {
3291              vl_expr *expr;
3292
3293              YYTRACE("delay: '#' YYRNUMBER");
3294              expr = vl_create_expr(IntExpr, 0, atof(yytext),
3295                                    NIL(void), NIL(void), NIL(void));
3296              $$ = vl_create_delay(expr, NIL(vl_expr), NIL(vl_expr));
3297          }
3298        | '#' identifier
3299          {
3300              vl_expr *expr;
3301
3302              YYTRACE("delay: '#' identifier");
3303              expr = vl_create_expr(IDExpr, 0, (double)0.0,
3304                                    $2, NIL(void), NIL(void));
3305              $$ = vl_create_delay(expr, NIL(vl_expr), NIL(vl_expr));
3306          }
3307        | '#' '(' mintypmax_expression ')'
3308          {
3309              YYTRACE("delay: '#' '(' mintypmax_expression ')'");
3310              $$ = vl_create_delay($3, NIL(vl_expr), NIL(vl_expr));
3311          }
3312        | '#' '(' mintypmax_expression ',' mintypmax_expression ')'
3313          {
3314              YYTRACE("delay: '#' '(' mintypmax_expression ',' mintypmax_expression ')'");
3315              $$ = vl_create_delay($3, $5, NIL(vl_expr));
3316          }
3317        | '#' '(' mintypmax_expression ',' mintypmax_expression ','
3318                  mintypmax_expression ')'
3319          {
3320              YYTRACE("delay: '#' '(' mintypmax_expression ',' mintypmax_expression ',' mintypmax_expression ')'");
3321              $$ = vl_create_delay($3, $5, $7);
3322          }
3323        ;
3324
3325delay_control
3326        : '#' YYINUMBER
3327          {
3328              vl_expr *expr;
3329
3330              YYTRACE("delay_control: '#' YYINUMBER");
3331              expr = vl_create_expr(IntExpr, atoi(yytext), (double)0.0,
3332                                    NIL(void), NIL(void), NIL(void));
3333              $$ = vl_create_delay(expr, NIL(vl_expr), NIL(vl_expr));
3334              timed_statement = 1;
3335          }
3336        | '#' YYRNUMBER
3337          {
3338              vl_expr *expr;
3339
3340              YYTRACE("delay_control: '#' YYRNUMBER");
3341              expr = vl_create_expr(RealExpr, 0, atof(yytext),
3342                                    NIL(void), NIL(void), NIL(void));
3343              $$ = vl_create_delay(expr, NIL(vl_expr), NIL(vl_expr));
3344              timed_statement = 1;
3345          }
3346        | '#' identifier
3347          {
3348              vl_expr *expr;
3349
3350              YYTRACE("delay_control: '#' identifier");
3351              expr = vl_create_expr(IDExpr, 0, (double)0.0,
3352                                    $2, NIL(void), NIL(void));
3353              $$ = vl_create_delay(expr, NIL(vl_expr), NIL(vl_expr));
3354              timed_statement = 1;
3355          }
3356        | '#' '(' mintypmax_expression_list ')'
3357          {
3358              YYTRACE("delay_control: '#' '(' mintypmax_expression ')'");
3359              $$ = vl_create_delay((vl_expr*)$3, NIL(vl_expr), (vl_expr*)$3);
3360              timed_statement = 1;
3361          }
3362        ;
3363
3364event_control
3365        : '@' identifier
3366          {
3367              vl_exprPtr expr;
3368
3369              YYTRACE("event_control: '@' identifier");
3370              expr = vl_create_expr(IDExpr, 0, (double)0.0,
3371                                    $2, NIL(vl_expr), NIL(vl_expr));
3372              $$ = vl_create_event_expr(EventExpr, expr);
3373              timed_statement = 1;
3374          }
3375        | '@' '(' event_expression ')'
3376          {
3377              YYTRACE("event_control: '@' '(' event_expression ')'");
3378              $$ = $3;
3379              timed_statement = 1;
3380          }
3381        | '@' '(' ored_event_expression ')'
3382          {
3383              YYTRACE("event_control: '@' '(' ored_event_expression ')'");
3384              $$ = $3;
3385              timed_statement = 1;
3386          }
3387        ;
3388
3389
3390event_expression
3391        : expression
3392          {
3393              YYTRACE("event_expression: expression");
3394              $$ = vl_create_event_expr(EventExpr, $1);
3395          }
3396        | YYPOSEDGE expression
3397          {
3398              YYTRACE("event_expression: YYPOSEDGE expression");
3399              $$ = vl_create_event_expr(PosedgeEventExpr, $2);
3400          }
3401        | YYNEGEDGE expression
3402          {
3403              YYTRACE("event_expression: YYNEGEDGE expression");
3404              $$ = vl_create_event_expr(NegedgeEventExpr, $2);
3405          }
3406        | YYEDGE expression
3407          {
3408              YYTRACE("event_expression: YYEDGE expression");
3409              $$ = vl_create_event_expr(EdgeEventExpr, $2);
3410          }
3411        ;
3412
3413ored_event_expression
3414        : event_expression YYOR event_expression
3415          {
3416              lsList event_list;
3417              YYTRACE("ored_event_expression: event_expression YYOR event_expression");
3418              event_list = lsCreate();
3419              lsNewEnd(event_list, (lsGeneric)$1, LS_NH);
3420              lsNewEnd(event_list, (lsGeneric)$3, LS_NH);
3421              $$ = vl_create_event_expr(OrEventExpr, NIL(vl_expr));
3422              $$->list = event_list;
3423          }
3424        | ored_event_expression YYOR event_expression
3425          {
3426              YYTRACE("ored_event_expression: ored_event_expression YYOR event_expression");
3427              lsNewEnd($1->list, (lsGeneric)$3, LS_NH);
3428              $$ = $1;
3429          }
3430        ;
3431
3432%%
3433
3434void yyerror(str)
3435char *str;
3436{
3437    fprintf(stderr, "%s : (line:%d;file:%s) token :'%s', ",
3438            str, yylineno, vl_filename,
3439#ifndef _snake
3440            (yytypetoken[0])?yytypetoken:yytext
3441#else
3442            (yytypetoken[0])?yytypetoken:(char*)yytext
3443#endif
3444);
3445    fprintf(stderr, "yacc token : '%s'\n", yytext);
3446    if (vl_currentModule)
3447        fprintf(stderr, "unexpected token '%s' seen in module '%s'\n",
3448#ifndef _snake
3449                (yytypetoken[0])?yytypetoken:yytext,
3450#else
3451                (yytypetoken[0])?yytypetoken:(char*)yytext,
3452#endif
3453                vl_currentModule->name->name);
3454    exit (1);
3455}
Note: See TracBrowser for help on using the repository browser.