e7b86cf3ce8392d9f0bfdf1f8effe73a967e458a
[sv2nmigen.git] / parse.py
1 # %{
2 # /*
3 # * Copyright (c) 1998-2017 Stephen Williams (steve@icarus.com)
4 # * Copyright CERN 2012-2013 / Stephen Williams (steve@icarus.com)
5 # *
6 # * This source code is free software; you can redistribute it
7 # * and/or modify it in source code form under the terms of the GNU
8 # * General Public License as published by the Free Software
9 # * Foundation; either version 2 of the License, or (at your option)
10 # * any later version.
11 # *
12 # * This program is distributed in the hope that it will be useful,
13 # * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 # * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 # * GNU General Public License for more details.
16 # *
17 # * You should have received a copy of the GNU General Public License
18 # * along with this program; if not, write to the Free Software
19 # * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
20 # */
21 #
22 # # include "config.h"
23 #
24 # # include "parse_misc.h"
25 # # include "compiler.h"
26 # # include "pform.h"
27 # # include "Statement.h"
28 # # include "PSpec.h"
29 # # include <stack>
30 # # include <cstring>
31 # # include <sstream>
32 #
33 # class PSpecPath;
34 #
35 # extern void lex_end_table();
36 #
37 # static list<pform_range_t>* param_active_range = 0;
38 # static bool param_active_signed = false;
39 # static ivl_variable_type_t param_active_type = IVL_VT_LOGIC;
40 #
41 # /* Port declaration lists use this structure for context. */
42 # static struct {
43 # NetNet::Type port_net_type;
44 # NetNet::PortType port_type;
45 # data_type_t* data_type;
46 # } port_declaration_context = {NetNet::NONE, NetNet::NOT_A_PORT, 0};
47 #
48 # /* Modport port declaration lists use this structure for context. */
49 # enum modport_port_type_t { MP_NONE, MP_SIMPLE, MP_TF, MP_CLOCKING };
50 # static struct {
51 # modport_port_type_t type;
52 # union {
53 # NetNet::PortType direction;
54 # bool is_import;
55 # };
56 # } last_modport_port = { MP_NONE, {NetNet::NOT_A_PORT}};
57 #
58 # /* The task and function rules need to briefly hold the pointer to the
59 # task/function that is currently in progress. */
60 # static PTask* current_task = 0;
61 # static PFunction* current_function = 0;
62 # static stack<PBlock*> current_block_stack;
63 #
64 # /* The variable declaration rules need to know if a lifetime has been
65 # specified. */
66 # static LexicalScope::lifetime_t var_lifetime;
67 #
68 # static pform_name_t* pform_create_this(void)
69 # {
70 # name_component_t name (perm_string::literal("@"));
71 # pform_name_t*res = new pform_name_t;
72 # res->push_back(name);
73 # return res;
74 # }
75 #
76 # static pform_name_t* pform_create_super(void)
77 # {
78 # name_component_t name (perm_string::literal("#"));
79 # pform_name_t*res = new pform_name_t;
80 # res->push_back(name);
81 # return res;
82 # }
83 #
84 # /* This is used to keep track of the extra arguments after the notifier
85 # * in the $setuphold and $recrem timing checks. This allows us to print
86 # * a warning message that the delayed signals will not be created. We
87 # * need to do this since not driving these signals creates real
88 # * simulation issues. */
89 # static unsigned args_after_notifier;
90 #
91 # /* The rules sometimes push attributes into a global context where
92 # sub-rules may grab them. This makes parser rules a little easier to
93 # write in some cases. */
94 # static list<named_pexpr_t>*attributes_in_context = 0;
95 #
96 # /* Later version of bison (including 1.35) will not compile in stack
97 # extension if the output is compiled with C++ and either the YYSTYPE
98 # or YYLTYPE are provided by the source code. However, I can get the
99 # old behavior back by defining these symbols. */
100 # # define YYSTYPE_IS_TRIVIAL 1
101 # # define YYLTYPE_IS_TRIVIAL 1
102 #
103 # /* Recent version of bison expect that the user supply a
104 # YYLLOC_DEFAULT macro that makes up a yylloc value from existing
105 # values. I need to supply an explicit version to account for the
106 # text field, that otherwise won't be copied.
107 #
108 # The YYLLOC_DEFAULT blends the file range for the tokens of Rhs
109 # rule, which has N tokens.
110 # */
111 # # define YYLLOC_DEFAULT(Current, Rhs, N) do { \
112 # if (N) { \
113 # (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
114 # (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
115 # (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
116 # (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
117 # (Current).text = YYRHSLOC (Rhs, 1).text; \
118 # } else { \
119 # (Current).first_line = YYRHSLOC (Rhs, 0).last_line; \
120 # (Current).first_column = YYRHSLOC (Rhs, 0).last_column; \
121 # (Current).last_line = YYRHSLOC (Rhs, 0).last_line; \
122 # (Current).last_column = YYRHSLOC (Rhs, 0).last_column; \
123 # (Current).text = YYRHSLOC (Rhs, 0).text; \
124 # } \
125 # } while (0)
126 #
127 # /*
128 # * These are some common strength pairs that are used as defaults when
129 # * the user is not otherwise specific.
130 # */
131 # static const struct str_pair_t pull_strength = { IVL_DR_PULL, IVL_DR_PULL };
132 # static const struct str_pair_t str_strength = { IVL_DR_STRONG, IVL_DR_STRONG };
133 #
134 # static list<pform_port_t>* make_port_list(char*id, list<pform_range_t>*udims, PExpr*expr)
135 # {
136 # list<pform_port_t>*tmp = new list<pform_port_t>;
137 # tmp->push_back(pform_port_t(lex_strings.make(id), udims, expr));
138 # delete[]id;
139 # return tmp;
140 # }
141 # static list<pform_port_t>* make_port_list(list<pform_port_t>*tmp,
142 # char*id, list<pform_range_t>*udims, PExpr*expr)
143 # {
144 # tmp->push_back(pform_port_t(lex_strings.make(id), udims, expr));
145 # delete[]id;
146 # return tmp;
147 # }
148 #
149 # list<pform_range_t>* make_range_from_width(uint64_t wid)
150 # {
151 # pform_range_t range;
152 # range.first = new PENumber(new verinum(wid-1, integer_width));
153 # range.second = new PENumber(new verinum((uint64_t)0, integer_width));
154 #
155 # list<pform_range_t>*rlist = new list<pform_range_t>;
156 # rlist->push_back(range);
157 # return rlist;
158 # }
159 #
160 # static list<perm_string>* list_from_identifier(char*id)
161 # {
162 # list<perm_string>*tmp = new list<perm_string>;
163 # tmp->push_back(lex_strings.make(id));
164 # delete[]id;
165 # return tmp;
166 # }
167 #
168 # static list<perm_string>* list_from_identifier(list<perm_string>*tmp, char*id)
169 # {
170 # tmp->push_back(lex_strings.make(id));
171 # delete[]id;
172 # return tmp;
173 # }
174 #
175 # list<pform_range_t>* copy_range(list<pform_range_t>* orig)
176 # {
177 # list<pform_range_t>*copy = 0;
178 #
179 # if (orig)
180 # copy = new list<pform_range_t> (*orig);
181 #
182 # return copy;
183 # }
184 #
185 # template <class T> void append(vector<T>&out, const vector<T>&in)
186 # {
187 # for (size_t idx = 0 ; idx < in.size() ; idx += 1)
188 # out.push_back(in[idx]);
189 # }
190 #
191 # /*
192 # * Look at the list and pull null pointers off the end.
193 # */
194 # static void strip_tail_items(list<PExpr*>*lst)
195 # {
196 # while (! lst->empty()) {
197 # if (lst->back() != 0)
198 # return;
199 # lst->pop_back();
200 # }
201 # }
202 #
203 # /*
204 # * This is a shorthand for making a PECallFunction that takes a single
205 # * arg. This is used by some of the code that detects built-ins.
206 # */
207 # static PECallFunction*make_call_function(perm_string tn, PExpr*arg)
208 # {
209 # vector<PExpr*> parms(1);
210 # parms[0] = arg;
211 # PECallFunction*tmp = new PECallFunction(tn, parms);
212 # return tmp;
213 # }
214 #
215 # static PECallFunction*make_call_function(perm_string tn, PExpr*arg1, PExpr*arg2)
216 # {
217 # vector<PExpr*> parms(2);
218 # parms[0] = arg1;
219 # parms[1] = arg2;
220 # PECallFunction*tmp = new PECallFunction(tn, parms);
221 # return tmp;
222 # }
223 #
224 # static list<named_pexpr_t>* make_named_numbers(perm_string name, long first, long last, PExpr*val =0)
225 # {
226 # list<named_pexpr_t>*lst = new list<named_pexpr_t>;
227 # named_pexpr_t tmp;
228 # // We are counting up.
229 # if (first <= last) {
230 # for (long idx = first ; idx <= last ; idx += 1) {
231 # ostringstream buf;
232 # buf << name.str() << idx << ends;
233 # tmp.name = lex_strings.make(buf.str());
234 # tmp.parm = val;
235 # val = 0;
236 # lst->push_back(tmp);
237 # }
238 # // We are counting down.
239 # } else {
240 # for (long idx = first ; idx >= last ; idx -= 1) {
241 # ostringstream buf;
242 # buf << name.str() << idx << ends;
243 # tmp.name = lex_strings.make(buf.str());
244 # tmp.parm = val;
245 # val = 0;
246 # lst->push_back(tmp);
247 # }
248 # }
249 # return lst;
250 # }
251 #
252 # static list<named_pexpr_t>* make_named_number(perm_string name, PExpr*val =0)
253 # {
254 # list<named_pexpr_t>*lst = new list<named_pexpr_t>;
255 # named_pexpr_t tmp;
256 # tmp.name = name;
257 # tmp.parm = val;
258 # lst->push_back(tmp);
259 # return lst;
260 # }
261 #
262 # static long check_enum_seq_value(const YYLTYPE&loc, verinum *arg, bool zero_ok)
263 # {
264 # long value = 1;
265 # // We can never have an undefined value in an enumeration name
266 # // declaration sequence.
267 # if (! arg->is_defined()) {
268 # yyerror(loc, "error: undefined value used in enum name sequence.");
269 # // We can never have a negative value in an enumeration name
270 # // declaration sequence.
271 # } else if (arg->is_negative()) {
272 # yyerror(loc, "error: negative value used in enum name sequence.");
273 # } else {
274 # value = arg->as_ulong();
275 # // We cannot have a zero enumeration name declaration count.
276 # if (! zero_ok && (value == 0)) {
277 # yyerror(loc, "error: zero count used in enum name sequence.");
278 # value = 1;
279 # }
280 # }
281 # return value;
282 # }
283 #
284 # static void current_task_set_statement(const YYLTYPE&loc, vector<Statement*>*s)
285 # {
286 # if (s == 0) {
287 # /* if the statement list is null, then the parser
288 # detected the case that there are no statements in the
289 # task. If this is SystemVerilog, handle it as an
290 # an empty block. */
291 # if (!gn_system_verilog()) {
292 # yyerror(loc, "error: Support for empty tasks requires SystemVerilog.");
293 # }
294 # PBlock*tmp = new PBlock(PBlock::BL_SEQ);
295 # FILE_NAME(tmp, loc);
296 # current_task->set_statement(tmp);
297 # return;
298 # }
299 # assert(s);
300 #
301 # /* An empty vector represents one or more null statements. Handle
302 # this as a simple null statement. */
303 # if (s->empty())
304 # return;
305 #
306 # /* A vector of 1 is handled as a simple statement. */
307 # if (s->size() == 1) {
308 # current_task->set_statement((*s)[0]);
309 # return;
310 # }
311 #
312 # if (!gn_system_verilog()) {
313 # yyerror(loc, "error: Task body with multiple statements requires SystemVerilog.");
314 # }
315 #
316 # PBlock*tmp = new PBlock(PBlock::BL_SEQ);
317 # FILE_NAME(tmp, loc);
318 # tmp->set_statement(*s);
319 # current_task->set_statement(tmp);
320 # }
321 #
322 # static void current_function_set_statement(const YYLTYPE&loc, vector<Statement*>*s)
323 # {
324 # if (s == 0) {
325 # /* if the statement list is null, then the parser
326 # detected the case that there are no statements in the
327 # task. If this is SystemVerilog, handle it as an
328 # an empty block. */
329 # if (!gn_system_verilog()) {
330 # yyerror(loc, "error: Support for empty functions requires SystemVerilog.");
331 # }
332 # PBlock*tmp = new PBlock(PBlock::BL_SEQ);
333 # FILE_NAME(tmp, loc);
334 # current_function->set_statement(tmp);
335 # return;
336 # }
337 # assert(s);
338 #
339 # /* An empty vector represents one or more null statements. Handle
340 # this as a simple null statement. */
341 # if (s->empty())
342 # return;
343 #
344 # /* A vector of 1 is handled as a simple statement. */
345 # if (s->size() == 1) {
346 # current_function->set_statement((*s)[0]);
347 # return;
348 # }
349 #
350 # if (!gn_system_verilog()) {
351 # yyerror(loc, "error: Function body with multiple statements requires SystemVerilog.");
352 # }
353 #
354 # PBlock*tmp = new PBlock(PBlock::BL_SEQ);
355 # FILE_NAME(tmp, loc);
356 # tmp->set_statement(*s);
357 # current_function->set_statement(tmp);
358 # }
359 #
360 # %}
361 ('tokens = ', "['IDENTIFIER', 'SYSTEM_IDENTIFIER', 'STRING', 'TIME_LITERAL', 'TYPE_IDENTIFIER', 'PACKAGE_IDENTIFIER', 'DISCIPLINE_IDENTIFIER', 'PATHPULSE_IDENTIFIER', 'BASED_NUMBER', 'DEC_NUMBER', 'UNBASED_NUMBER', 'REALTIME', 'K_PLUS_EQ', 'K_MINUS_EQ', 'K_INCR', 'K_DECR', 'K_LE', 'K_GE', 'K_EG', 'K_EQ', 'K_NE', 'K_CEQ', 'K_CNE', 'K_WEQ', 'K_WNE', 'K_LP', 'K_LS', 'K_RS', 'K_RSS', 'K_SG', 'K_CONTRIBUTE', 'K_PO_POS', 'K_PO_NEG', 'K_POW', 'K_PSTAR', 'K_STARP', 'K_DOTSTAR', 'K_LOR', 'K_LAND', 'K_NAND', 'K_NOR', 'K_NXOR', 'K_TRIGGER', 'K_SCOPE_RES', 'K_edge_descriptor', 'K_always', 'K_and', 'K_assign', 'K_begin', 'K_buf', 'K_bufif0', 'K_bufif1', 'K_case', 'K_casex', 'K_casez', 'K_cmos', 'K_deassign', 'K_default', 'K_defparam', 'K_disable', 'K_edge', 'K_else', 'K_end', 'K_endcase', 'K_endfunction', 'K_endmodule', 'K_endprimitive', 'K_endspecify', 'K_endtable', 'K_endtask', 'K_event', 'K_for', 'K_force', 'K_forever', 'K_fork', 'K_function', 'K_highz0', 'K_highz1', 'K_if', 'K_ifnone', 'K_initial', 'K_inout', 'K_input', 'K_integer', 'K_join', 'K_large', 'K_macromodule', 'K_medium', 'K_module', 'K_nand', 'K_negedge', 'K_nmos', 'K_nor', 'K_not', 'K_notif0', 'K_notif1', 'K_or', 'K_output', 'K_parameter', 'K_pmos', 'K_posedge', 'K_primitive', 'K_pull0', 'K_pull1', 'K_pulldown', 'K_pullup', 'K_rcmos', 'K_real', 'K_realtime', 'K_reg', 'K_release', 'K_repeat', 'K_rnmos', 'K_rpmos', 'K_rtran', 'K_rtranif0', 'K_rtranif1', 'K_scalared', 'K_small', 'K_specify', 'K_specparam', 'K_strong0', 'K_strong1', 'K_supply0', 'K_supply1', 'K_table', 'K_task', 'K_time', 'K_tran', 'K_tranif0', 'K_tranif1', 'K_tri', 'K_tri0', 'K_tri1', 'K_triand', 'K_trior', 'K_trireg', 'K_vectored', 'K_wait', 'K_wand', 'K_weak0', 'K_weak1', 'K_while', 'K_wire', 'K_wor', 'K_xnor', 'K_xor', 'K_Shold', 'K_Snochange', 'K_Speriod', 'K_Srecovery', 'K_Ssetup', 'K_Ssetuphold', 'K_Sskew', 'K_Swidth', 'KK_attribute', 'K_bool', 'K_logic', 'K_automatic', 'K_endgenerate', 'K_generate', 'K_genvar', 'K_localparam', 'K_noshowcancelled', 'K_pulsestyle_onevent', 'K_pulsestyle_ondetect', 'K_showcancelled', 'K_signed', 'K_unsigned', 'K_Sfullskew', 'K_Srecrem', 'K_Sremoval', 'K_Stimeskew', 'K_cell', 'K_config', 'K_design', 'K_endconfig', 'K_incdir', 'K_include', 'K_instance', 'K_liblist', 'K_library', 'K_use', 'K_wone', 'K_uwire', 'K_alias', 'K_always_comb', 'K_always_ff', 'K_always_latch', 'K_assert', 'K_assume', 'K_before', 'K_bind', 'K_bins', 'K_binsof', 'K_bit', 'K_break', 'K_byte', 'K_chandle', 'K_class', 'K_clocking', 'K_const', 'K_constraint', 'K_context', 'K_continue', 'K_cover', 'K_covergroup', 'K_coverpoint', 'K_cross', 'K_dist', 'K_do', 'K_endclass', 'K_endclocking', 'K_endgroup', 'K_endinterface', 'K_endpackage', 'K_endprogram', 'K_endproperty', 'K_endsequence', 'K_enum', 'K_expect', 'K_export', 'K_extends', 'K_extern', 'K_final', 'K_first_match', 'K_foreach', 'K_forkjoin', 'K_iff', 'K_ignore_bins', 'K_illegal_bins', 'K_import', 'K_inside', 'K_int', 'K_interface', 'K_intersect', 'K_join_any', 'K_join_none', 'K_local', 'K_longint', 'K_matches', 'K_modport', 'K_new', 'K_null', 'K_package', 'K_packed', 'K_priority', 'K_program', 'K_property', 'K_protected', 'K_pure', 'K_rand', 'K_randc', 'K_randcase', 'K_randsequence', 'K_ref', 'K_return', 'K_sequence', 'K_shortint', 'K_shortreal', 'K_solve', 'K_static', 'K_string', 'K_struct', 'K_super', 'K_tagged', 'K_this', 'K_throughout', 'K_timeprecision', 'K_timeunit', 'K_type', 'K_typedef', 'K_union', 'K_unique', 'K_var', 'K_virtual', 'K_void', 'K_wait_order', 'K_wildcard', 'K_with', 'K_within', 'K_accept_on', 'K_checker', 'K_endchecker', 'K_eventually', 'K_global', 'K_implies', 'K_let', 'K_nexttime', 'K_reject_on', 'K_restrict', 'K_s_always', 'K_s_eventually', 'K_s_nexttime', 'K_s_until', 'K_s_until_with', 'K_strong', 'K_sync_accept_on', 'K_sync_reject_on', 'K_unique0', 'K_until', 'K_until_with', 'K_untyped', 'K_weak', 'K_implements', 'K_interconnect', 'K_nettype', 'K_soft', 'K_above', 'K_abs', 'K_absdelay', 'K_abstol', 'K_access', 'K_acos', 'K_acosh', 'K_ac_stim', 'K_aliasparam', 'K_analog', 'K_analysis', 'K_asin', 'K_asinh', 'K_atan', 'K_atan2', 'K_atanh', 'K_branch', 'K_ceil', 'K_connect', 'K_connectmodule', 'K_connectrules', 'K_continuous', 'K_cos', 'K_cosh', 'K_ddt', 'K_ddt_nature', 'K_ddx', 'K_discipline', 'K_discrete', 'K_domain', 'K_driver_update', 'K_endconnectrules', 'K_enddiscipline', 'K_endnature', 'K_endparamset', 'K_exclude', 'K_exp', 'K_final_step', 'K_flicker_noise', 'K_floor', 'K_flow', 'K_from', 'K_ground', 'K_hypot', 'K_idt', 'K_idtmod', 'K_idt_nature', 'K_inf', 'K_initial_step', 'K_laplace_nd', 'K_laplace_np', 'K_laplace_zd', 'K_laplace_zp', 'K_last_crossing', 'K_limexp', 'K_ln', 'K_log', 'K_max', 'K_merged', 'K_min', 'K_nature', 'K_net_resolution', 'K_noise_table', 'K_paramset', 'K_potential', 'K_pow', 'K_resolveto', 'K_sin', 'K_sinh', 'K_slew', 'K_split', 'K_sqrt', 'K_tan', 'K_tanh', 'K_timer', 'K_transition', 'K_units', 'K_white_noise', 'K_wreal', 'K_zi_nd', 'K_zi_np', 'K_zi_zd', 'K_zi_zp', 'K_TAND', 'K_PLUS_EQ', 'K_MINUS_EQ', 'K_MUL_EQ', 'K_DIV_EQ', 'K_MOD_EQ', 'K_AND_EQ', 'K_OR_EQ', 'K_XOR_EQ', 'K_LS_EQ', 'K_RS_EQ', 'K_RSS_EQ', 'K_inside', 'K_LOR', 'K_LAND', 'K_NXOR', 'K_NOR', 'K_NAND', 'K_EQ', 'K_NE', 'K_CEQ', 'K_CNE', 'K_WEQ', 'K_WNE', 'K_GE', 'K_LE', 'K_LS', 'K_RS', 'K_RSS', 'K_POW', 'UNARY_PREC', 'less_than_K_else', 'K_else', 'K_exclude', 'no_timeunits_declaration', 'one_timeunits_declaration', 'K_timeunit', 'K_timeprecision']")
362 ()
363 ('precedence = ', '[(\'right\', \'K_PLUS_EQ\', \'K_MINUS_EQ\', \'K_MUL_EQ\', \'K_DIV_EQ\', \'K_MOD_EQ\', \'K_AND_EQ\', \'K_OR_EQ\'), (\'right\', \'K_XOR_EQ\', \'K_LS_EQ\', \'K_RS_EQ\', \'K_RSS_EQ\'), (\'right\', "\'?\'", "\':\'", \'K_inside\'), (\'left\', \'K_LOR\'), (\'left\', \'K_LAND\'), (\'left\', "\'|\'"), (\'left\', "\'^\'", \'K_NXOR\', \'K_NOR\'), (\'left\', "\'&\'", \'K_NAND\'), (\'left\', \'K_EQ\', \'K_NE\', \'K_CEQ\', \'K_CNE\', \'K_WEQ\', \'K_WNE\'), (\'left\', \'K_GE\', \'K_LE\', "\'<\'", "\'>\'"), (\'left\', \'K_LS\', \'K_RS\', \'K_RSS\'), (\'left\', "\'+\'", "\'-\'"), (\'left\', "\'*\'", "\'/\'", "\'%\'"), (\'left\', \'K_POW\'), (\'left\', \'UNARY_PREC\'), (\'nonassoc\', \'less_than_K_else\'), (\'nonassoc\', \'K_else\'), (\'nonassoc\', "\'(\'"), (\'nonassoc\', \'K_exclude\'), (\'nonassoc\', \'no_timeunits_declaration\'), (\'nonassoc\', \'one_timeunits_declaration\'), (\'nonassoc\', \'K_timeunit\', \'K_timeprecision\')]')
364 ()
365 # -------------- RULES ----------------
366 ()
367 def p_source_text_1(p):
368 '''source_text : timeunits_declaration_opt _embed0_source_text description_list '''
369 print(p)
370 ()
371 def p_source_text_2(p):
372 '''source_text : '''
373 print(p)
374 ()
375 def p__embed0_source_text(p):
376 '''_embed0_source_text : '''
377 # { pform_set_scope_timescale(yyloc); }
378 ()
379 def p_assertion_item_1(p):
380 '''assertion_item : concurrent_assertion_item '''
381 print(p)
382 ()
383 def p_assignment_pattern_1(p):
384 '''assignment_pattern : K_LP expression_list_proper '}' '''
385 print(p)
386 # { PEAssignPattern*tmp = new PEAssignPattern(*$2);
387 # FILE_NAME(tmp, @1);
388 # delete $2;
389 # $$ = tmp;
390 # }
391 ()
392 def p_assignment_pattern_2(p):
393 '''assignment_pattern : K_LP '}' '''
394 print(p)
395 # { PEAssignPattern*tmp = new PEAssignPattern;
396 # FILE_NAME(tmp, @1);
397 # $$ = tmp;
398 # }
399 ()
400 def p_block_identifier_opt_1(p):
401 '''block_identifier_opt : IDENTIFIER ':' '''
402 print(p)
403 ()
404 def p_block_identifier_opt_2(p):
405 '''block_identifier_opt : '''
406 print(p)
407 ()
408 def p_class_declaration_1(p):
409 '''class_declaration : K_virtual_opt K_class lifetime_opt class_identifier class_declaration_extends_opt ';' _embed0_class_declaration class_items_opt K_endclass _embed1_class_declaration class_declaration_endlabel_opt '''
410 print(p)
411 # { // Wrap up the class.
412 # if ($11 && $4 && $4->name != $11) {
413 # yyerror(@11, "error: Class end label doesn't match class name.");
414 # delete[]$11;
415 # }
416 # }
417 ()
418 def p__embed0_class_declaration(p):
419 '''_embed0_class_declaration : '''
420 # { pform_start_class_declaration(@2, $4, $5.type, $5.exprs, $3); }
421 ()
422 def p__embed1_class_declaration(p):
423 '''_embed1_class_declaration : '''
424 # { // Process a class.
425 # pform_end_class_declaration(@9);
426 # }
427 ()
428 def p_class_constraint_1(p):
429 '''class_constraint : constraint_prototype '''
430 print(p)
431 ()
432 def p_class_constraint_2(p):
433 '''class_constraint : constraint_declaration '''
434 print(p)
435 ()
436 def p_class_identifier_1(p):
437 '''class_identifier : IDENTIFIER '''
438 print(p)
439 # { // Create a synthetic typedef for the class name so that the
440 # // lexor detects the name as a type.
441 # perm_string name = lex_strings.make($1);
442 # class_type_t*tmp = new class_type_t(name);
443 # FILE_NAME(tmp, @1);
444 # pform_set_typedef(name, tmp, NULL);
445 # delete[]$1;
446 # $$ = tmp;
447 # }
448 ()
449 def p_class_identifier_2(p):
450 '''class_identifier : TYPE_IDENTIFIER '''
451 print(p)
452 # { class_type_t*tmp = dynamic_cast<class_type_t*>($1.type);
453 # if (tmp == 0) {
454 # yyerror(@1, "Type name \"%s\"is not a predeclared class name.", $1.text);
455 # }
456 # delete[]$1.text;
457 # $$ = tmp;
458 # }
459 ()
460 def p_class_declaration_endlabel_opt_1(p):
461 '''class_declaration_endlabel_opt : ':' TYPE_IDENTIFIER '''
462 print(p)
463 # { class_type_t*tmp = dynamic_cast<class_type_t*> ($2.type);
464 # if (tmp == 0) {
465 # yyerror(@2, "error: class declaration endlabel \"%s\" is not a class name\n", $2.text);
466 # $$ = 0;
467 # } else {
468 # $$ = strdupnew(tmp->name.str());
469 # }
470 # delete[]$2.text;
471 # }
472 ()
473 def p_class_declaration_endlabel_opt_2(p):
474 '''class_declaration_endlabel_opt : ':' IDENTIFIER '''
475 print(p)
476 # { $$ = $2; }
477 ()
478 def p_class_declaration_endlabel_opt_3(p):
479 '''class_declaration_endlabel_opt : '''
480 print(p)
481 # { $$ = 0; }
482 ()
483 def p_class_declaration_extends_opt_1(p):
484 '''class_declaration_extends_opt : K_extends TYPE_IDENTIFIER '''
485 print(p)
486 # { $$.type = $2.type;
487 # $$.exprs= 0;
488 # delete[]$2.text;
489 # }
490 ()
491 def p_class_declaration_extends_opt_2(p):
492 '''class_declaration_extends_opt : K_extends TYPE_IDENTIFIER '(' expression_list_with_nuls ')' '''
493 print(p)
494 # { $$.type = $2.type;
495 # $$.exprs = $4;
496 # delete[]$2.text;
497 # }
498 ()
499 def p_class_declaration_extends_opt_3(p):
500 '''class_declaration_extends_opt : '''
501 print(p)
502 # { $$.type = 0; $$.exprs = 0; }
503 ()
504 def p_class_items_opt_1(p):
505 '''class_items_opt : class_items '''
506 print(p)
507 ()
508 def p_class_items_opt_2(p):
509 '''class_items_opt : '''
510 print(p)
511 ()
512 def p_class_items_1(p):
513 '''class_items : class_items class_item '''
514 print(p)
515 ()
516 def p_class_items_2(p):
517 '''class_items : class_item '''
518 print(p)
519 ()
520 def p_class_item_1(p):
521 '''class_item : method_qualifier_opt K_function K_new _embed0_class_item '(' tf_port_list_opt ')' ';' function_item_list_opt statement_or_null_list_opt K_endfunction endnew_opt '''
522 print(p)
523 # { current_function->set_ports($6);
524 # pform_set_constructor_return(current_function);
525 # pform_set_this_class(@3, current_function);
526 # current_function_set_statement(@3, $10);
527 # pform_pop_scope();
528 # current_function = 0;
529 # }
530 ()
531 def p_class_item_2(p):
532 '''class_item : property_qualifier_opt data_type list_of_variable_decl_assignments ';' '''
533 print(p)
534 # { pform_class_property(@2, $1, $2, $3); }
535 ()
536 def p_class_item_3(p):
537 '''class_item : K_const class_item_qualifier_opt data_type list_of_variable_decl_assignments ';' '''
538 print(p)
539 # { pform_class_property(@1, $2 | property_qualifier_t::make_const(), $3, $4); }
540 ()
541 def p_class_item_4(p):
542 '''class_item : method_qualifier_opt task_declaration '''
543 print(p)
544 # { /* The task_declaration rule puts this into the class */ }
545 ()
546 def p_class_item_5(p):
547 '''class_item : method_qualifier_opt function_declaration '''
548 print(p)
549 # { /* The function_declaration rule puts this into the class */ }
550 ()
551 def p_class_item_6(p):
552 '''class_item : K_extern method_qualifier_opt K_function K_new ';' '''
553 print(p)
554 # { yyerror(@1, "sorry: External constructors are not yet supported."); }
555 ()
556 def p_class_item_7(p):
557 '''class_item : K_extern method_qualifier_opt K_function K_new '(' tf_port_list_opt ')' ';' '''
558 print(p)
559 # { yyerror(@1, "sorry: External constructors are not yet supported."); }
560 ()
561 def p_class_item_8(p):
562 '''class_item : K_extern method_qualifier_opt K_function data_type_or_implicit_or_void IDENTIFIER ';' '''
563 print(p)
564 # { yyerror(@1, "sorry: External methods are not yet supported.");
565 # delete[] $5;
566 # }
567 ()
568 def p_class_item_9(p):
569 '''class_item : K_extern method_qualifier_opt K_function data_type_or_implicit_or_void IDENTIFIER '(' tf_port_list_opt ')' ';' '''
570 print(p)
571 # { yyerror(@1, "sorry: External methods are not yet supported.");
572 # delete[] $5;
573 # }
574 ()
575 def p_class_item_10(p):
576 '''class_item : K_extern method_qualifier_opt K_task IDENTIFIER ';' '''
577 print(p)
578 # { yyerror(@1, "sorry: External methods are not yet supported.");
579 # delete[] $4;
580 # }
581 ()
582 def p_class_item_11(p):
583 '''class_item : K_extern method_qualifier_opt K_task IDENTIFIER '(' tf_port_list_opt ')' ';' '''
584 print(p)
585 # { yyerror(@1, "sorry: External methods are not yet supported.");
586 # delete[] $4;
587 # }
588 ()
589 def p_class_item_12(p):
590 '''class_item : class_constraint '''
591 print(p)
592 ()
593 def p_class_item_13(p):
594 '''class_item : property_qualifier_opt data_type error ';' '''
595 print(p)
596 # { yyerror(@3, "error: Errors in variable names after data type.");
597 # yyerrok;
598 # }
599 ()
600 def p_class_item_14(p):
601 '''class_item : property_qualifier_opt IDENTIFIER error ';' '''
602 print(p)
603 # { yyerror(@3, "error: %s doesn't name a type.", $2);
604 # yyerrok;
605 # }
606 ()
607 def p_class_item_15(p):
608 '''class_item : method_qualifier_opt K_function K_new error K_endfunction endnew_opt '''
609 print(p)
610 # { yyerror(@1, "error: I give up on this class constructor declaration.");
611 # yyerrok;
612 # }
613 ()
614 def p_class_item_16(p):
615 '''class_item : error ';' '''
616 print(p)
617 # { yyerror(@2, "error: invalid class item.");
618 # yyerrok;
619 # }
620 ()
621 def p__embed0_class_item(p):
622 '''_embed0_class_item : '''
623 # { assert(current_function==0);
624 # current_function = pform_push_constructor_scope(@3);
625 # }
626 ()
627 def p_class_item_qualifier_1(p):
628 '''class_item_qualifier : K_static '''
629 print(p)
630 # { $$ = property_qualifier_t::make_static(); }
631 ()
632 def p_class_item_qualifier_2(p):
633 '''class_item_qualifier : K_protected '''
634 print(p)
635 # { $$ = property_qualifier_t::make_protected(); }
636 ()
637 def p_class_item_qualifier_3(p):
638 '''class_item_qualifier : K_local '''
639 print(p)
640 # { $$ = property_qualifier_t::make_local(); }
641 ()
642 def p_class_item_qualifier_list_1(p):
643 '''class_item_qualifier_list : class_item_qualifier_list class_item_qualifier '''
644 print(p)
645 # { $$ = $1 | $2; }
646 ()
647 def p_class_item_qualifier_list_2(p):
648 '''class_item_qualifier_list : class_item_qualifier '''
649 print(p)
650 # { $$ = $1; }
651 ()
652 def p_class_item_qualifier_opt_1(p):
653 '''class_item_qualifier_opt : class_item_qualifier_list '''
654 print(p)
655 # { $$ = $1; }
656 ()
657 def p_class_item_qualifier_opt_2(p):
658 '''class_item_qualifier_opt : '''
659 print(p)
660 # { $$ = property_qualifier_t::make_none(); }
661 ()
662 def p_class_new_1(p):
663 '''class_new : K_new '(' expression_list_with_nuls ')' '''
664 print(p)
665 # { list<PExpr*>*expr_list = $3;
666 # strip_tail_items(expr_list);
667 # PENewClass*tmp = new PENewClass(*expr_list);
668 # FILE_NAME(tmp, @1);
669 # delete $3;
670 # $$ = tmp;
671 # }
672 ()
673 def p_class_new_2(p):
674 '''class_new : K_new hierarchy_identifier '''
675 print(p)
676 # { PEIdent*tmpi = new PEIdent(*$2);
677 # FILE_NAME(tmpi, @2);
678 # PENewCopy*tmp = new PENewCopy(tmpi);
679 # FILE_NAME(tmp, @1);
680 # delete $2;
681 # $$ = tmp;
682 # }
683 ()
684 def p_class_new_3(p):
685 '''class_new : K_new '''
686 print(p)
687 # { PENewClass*tmp = new PENewClass;
688 # FILE_NAME(tmp, @1);
689 # $$ = tmp;
690 # }
691 ()
692 def p_concurrent_assertion_item_1(p):
693 '''concurrent_assertion_item : block_identifier_opt K_assert K_property '(' property_spec ')' statement_or_null '''
694 print(p)
695 # { /* */
696 # if (gn_assertions_flag) {
697 # yyerror(@2, "sorry: concurrent_assertion_item not supported."
698 # " Try -gno-assertion to turn this message off.");
699 # }
700 # }
701 ()
702 def p_concurrent_assertion_item_2(p):
703 '''concurrent_assertion_item : block_identifier_opt K_assert K_property '(' error ')' statement_or_null '''
704 print(p)
705 # { yyerrok;
706 # yyerror(@2, "error: Error in property_spec of concurrent assertion item.");
707 # }
708 ()
709 def p_constraint_block_item_1(p):
710 '''constraint_block_item : constraint_expression '''
711 print(p)
712 ()
713 def p_constraint_block_item_list_1(p):
714 '''constraint_block_item_list : constraint_block_item_list constraint_block_item '''
715 print(p)
716 ()
717 def p_constraint_block_item_list_2(p):
718 '''constraint_block_item_list : constraint_block_item '''
719 print(p)
720 ()
721 def p_constraint_block_item_list_opt_1(p):
722 '''constraint_block_item_list_opt : '''
723 print(p)
724 ()
725 def p_constraint_block_item_list_opt_2(p):
726 '''constraint_block_item_list_opt : constraint_block_item_list '''
727 print(p)
728 ()
729 def p_constraint_declaration_1(p):
730 '''constraint_declaration : K_static_opt K_constraint IDENTIFIER '{' constraint_block_item_list_opt '}' '''
731 print(p)
732 # { yyerror(@2, "sorry: Constraint declarations not supported."); }
733 ()
734 def p_constraint_declaration_2(p):
735 '''constraint_declaration : K_static_opt K_constraint IDENTIFIER '{' error '}' '''
736 print(p)
737 # { yyerror(@4, "error: Errors in the constraint block item list."); }
738 ()
739 def p_constraint_expression_1(p):
740 '''constraint_expression : expression ';' '''
741 print(p)
742 ()
743 def p_constraint_expression_2(p):
744 '''constraint_expression : expression K_dist '{' '}' ';' '''
745 print(p)
746 ()
747 def p_constraint_expression_3(p):
748 '''constraint_expression : expression K_TRIGGER constraint_set '''
749 print(p)
750 ()
751 def p_constraint_expression_4(p):
752 '''constraint_expression : K_if '(' expression ')' constraint_set %prec less_than_K_else '''
753 print(p)
754 ()
755 def p_constraint_expression_5(p):
756 '''constraint_expression : K_if '(' expression ')' constraint_set K_else constraint_set '''
757 print(p)
758 ()
759 def p_constraint_expression_6(p):
760 '''constraint_expression : K_foreach '(' IDENTIFIER '[' loop_variables ']' ')' constraint_set '''
761 print(p)
762 ()
763 def p_constraint_expression_list_1(p):
764 '''constraint_expression_list : constraint_expression_list constraint_expression '''
765 print(p)
766 ()
767 def p_constraint_expression_list_2(p):
768 '''constraint_expression_list : constraint_expression '''
769 print(p)
770 ()
771 def p_constraint_prototype_1(p):
772 '''constraint_prototype : K_static_opt K_constraint IDENTIFIER ';' '''
773 print(p)
774 # { yyerror(@2, "sorry: Constraint prototypes not supported."); }
775 ()
776 def p_constraint_set_1(p):
777 '''constraint_set : constraint_expression '''
778 print(p)
779 ()
780 def p_constraint_set_2(p):
781 '''constraint_set : '{' constraint_expression_list '}' '''
782 print(p)
783 ()
784 def p_data_declaration_1(p):
785 '''data_declaration : attribute_list_opt data_type_or_implicit list_of_variable_decl_assignments ';' '''
786 print(p)
787 # { data_type_t*data_type = $2;
788 # if (data_type == 0) {
789 # data_type = new vector_type_t(IVL_VT_LOGIC, false, 0);
790 # FILE_NAME(data_type, @2);
791 # }
792 # pform_makewire(@2, 0, str_strength, $3, NetNet::IMPLICIT_REG, data_type);
793 # }
794 ()
795 def p_data_type_1(p):
796 '''data_type : integer_vector_type unsigned_signed_opt dimensions_opt '''
797 print(p)
798 # { ivl_variable_type_t use_vtype = $1;
799 # bool reg_flag = false;
800 # if (use_vtype == IVL_VT_NO_TYPE) {
801 # use_vtype = IVL_VT_LOGIC;
802 # reg_flag = true;
803 # }
804 # vector_type_t*tmp = new vector_type_t(use_vtype, $2, $3);
805 # tmp->reg_flag = reg_flag;
806 # FILE_NAME(tmp, @1);
807 # $$ = tmp;
808 # }
809 ()
810 def p_data_type_2(p):
811 '''data_type : non_integer_type '''
812 print(p)
813 # { real_type_t*tmp = new real_type_t($1);
814 # FILE_NAME(tmp, @1);
815 # $$ = tmp;
816 # }
817 ()
818 def p_data_type_3(p):
819 '''data_type : struct_data_type '''
820 print(p)
821 # { if (!$1->packed_flag) {
822 # yyerror(@1, "sorry: Unpacked structs not supported.");
823 # }
824 # $$ = $1;
825 # }
826 ()
827 def p_data_type_4(p):
828 '''data_type : enum_data_type '''
829 print(p)
830 # { $$ = $1; }
831 ()
832 def p_data_type_5(p):
833 '''data_type : atom2_type signed_unsigned_opt '''
834 print(p)
835 # { atom2_type_t*tmp = new atom2_type_t($1, $2);
836 # FILE_NAME(tmp, @1);
837 # $$ = tmp;
838 # }
839 ()
840 def p_data_type_6(p):
841 '''data_type : K_integer signed_unsigned_opt '''
842 print(p)
843 # { list<pform_range_t>*pd = make_range_from_width(integer_width);
844 # vector_type_t*tmp = new vector_type_t(IVL_VT_LOGIC, $2, pd);
845 # tmp->reg_flag = true;
846 # tmp->integer_flag = true;
847 # $$ = tmp;
848 # }
849 ()
850 def p_data_type_7(p):
851 '''data_type : K_time '''
852 print(p)
853 # { list<pform_range_t>*pd = make_range_from_width(64);
854 # vector_type_t*tmp = new vector_type_t(IVL_VT_LOGIC, false, pd);
855 # tmp->reg_flag = !gn_system_verilog();
856 # $$ = tmp;
857 # }
858 ()
859 def p_data_type_8(p):
860 '''data_type : TYPE_IDENTIFIER dimensions_opt '''
861 print(p)
862 # { if ($2) {
863 # parray_type_t*tmp = new parray_type_t($1.type, $2);
864 # FILE_NAME(tmp, @1);
865 # $$ = tmp;
866 # } else $$ = $1.type;
867 # delete[]$1.text;
868 # }
869 ()
870 def p_data_type_9(p):
871 '''data_type : PACKAGE_IDENTIFIER K_SCOPE_RES _embed0_data_type TYPE_IDENTIFIER '''
872 print(p)
873 # { lex_in_package_scope(0);
874 # $$ = $4.type;
875 # delete[]$4.text;
876 # }
877 ()
878 def p_data_type_10(p):
879 '''data_type : K_string '''
880 print(p)
881 # { string_type_t*tmp = new string_type_t;
882 # FILE_NAME(tmp, @1);
883 # $$ = tmp;
884 # }
885 ()
886 def p__embed0_data_type(p):
887 '''_embed0_data_type : '''
888 # { lex_in_package_scope($1); }
889 ()
890 def p_data_type_or_implicit_1(p):
891 '''data_type_or_implicit : data_type '''
892 print(p)
893 # { $$ = $1; }
894 ()
895 def p_data_type_or_implicit_2(p):
896 '''data_type_or_implicit : signing dimensions_opt '''
897 print(p)
898 # { vector_type_t*tmp = new vector_type_t(IVL_VT_LOGIC, $1, $2);
899 # tmp->implicit_flag = true;
900 # FILE_NAME(tmp, @1);
901 # $$ = tmp;
902 # }
903 ()
904 def p_data_type_or_implicit_3(p):
905 '''data_type_or_implicit : dimensions '''
906 print(p)
907 # { vector_type_t*tmp = new vector_type_t(IVL_VT_LOGIC, false, $1);
908 # tmp->implicit_flag = true;
909 # FILE_NAME(tmp, @1);
910 # $$ = tmp;
911 # }
912 ()
913 def p_data_type_or_implicit_4(p):
914 '''data_type_or_implicit : '''
915 print(p)
916 # { $$ = 0; }
917 ()
918 def p_data_type_or_implicit_or_void_1(p):
919 '''data_type_or_implicit_or_void : data_type_or_implicit '''
920 print(p)
921 # { $$ = $1; }
922 ()
923 def p_data_type_or_implicit_or_void_2(p):
924 '''data_type_or_implicit_or_void : K_void '''
925 print(p)
926 # { void_type_t*tmp = new void_type_t;
927 # FILE_NAME(tmp, @1);
928 # $$ = tmp;
929 # }
930 ()
931 def p_description_1(p):
932 '''description : module '''
933 print(p)
934 ()
935 def p_description_2(p):
936 '''description : udp_primitive '''
937 print(p)
938 ()
939 def p_description_3(p):
940 '''description : config_declaration '''
941 print(p)
942 ()
943 def p_description_4(p):
944 '''description : nature_declaration '''
945 print(p)
946 ()
947 def p_description_5(p):
948 '''description : package_declaration '''
949 print(p)
950 ()
951 def p_description_6(p):
952 '''description : discipline_declaration '''
953 print(p)
954 ()
955 def p_description_7(p):
956 '''description : package_item '''
957 print(p)
958 ()
959 def p_description_8(p):
960 '''description : KK_attribute '(' IDENTIFIER ',' STRING ',' STRING ')' '''
961 print(p)
962 # { perm_string tmp3 = lex_strings.make($3);
963 # pform_set_type_attrib(tmp3, $5, $7);
964 # delete[] $3;
965 # delete[] $5;
966 # }
967 ()
968 def p_description_list_1(p):
969 '''description_list : description '''
970 print(p)
971 ()
972 def p_description_list_2(p):
973 '''description_list : description_list description '''
974 print(p)
975 ()
976 def p_endnew_opt_1(p):
977 '''endnew_opt : ':' K_new '''
978 print(p)
979 ()
980 def p_endnew_opt_2(p):
981 '''endnew_opt : '''
982 print(p)
983 ()
984 def p_dynamic_array_new_1(p):
985 '''dynamic_array_new : K_new '[' expression ']' '''
986 print(p)
987 # { $$ = new PENewArray($3, 0);
988 # FILE_NAME($$, @1);
989 # }
990 ()
991 def p_dynamic_array_new_2(p):
992 '''dynamic_array_new : K_new '[' expression ']' '(' expression ')' '''
993 print(p)
994 # { $$ = new PENewArray($3, $6);
995 # FILE_NAME($$, @1);
996 # }
997 ()
998 def p_for_step_1(p):
999 '''for_step : lpvalue '=' expression '''
1000 print(p)
1001 # { PAssign*tmp = new PAssign($1,$3);
1002 # FILE_NAME(tmp, @1);
1003 # $$ = tmp;
1004 # }
1005 ()
1006 def p_for_step_2(p):
1007 '''for_step : inc_or_dec_expression '''
1008 print(p)
1009 # { $$ = pform_compressed_assign_from_inc_dec(@1, $1); }
1010 ()
1011 def p_for_step_3(p):
1012 '''for_step : compressed_statement '''
1013 print(p)
1014 # { $$ = $1; }
1015 ()
1016 def p_function_declaration_1(p):
1017 '''function_declaration : K_function lifetime_opt data_type_or_implicit_or_void IDENTIFIER ';' _embed0_function_declaration function_item_list statement_or_null_list_opt K_endfunction _embed1_function_declaration endlabel_opt '''
1018 print(p)
1019 # { // Last step: check any closing name.
1020 # if ($11) {
1021 # if (strcmp($4,$11) != 0) {
1022 # yyerror(@11, "error: End label doesn't match "
1023 # "function name");
1024 # }
1025 # if (! gn_system_verilog()) {
1026 # yyerror(@11, "error: Function end labels require "
1027 # "SystemVerilog.");
1028 # }
1029 # delete[]$11;
1030 # }
1031 # delete[]$4;
1032 # }
1033 ()
1034 def p_function_declaration_2(p):
1035 '''function_declaration : K_function lifetime_opt data_type_or_implicit_or_void IDENTIFIER _embed2_function_declaration '(' tf_port_list_opt ')' ';' block_item_decls_opt statement_or_null_list_opt K_endfunction _embed3_function_declaration endlabel_opt '''
1036 print(p)
1037 # { // Last step: check any closing name.
1038 # if ($14) {
1039 # if (strcmp($4,$14) != 0) {
1040 # yyerror(@14, "error: End label doesn't match "
1041 # "function name");
1042 # }
1043 # if (! gn_system_verilog()) {
1044 # yyerror(@14, "error: Function end labels require "
1045 # "SystemVerilog.");
1046 # }
1047 # delete[]$14;
1048 # }
1049 # delete[]$4;
1050 # }
1051 ()
1052 def p_function_declaration_3(p):
1053 '''function_declaration : K_function lifetime_opt data_type_or_implicit_or_void IDENTIFIER error K_endfunction _embed4_function_declaration endlabel_opt '''
1054 print(p)
1055 # { // Last step: check any closing name.
1056 # if ($8) {
1057 # if (strcmp($4,$8) != 0) {
1058 # yyerror(@8, "error: End label doesn't match function name");
1059 # }
1060 # if (! gn_system_verilog()) {
1061 # yyerror(@8, "error: Function end labels require "
1062 # "SystemVerilog.");
1063 # }
1064 # delete[]$8;
1065 # }
1066 # delete[]$4;
1067 # }
1068 ()
1069 def p__embed0_function_declaration(p):
1070 '''_embed0_function_declaration : '''
1071 # { assert(current_function == 0);
1072 # current_function = pform_push_function_scope(@1, $4, $2);
1073 # }
1074 ()
1075 def p__embed1_function_declaration(p):
1076 '''_embed1_function_declaration : '''
1077 # { current_function->set_ports($7);
1078 # current_function->set_return($3);
1079 # current_function_set_statement($8? @8 : @4, $8);
1080 # pform_set_this_class(@4, current_function);
1081 # pform_pop_scope();
1082 # current_function = 0;
1083 # }
1084 ()
1085 def p__embed2_function_declaration(p):
1086 '''_embed2_function_declaration : '''
1087 # { assert(current_function == 0);
1088 # current_function = pform_push_function_scope(@1, $4, $2);
1089 # }
1090 ()
1091 def p__embed3_function_declaration(p):
1092 '''_embed3_function_declaration : '''
1093 # { current_function->set_ports($7);
1094 # current_function->set_return($3);
1095 # current_function_set_statement($11? @11 : @4, $11);
1096 # pform_set_this_class(@4, current_function);
1097 # pform_pop_scope();
1098 # current_function = 0;
1099 # if ($7==0 && !gn_system_verilog()) {
1100 # yyerror(@4, "error: Empty parenthesis syntax requires SystemVerilog.");
1101 # }
1102 # }
1103 ()
1104 def p__embed4_function_declaration(p):
1105 '''_embed4_function_declaration : '''
1106 # { /* */
1107 # if (current_function) {
1108 # pform_pop_scope();
1109 # current_function = 0;
1110 # }
1111 # assert(current_function == 0);
1112 # yyerror(@1, "error: Syntax error defining function.");
1113 # yyerrok;
1114 # }
1115 ()
1116 def p_import_export_1(p):
1117 '''import_export : K_import '''
1118 print(p)
1119 # { $$ = true; }
1120 ()
1121 def p_import_export_2(p):
1122 '''import_export : K_export '''
1123 print(p)
1124 # { $$ = false; }
1125 ()
1126 def p_implicit_class_handle_1(p):
1127 '''implicit_class_handle : K_this '''
1128 print(p)
1129 # { $$ = pform_create_this(); }
1130 ()
1131 def p_implicit_class_handle_2(p):
1132 '''implicit_class_handle : K_super '''
1133 print(p)
1134 # { $$ = pform_create_super(); }
1135 ()
1136 def p_inc_or_dec_expression_1(p):
1137 '''inc_or_dec_expression : K_INCR lpvalue %prec UNARY_PREC '''
1138 print(p)
1139 # { PEUnary*tmp = new PEUnary('I', $2);
1140 # FILE_NAME(tmp, @2);
1141 # $$ = tmp;
1142 # }
1143 ()
1144 def p_inc_or_dec_expression_2(p):
1145 '''inc_or_dec_expression : lpvalue K_INCR %prec UNARY_PREC '''
1146 print(p)
1147 # { PEUnary*tmp = new PEUnary('i', $1);
1148 # FILE_NAME(tmp, @1);
1149 # $$ = tmp;
1150 # }
1151 ()
1152 def p_inc_or_dec_expression_3(p):
1153 '''inc_or_dec_expression : K_DECR lpvalue %prec UNARY_PREC '''
1154 print(p)
1155 # { PEUnary*tmp = new PEUnary('D', $2);
1156 # FILE_NAME(tmp, @2);
1157 # $$ = tmp;
1158 # }
1159 ()
1160 def p_inc_or_dec_expression_4(p):
1161 '''inc_or_dec_expression : lpvalue K_DECR %prec UNARY_PREC '''
1162 print(p)
1163 # { PEUnary*tmp = new PEUnary('d', $1);
1164 # FILE_NAME(tmp, @1);
1165 # $$ = tmp;
1166 # }
1167 ()
1168 def p_inside_expression_1(p):
1169 '''inside_expression : expression K_inside '{' open_range_list '}' '''
1170 print(p)
1171 # { yyerror(@2, "sorry: \"inside\" expressions not supported yet.");
1172 # $$ = 0;
1173 # }
1174 ()
1175 def p_integer_vector_type_1(p):
1176 '''integer_vector_type : K_reg '''
1177 print(p)
1178 # { $$ = IVL_VT_NO_TYPE; }
1179 ()
1180 def p_integer_vector_type_2(p):
1181 '''integer_vector_type : K_bit '''
1182 print(p)
1183 # { $$ = IVL_VT_BOOL; }
1184 ()
1185 def p_integer_vector_type_3(p):
1186 '''integer_vector_type : K_logic '''
1187 print(p)
1188 # { $$ = IVL_VT_LOGIC; }
1189 ()
1190 def p_integer_vector_type_4(p):
1191 '''integer_vector_type : K_bool '''
1192 print(p)
1193 # { $$ = IVL_VT_BOOL; }
1194 ()
1195 def p_join_keyword_1(p):
1196 '''join_keyword : K_join '''
1197 print(p)
1198 # { $$ = PBlock::BL_PAR; }
1199 ()
1200 def p_join_keyword_2(p):
1201 '''join_keyword : K_join_none '''
1202 print(p)
1203 # { $$ = PBlock::BL_JOIN_NONE; }
1204 ()
1205 def p_join_keyword_3(p):
1206 '''join_keyword : K_join_any '''
1207 print(p)
1208 # { $$ = PBlock::BL_JOIN_ANY; }
1209 ()
1210 def p_jump_statement_1(p):
1211 '''jump_statement : K_break ';' '''
1212 print(p)
1213 # { yyerror(@1, "sorry: break statements not supported.");
1214 # $$ = 0;
1215 # }
1216 ()
1217 def p_jump_statement_2(p):
1218 '''jump_statement : K_return ';' '''
1219 print(p)
1220 # { PReturn*tmp = new PReturn(0);
1221 # FILE_NAME(tmp, @1);
1222 # $$ = tmp;
1223 # }
1224 ()
1225 def p_jump_statement_3(p):
1226 '''jump_statement : K_return expression ';' '''
1227 print(p)
1228 # { PReturn*tmp = new PReturn($2);
1229 # FILE_NAME(tmp, @1);
1230 # $$ = tmp;
1231 # }
1232 ()
1233 def p_lifetime_1(p):
1234 '''lifetime : K_automatic '''
1235 print(p)
1236 # { $$ = LexicalScope::AUTOMATIC; }
1237 ()
1238 def p_lifetime_2(p):
1239 '''lifetime : K_static '''
1240 print(p)
1241 # { $$ = LexicalScope::STATIC; }
1242 ()
1243 def p_lifetime_opt_1(p):
1244 '''lifetime_opt : lifetime '''
1245 print(p)
1246 # { $$ = $1; }
1247 ()
1248 def p_lifetime_opt_2(p):
1249 '''lifetime_opt : '''
1250 print(p)
1251 # { $$ = LexicalScope::INHERITED; }
1252 ()
1253 def p_loop_statement_1(p):
1254 '''loop_statement : K_for '(' lpvalue '=' expression ';' expression ';' for_step ')' statement_or_null '''
1255 print(p)
1256 # { PForStatement*tmp = new PForStatement($3, $5, $7, $9, $11);
1257 # FILE_NAME(tmp, @1);
1258 # $$ = tmp;
1259 # }
1260 ()
1261 def p_loop_statement_2(p):
1262 '''loop_statement : K_for '(' data_type IDENTIFIER '=' expression ';' expression ';' for_step ')' _embed0_loop_statement statement_or_null '''
1263 print(p)
1264 # { pform_name_t tmp_hident;
1265 # tmp_hident.push_back(name_component_t(lex_strings.make($4)));
1266 #
1267 # PEIdent*tmp_ident = pform_new_ident(tmp_hident);
1268 # FILE_NAME(tmp_ident, @4);
1269 #
1270 # PForStatement*tmp_for = new PForStatement(tmp_ident, $6, $8, $10, $13);
1271 # FILE_NAME(tmp_for, @1);
1272 #
1273 # pform_pop_scope();
1274 # vector<Statement*>tmp_for_list (1);
1275 # tmp_for_list[0] = tmp_for;
1276 # PBlock*tmp_blk = current_block_stack.top();
1277 # current_block_stack.pop();
1278 # tmp_blk->set_statement(tmp_for_list);
1279 # $$ = tmp_blk;
1280 # delete[]$4;
1281 # }
1282 ()
1283 def p_loop_statement_3(p):
1284 '''loop_statement : K_forever statement_or_null '''
1285 print(p)
1286 # { PForever*tmp = new PForever($2);
1287 # FILE_NAME(tmp, @1);
1288 # $$ = tmp;
1289 # }
1290 ()
1291 def p_loop_statement_4(p):
1292 '''loop_statement : K_repeat '(' expression ')' statement_or_null '''
1293 print(p)
1294 # { PRepeat*tmp = new PRepeat($3, $5);
1295 # FILE_NAME(tmp, @1);
1296 # $$ = tmp;
1297 # }
1298 ()
1299 def p_loop_statement_5(p):
1300 '''loop_statement : K_while '(' expression ')' statement_or_null '''
1301 print(p)
1302 # { PWhile*tmp = new PWhile($3, $5);
1303 # FILE_NAME(tmp, @1);
1304 # $$ = tmp;
1305 # }
1306 ()
1307 def p_loop_statement_6(p):
1308 '''loop_statement : K_do statement_or_null K_while '(' expression ')' ';' '''
1309 print(p)
1310 # { PDoWhile*tmp = new PDoWhile($5, $2);
1311 # FILE_NAME(tmp, @1);
1312 # $$ = tmp;
1313 # }
1314 ()
1315 def p_loop_statement_7(p):
1316 '''loop_statement : K_foreach '(' IDENTIFIER '[' loop_variables ']' ')' _embed1_loop_statement statement_or_null '''
1317 print(p)
1318 # { PForeach*tmp_for = pform_make_foreach(@1, $3, $5, $9);
1319 #
1320 # pform_pop_scope();
1321 # vector<Statement*>tmp_for_list(1);
1322 # tmp_for_list[0] = tmp_for;
1323 # PBlock*tmp_blk = current_block_stack.top();
1324 # current_block_stack.pop();
1325 # tmp_blk->set_statement(tmp_for_list);
1326 # $$ = tmp_blk;
1327 # }
1328 ()
1329 def p_loop_statement_8(p):
1330 '''loop_statement : K_for '(' lpvalue '=' expression ';' expression ';' error ')' statement_or_null '''
1331 print(p)
1332 # { $$ = 0;
1333 # yyerror(@1, "error: Error in for loop step assignment.");
1334 # }
1335 ()
1336 def p_loop_statement_9(p):
1337 '''loop_statement : K_for '(' lpvalue '=' expression ';' error ';' for_step ')' statement_or_null '''
1338 print(p)
1339 # { $$ = 0;
1340 # yyerror(@1, "error: Error in for loop condition expression.");
1341 # }
1342 ()
1343 def p_loop_statement_10(p):
1344 '''loop_statement : K_for '(' error ')' statement_or_null '''
1345 print(p)
1346 # { $$ = 0;
1347 # yyerror(@1, "error: Incomprehensible for loop.");
1348 # }
1349 ()
1350 def p_loop_statement_11(p):
1351 '''loop_statement : K_while '(' error ')' statement_or_null '''
1352 print(p)
1353 # { $$ = 0;
1354 # yyerror(@1, "error: Error in while loop condition.");
1355 # }
1356 ()
1357 def p_loop_statement_12(p):
1358 '''loop_statement : K_do statement_or_null K_while '(' error ')' ';' '''
1359 print(p)
1360 # { $$ = 0;
1361 # yyerror(@1, "error: Error in do/while loop condition.");
1362 # }
1363 ()
1364 def p_loop_statement_13(p):
1365 '''loop_statement : K_foreach '(' IDENTIFIER '[' error ']' ')' statement_or_null '''
1366 print(p)
1367 # { $$ = 0;
1368 # yyerror(@4, "error: Errors in foreach loop variables list.");
1369 # }
1370 ()
1371 def p__embed0_loop_statement(p):
1372 '''_embed0_loop_statement : '''
1373 # { static unsigned for_counter = 0;
1374 # char for_block_name [64];
1375 # snprintf(for_block_name, sizeof for_block_name, "$ivl_for_loop%u", for_counter);
1376 # for_counter += 1;
1377 # PBlock*tmp = pform_push_block_scope(for_block_name, PBlock::BL_SEQ);
1378 # FILE_NAME(tmp, @1);
1379 # current_block_stack.push(tmp);
1380 #
1381 # list<decl_assignment_t*>assign_list;
1382 # decl_assignment_t*tmp_assign = new decl_assignment_t;
1383 # tmp_assign->name = lex_strings.make($4);
1384 # assign_list.push_back(tmp_assign);
1385 # pform_makewire(@4, 0, str_strength, &assign_list, NetNet::REG, $3);
1386 # }
1387 ()
1388 def p__embed1_loop_statement(p):
1389 '''_embed1_loop_statement : '''
1390 # { static unsigned foreach_counter = 0;
1391 # char for_block_name[64];
1392 # snprintf(for_block_name, sizeof for_block_name, "$ivl_foreach%u", foreach_counter);
1393 # foreach_counter += 1;
1394 #
1395 # PBlock*tmp = pform_push_block_scope(for_block_name, PBlock::BL_SEQ);
1396 # FILE_NAME(tmp, @1);
1397 # current_block_stack.push(tmp);
1398 #
1399 # pform_make_foreach_declarations(@1, $5);
1400 # }
1401 ()
1402 def p_list_of_variable_decl_assignments_1(p):
1403 '''list_of_variable_decl_assignments : variable_decl_assignment '''
1404 print(p)
1405 # { list<decl_assignment_t*>*tmp = new list<decl_assignment_t*>;
1406 # tmp->push_back($1);
1407 # $$ = tmp;
1408 # }
1409 ()
1410 def p_list_of_variable_decl_assignments_2(p):
1411 '''list_of_variable_decl_assignments : list_of_variable_decl_assignments ',' variable_decl_assignment '''
1412 print(p)
1413 # { list<decl_assignment_t*>*tmp = $1;
1414 # tmp->push_back($3);
1415 # $$ = tmp;
1416 # }
1417 ()
1418 def p_variable_decl_assignment_1(p):
1419 '''variable_decl_assignment : IDENTIFIER dimensions_opt '''
1420 print(p)
1421 # { decl_assignment_t*tmp = new decl_assignment_t;
1422 # tmp->name = lex_strings.make($1);
1423 # if ($2) {
1424 # tmp->index = *$2;
1425 # delete $2;
1426 # }
1427 # delete[]$1;
1428 # $$ = tmp;
1429 # }
1430 ()
1431 def p_variable_decl_assignment_2(p):
1432 '''variable_decl_assignment : IDENTIFIER '=' expression '''
1433 print(p)
1434 # { decl_assignment_t*tmp = new decl_assignment_t;
1435 # tmp->name = lex_strings.make($1);
1436 # tmp->expr .reset($3);
1437 # delete[]$1;
1438 # $$ = tmp;
1439 # }
1440 ()
1441 def p_variable_decl_assignment_3(p):
1442 '''variable_decl_assignment : IDENTIFIER '=' K_new '(' ')' '''
1443 print(p)
1444 # { decl_assignment_t*tmp = new decl_assignment_t;
1445 # tmp->name = lex_strings.make($1);
1446 # PENewClass*expr = new PENewClass;
1447 # FILE_NAME(expr, @3);
1448 # tmp->expr .reset(expr);
1449 # delete[]$1;
1450 # $$ = tmp;
1451 # }
1452 ()
1453 def p_loop_variables_1(p):
1454 '''loop_variables : loop_variables ',' IDENTIFIER '''
1455 print(p)
1456 # { list<perm_string>*tmp = $1;
1457 # tmp->push_back(lex_strings.make($3));
1458 # delete[]$3;
1459 # $$ = tmp;
1460 # }
1461 ()
1462 def p_loop_variables_2(p):
1463 '''loop_variables : IDENTIFIER '''
1464 print(p)
1465 # { list<perm_string>*tmp = new list<perm_string>;
1466 # tmp->push_back(lex_strings.make($1));
1467 # delete[]$1;
1468 # $$ = tmp;
1469 # }
1470 ()
1471 def p_method_qualifier_1(p):
1472 '''method_qualifier : K_virtual '''
1473 print(p)
1474 ()
1475 def p_method_qualifier_2(p):
1476 '''method_qualifier : class_item_qualifier '''
1477 print(p)
1478 ()
1479 def p_method_qualifier_opt_1(p):
1480 '''method_qualifier_opt : method_qualifier '''
1481 print(p)
1482 ()
1483 def p_method_qualifier_opt_2(p):
1484 '''method_qualifier_opt : '''
1485 print(p)
1486 ()
1487
1488 if __name__ == '__main__':
1489 from ply import *
1490 yacc.yacc()
1491