Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Blame
Revision Log

verilog.y @ 69

Last change on this file since 69 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
50	extern vl_descPtr mod_list;
51	extern char yyid[];
52	extern char brep[];
53	extern int bexp0, bexp1;
54	extern char last_macro[];
55	extern st_table *macros;
56	extern int compatibleChecking;
57	extern char yytypetoken[];
58	extern int instantiateAll;
59
60	int YYTrace=0;
61
62	char *vl_filename = "<stdin>";
63	struct vl_desc *vl_description = NIL(struct vl_desc);
64	struct vl_module *vl_currentModule=NIL(vl_module);
65	struct vl_primitive *vl_currentPrimitive=NIL(vl_primitive);
66	struct vl_function *vl_currentFunction=NIL(vl_function);
67	lsList vl_module_stack;
68	lsList vl_cur_type_stack;
69	st_table *aux_st=NIL(st_table);
70	char modName[MAXSTRLEN];
71	char *cp;
72	short eventType;
73	int enum_val=0;
74	int reserve_type_name=1;
75	int task_mode=0;
76	int timed_statement = 0;
77	static int c_assign=0;
78
79	EXTERN 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
378	source_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
392	description
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
407	type_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
417	module
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
454	port_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
467	port_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
486	port
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
503	port_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
515	port_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
531	port_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
550	port_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
562	port_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
580	module_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
622	module_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
720	primitive
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
746	primitive_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
765	primitive_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
783	table_definition
784	: YYTABLE table_entries YYENDTABLE
785	{
786	YYTRACE("table_definition: YYTABLE table_entries YYENDTABLE");
787	$$ = $2;
788	}
789	;
790
791	table_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
804	combinational_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
819	combinational_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
827	sequential_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
842	sequential_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
850	input_list
851	: level_symbol_or_edge_eclr
852	{
853	YYTRACE("input_list: level_symbol_or_edge_eclr");
854	}
855	;
856
857	level_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
872	level_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
883	edge
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
911	state
912	: level_symbol
913	{
914	YYTRACE("state: level_symbol");
915	}
916	;
917
918	next_state
919	: output_symbol
920	{
921	YYTRACE("next_state: output_symbol");
922	}
923	\| '-'
924	{
925	YYTRACE("next_state: '_'");
926	$$ = PrimM;
927	}
928	;
929
930	output_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
953	level_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
991	edge_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
1039	task
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
1054	function
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
1131	range_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
1144	range_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
1162	tf_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
1178	tf_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
1197	tf_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
1245	type_name
1246	: YYIDE
1247	{
1248	YYTRACE("type_name: YYIDE");
1249	$$ = vlStrdup(yyid);
1250	}
1251	;
1252
1253	type_specifier
1254	: enum_specifier
1255	{
1256	YYTRACE("type_specifier: enum_specifier ';'");
1257	$$ = vl_create_type_specifier(EnumType, $1);
1258	}
1259	;
1260
1261	enum_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
1274	enum_name
1275	: YYIDE
1276	{
1277	YYTRACE("enum_name: YYIDE");
1278	$$ = vlStrdup(yyid);
1279	}
1280	;
1281
1282	enum_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
1295	enumerator_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
1309	enumerator
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
1325	type_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
1343	parameter_declaration
1344	: YYPARAMETER assignment_list ';'
1345	{
1346	YYTRACE("parameter_declaration: YYPARAMETER assignment_list ';'");
1347	$$ = vl_create_paramdecl(ParamDecl, $2);
1348	}
1349	;
1350
1351	input_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
1359	output_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
1367	inout_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
1375	net_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
1397	nettype
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
1456	expandrange_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
1469	expandrange
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
1486	reg_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
1499	time_declaration
1500	: YYTIME register_variable_list ';'
1501	{
1502	YYTRACE("time_declaration: YYTIME register_variable_list ';'");
1503	$$ = vl_create_basicdecl(TimeDecl, $2);
1504	}
1505	;
1506
1507	integer_declaration
1508	: YYINTEGER register_variable_list ';'
1509	{
1510	YYTRACE("integer_declaration: YYINTEGER register_variable_list ';'");
1511	$$ = vl_create_basicdecl(IntDecl, $2);
1512	}
1513	;
1514
1515	real_declaration
1516	: YYREAL variable_list ';'
1517	{
1518	YYTRACE("real_declaration: YYREAL variable_list ';'");
1519	$$ = vl_create_basicdecl(RealDecl, $2);
1520	}
1521	;
1522
1523	event_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
1531	continuous_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
1542	parameter_override
1543	: YYDEFPARAM assignment_list ';'
1544	{
1545	YYTRACE("parameter_override: YYDEFPARAM assign_list ';'");
1546	$$ = vl_create_paramdecl(DefparamDecl, $2);
1547	}
1548	;
1549
1550	variable_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
1569	register_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
1588	register_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
1608	name_of_register
1609	: YYIDE
1610	{
1611	YYTRACE("name_of_register: YYIDE");
1612	$$ = vlStrdup(yyid);
1613	}
1614	;
1615
1616	name_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
1635	name_of_event
1636	: YYIDE
1637	{
1638	YYTRACE("name_of_event: YYIDE");
1639	$$ = vl_create_id_range(vlStrdup(yyid), NIL(vl_range));
1640	}
1641	;
1642
1643	charge_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
1655	charge_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
1673	drive_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
1686	drive_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
1699	strength0
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
1727	strength1
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
1755	range_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
1768	range
1769	: '[' expression ':' expression ']'
1770	{
1771	YYTRACE("range: '[' expression ':' expression ']'");
1772	$$ = vl_create_range($2, $4);
1773	}
1774	;
1775
1776	assignment_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
1797	gate_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
1815	drive_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
1831	drive_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
1847	gatetype
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
1987	gate_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
2006	gate_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
2019	name_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
2027	terminal_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
2046	terminal
2047	: expression
2048	{
2049	YYTRACE("terminal: expression");
2050	}
2051	;
2052
2053
2054
2055	module_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
2074	name_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
2082	module_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
2098	module_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
2112	delay_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
2147	module_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
2167	module_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
2180	module_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
2191	module_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
2210	named_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
2229	module_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
2243	named_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
2253	initial_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
2263	always_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
2272	statement_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
2288	statement_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
2305	statement
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
2440	assignment
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
2469	type_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
2490	type_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
2515	case_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
2534	case_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
2552	seq_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
2565	par_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
2580	name_of_block
2581	: YYIDE
2582	{
2583	YYTRACE("name_of_block: YYIDE");
2584	$$ = vl_create_id_range(vlStrdup(yyid), NIL(vl_range));
2585	}
2586	;
2587
2588	block_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
2604	block_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
2638	task_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
2659	system_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
2670	name_of_system_task
2671	: system_identifier
2672	{
2673	YYTRACE("name_of_system_task: system_identifier");
2674	}
2675	;
2676
2677
2678
2679	specify_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
2687	specify_item_clr
2688	:
2689	\| specify_item_clr specify_item
2690	;
2691
2692	specify_item
2693	: specparam_declaration
2694	\| path_declaration
2695	\| level_sensitive_path_declaration
2696	\| edge_sensitive_path_declaration
2697	\| system_timing_check
2698	;
2699
2700	specparam_declaration
2701	: YYSPECPARAM assignment_list ';'
2702	;
2703
2704	path_declaration
2705	: path_description '=' path_delay_value ';'
2706	;
2707
2708
2709
2710	path_description
2711	: '(' specify_terminal_descriptor YYLEADTO specify_terminal_descriptor ')'
2712	\| '(' path_list YYALLPATH path_list_or_edge_sensitive_path_list ')'
2713	;
2714
2715	path_list
2716	: specify_terminal_descriptor
2717	\| path_list ',' specify_terminal_descriptor
2718	;
2719
2720	specify_terminal_descriptor
2721	: YYIDE
2722	\| YYIDE '[' expression ']'
2723	\| YYIDE '[' expression ';' expression ']'
2724	;
2725
2726	path_list_or_edge_sensitive_path_list
2727	: path_list
2728	\| '(' path_list ',' specify_terminal_descriptor
2729	polarity_operator YYCONDITIONAL
2730	expression ')'
2731	;
2732
2733	path_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
2743	path_delay_expression
2744	: expression
2745	{
2746	}
2747	;
2748
2749	system_timing_check
2750	: YYsysSETUP '(' ')' ';'
2751	;
2752
2753	level_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
2763	spec_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
2769	polarity_operator_opt
2770	:
2771	\| polarity_operator
2772	;
2773
2774	polarity_operator
2775	: '+'
2776	\| '-'
2777	;
2778
2779	edge_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
2806	edge_identifier
2807	: YYPOSEDGE
2808	\| YYNEGEDGE
2809	;
2810
2811
2812
2813	lvalue
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
2840	mintypmax_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
2859	mintypmax_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
2880	expression_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
2900	expression
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
3118	primary
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
3195	nondeterminism_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
3222	concatenation
3223	: '{' expression_list '}'
3224	{
3225	YYTRACE("concatenation: '{' expression_list '}'");
3226	$$ = $2;
3227	}
3228	;
3229
3230	multiple_concatenation
3231	: '{' expression '{' expression_list '}' '}'
3232	{
3233	YYTRACE("multiple_concatenation: '{' expression '{' expression_list '}' '}'");
3234	$$ = vl_create_mconcat($2,$4);
3235	}
3236	;
3237
3238	function_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
3248	system_identifier
3249	: YYsysID
3250	;
3251
3252
3253
3254	identifier
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
3267	delay_opt
3268	:
3269	{
3270	YYTRACE("delay_opt:");
3271	$$ = NIL(vl_delay);
3272	}
3273	\| delay
3274	{
3275	YYTRACE("delay_opt: delay");
3276	}
3277	;
3278
3279	delay
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
3325	delay_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
3364	event_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
3390	event_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
3413	ored_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
3434	void yyerror(str)
3435	char *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.

Download in other formats:

Original Format