convert numbers to python format

[sv2nmigen.git] / parse_sv.py

# %{
# /*
#  * Copyright (c) 1998-2017 Stephen Williams (steve@icarus.com)
#  * Copyright CERN 2012-2013 / Stephen Williams (steve@icarus.com)
#  *
#  *    This source code is free software; you can redistribute it
#  *    and/or modify it in source code form under the terms of the GNU
#  *    General Public License as published by the Free Software
#  *    Foundation; either version 2 of the License, or (at your option)
#  *    any later version.
#  *
#  *    This program is distributed in the hope that it will be useful,
#  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
#  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  *    GNU General Public License for more details.
#  *
#  *    You should have received a copy of the GNU General Public License
#  *    along with this program; if not, write to the Free Software
#  *    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#  */

import lexor
from ply import yacc, lex
from lib2to3.pytree import Node, Leaf
from lib2to3.pgen2 import token
from lib2to3.pygram import python_symbols as syms

yacc1_debug = 0
yacc2_debug = 0
parse_debug = 1


#from parse_tokens import tokens
tokens = lexor.tokens  # list(set(lexor.tokens).union(set(tokens)))
literals = lexor.literals

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')
]


IVL_VT_NO_TYPE = 'VT_NO_TYPE'
IVL_VT_BOOL = 'VT_BOOL'
IVL_VT_LOGIC = 'VT_LOGIC'
"""
      IVL_VT_VOID    = 0,  /* Not used */
      IVL_VT_NO_TYPE = 1,  /* Place holder for missing/unknown type. */
      IVL_VT_REAL    = 2,
      IVL_VT_BOOL    = 3,
      IVL_VT_LOGIC   = 4,
      IVL_VT_STRING  = 5,
      IVL_VT_DARRAY  = 6,  /* Array (esp. dynamic array) */
      IVL_VT_CLASS   = 7,  /* SystemVerilog class instances */
      IVL_VT_QUEUE   = 8,  /* SystemVerilog queue instances */
      IVL_VT_VECTOR = IVL_VT_LOGIC /* For compatibility */
"""

NN_NONE = 'NONE'
NN_IMPLICIT = 'IMPLICIT'
NN_IMPLICIT_REG = 'IMPLICIT_REG'
NN_INTEGER = 'INTEGER'
NN_WIRE = 'WIRE'
NN_TRI = 'TRI'
NN_TRI1 = 'TRI1'
NN_SUPPLY0 = 'SUPPLY0'
NN_SUPPLY1 = 'SUPPLY1'
NN_WAND = 'WAND'
NN_TRIAND = 'TRIAND'
NN_TRI0 = 'TRI0'
NN_WOR = 'WOR'
NN_TRIOR = 'TRIOR'
NN_REG = 'REG'
NN_UNRESOLVED_WIRE = 'UNRESOLVED_WIRE'

NP_NOT_A_PORT = 'NOT_A_PORT'
NP_PIMPLICIT = 'PIMPLICIT'
NP_PINPUT = 'PINPUT'
NP_POUTPUT = 'POUTPUT'
NP_PINOUT = 'PINOUT'
NP_PREF = 'PREF'


class DataType:
    def __init__(self, typ, signed):
        self.typ = typ
        self.signed = signed


class StatementList:
    def __init__(self):
        self.statements = []

    def add_statement(self, s):
        self.statements += [s]


# -------------- RULES ----------------
()


def p_source_text_1(p):
    '''source_text : timeunits_declaration_opt _embed0_source_text description_list '''
    if(parse_debug > 2):
        print('source_text', list(p))


()


def p_source_text_2(p):
    '''source_text :  '''
    if(parse_debug):
        print('source_text', list(p))


()


def p__embed0_source_text(p):
    '''_embed0_source_text : '''


    # { pform_set_scope_timescale(yyloc); }
()


def p_assertion_item_1(p):
    '''assertion_item : concurrent_assertion_item '''
    if(parse_debug):
        print('assertion_item_1', list(p))


()


def p_assignment_pattern_1(p):
    '''assignment_pattern : K_LP expression_list_proper '}' '''
    if(parse_debug):
        print('assignment_pattern_1', list(p))


    # { PEAssignPattern*tmp = new PEAssignPattern(*p[2]);
    #   FILE_NAME(tmp, @1);
    #   delete p[2];
    #   p[0] = tmp;
    #       }
()


def p_assignment_pattern_2(p):
    '''assignment_pattern : K_LP '}' '''
    if(parse_debug):
        print('assignment_pattern_2', list(p))


    # { PEAssignPattern*tmp = new PEAssignPattern;
    #   FILE_NAME(tmp, @1);
    #   p[0] = tmp;
    #       }
()


def p_block_identifier_opt_1(p):
    '''block_identifier_opt : IDENTIFIER ':' '''
    if(parse_debug):
        print('block_identifier_opt_1', list(p))


()


def p_block_identifier_opt_2(p):
    '''block_identifier_opt :  '''
    if(parse_debug):
        print('block_identifier_opt_2', list(p))


()


def p_class_declaration_1(p):
    '''class_declaration : K_virtual_opt K_class lifetime_opt class_identifier class_declaration_extends_opt ';' _embed0_class_declaration class_items_opt K_endclass _embed1_class_declaration class_declaration_endlabel_opt '''
    if(parse_debug):
        print('class_declaration_1', list(p))


    # { // Wrap up the class.
    #   if (p[11] && p[4] && p[4]->name != p[11]) {
    #         yyerror(@11, "error: Class end label doesn't match class name.");
    #         delete[]p[11];
    #   }
    #       }
()


def p__embed0_class_declaration(p):
    '''_embed0_class_declaration : '''


    # { pform_start_class_declaration(@2, p[4], p[5].type, p[5].exprs, p[3]); }
()


def p__embed1_class_declaration(p):
    '''_embed1_class_declaration : '''


    # { // Process a class.
    #   pform_end_class_declaration(@9);
    #       }
()


def p_class_constraint_1(p):
    '''class_constraint : constraint_prototype '''
    if(parse_debug):
        print('class_constraint_1', list(p))


()


def p_class_constraint_2(p):
    '''class_constraint : constraint_declaration '''
    if(parse_debug):
        print('class_constraint_2', list(p))


()


def p_class_identifier_1(p):
    '''class_identifier : IDENTIFIER '''
    if(parse_debug):
        print('class_identifier_1', list(p))


    # { // Create a synthetic typedef for the class name so that the
    #   // lexor detects the name as a type.
    #   perm_string name = lex_strings.make(p[1]);
    #   class_type_t*tmp = new class_type_t(name);
    #   FILE_NAME(tmp, @1);
    #   pform_set_typedef(name, tmp, NULL);
    #   delete[]p[1];
    #   p[0] = tmp;
    #       }
()


def p_class_identifier_2(p):
    '''class_identifier : TYPE_IDENTIFIER '''
    if(parse_debug):
        print('class_identifier_2', list(p))


    # { class_type_t*tmp = dynamic_cast<class_type_t*>(p[1].type);
    #   if (tmp == 0) {
    #         yyerror(@1, "Type name \"%s\"is not a predeclared class name.", p[1].text);
    #   }
    #   delete[]p[1].text;
    #   p[0] = tmp;
    #       }
()


def p_class_declaration_endlabel_opt_1(p):
    '''class_declaration_endlabel_opt : ':' TYPE_IDENTIFIER '''
    if(parse_debug):
        print('class_declaration_endlabel_opt_1', list(p))


    # { class_type_t*tmp = dynamic_cast<class_type_t*> (p[2].type);
    #   if (tmp == 0) {
    #         yyerror(@2, "error: class declaration endlabel \"%s\" is not a class name\n", p[2].text);
    #         p[0] = None
    #   } else {
    #         p[0] = strdupnew(tmp->name.str());
    #   }
    #   delete[]p[2].text;
    #       }
()


def p_class_declaration_endlabel_opt_2(p):
    '''class_declaration_endlabel_opt : ':' IDENTIFIER '''
    if(parse_debug):
        print('class_declaration_endlabel_opt_2', list(p))
    p[0] = p[2]


()


def p_class_declaration_endlabel_opt_3(p):
    '''class_declaration_endlabel_opt :  '''
    if(parse_debug):
        print('class_declaration_endlabel_opt_3', list(p))


    # { p[0] = None }
()


def p_class_declaration_extends_opt_1(p):
    '''class_declaration_extends_opt : K_extends TYPE_IDENTIFIER '''
    if(parse_debug):
        print('class_declaration_extends_opt_1', list(p))


    # { p[0].type = p[2].type;
    #   p[0].exprs= 0;
    #   delete[]p[2].text;
    #       }
()


def p_class_declaration_extends_opt_2(p):
    '''class_declaration_extends_opt : K_extends TYPE_IDENTIFIER '(' expression_list_with_nuls ')' '''
    if(parse_debug):
        print('class_declaration_extends_opt_2', list(p))


    # { p[0].type  = p[2].type;
    #   p[0].exprs = p[4];
    #   delete[]p[2].text;
    #       }
()


def p_class_declaration_extends_opt_3(p):
    '''class_declaration_extends_opt :  '''
    if(parse_debug):
        print('class_declaration_extends_opt_3', list(p))


    # { p[0].type = 0; p[0].exprs = 0; }
()


def p_class_items_opt_1(p):
    '''class_items_opt : class_items '''
    if(parse_debug):
        print('class_items_opt_1', list(p))


()


def p_class_items_opt_2(p):
    '''class_items_opt :  '''
    if(parse_debug):
        print('class_items_opt_2', list(p))


()


def p_class_items_1(p):
    '''class_items : class_items class_item '''
    if(parse_debug):
        print('class_items_1', list(p))


()


def p_class_items_2(p):
    '''class_items : class_item '''
    if(parse_debug):
        print('class_items_2', list(p))


()


def p_class_item_1(p):
    '''class_item : method_qualifier_opt K_function K_new _embed0_class_item '(' tf_port_list_opt ')' ';' function_item_list_opt statement_or_null_list_opt K_endfunction endnew_opt '''
    if(parse_debug):
        print('class_item_1', list(p))


    # { current_function->set_ports(p[6]);
    #   pform_set_constructor_return(current_function);
    #   pform_set_this_class(@3, current_function);
    #   current_function_set_statement(@3, p[10]);
    #   pform_pop_scope();
    #   current_function = 0;
    #       }
()


def p_class_item_2(p):
    '''class_item : property_qualifier_opt data_type list_of_variable_decl_assignments ';' '''
    if(parse_debug):
        print('class_item_2', list(p))


    # { pform_class_property(@2, p[1], p[2], p[3]); }
()


def p_class_item_3(p):
    '''class_item : K_const class_item_qualifier_opt data_type list_of_variable_decl_assignments ';' '''
    if(parse_debug):
        print('class_item_3', list(p))


    # { pform_class_property(@1, p[2] | property_qualifier_t::make_const(), p[3], p[4]); }
()


def p_class_item_4(p):
    '''class_item : method_qualifier_opt task_declaration '''
    if(parse_debug):
        print('class_item_4', list(p))


    # { /* The task_declaration rule puts this into the class */ }
()


def p_class_item_5(p):
    '''class_item : method_qualifier_opt function_declaration '''
    if(parse_debug):
        print('class_item_5', list(p))


    # { /* The function_declaration rule puts this into the class */ }
()


def p_class_item_6(p):
    '''class_item : K_extern method_qualifier_opt K_function K_new ';' '''
    if(parse_debug):
        print('class_item_6', list(p))


    # { yyerror(@1, "sorry: External constructors are not yet supported."); }
()


def p_class_item_7(p):
    '''class_item : K_extern method_qualifier_opt K_function K_new '(' tf_port_list_opt ')' ';' '''
    if(parse_debug):
        print('class_item_7', list(p))


    # { yyerror(@1, "sorry: External constructors are not yet supported."); }
()


def p_class_item_8(p):
    '''class_item : K_extern method_qualifier_opt K_function data_type_or_implicit_or_void IDENTIFIER ';' '''
    if(parse_debug):
        print('class_item_8', list(p))


    # { yyerror(@1, "sorry: External methods are not yet supported.");
    #   delete[] p[5];
    #       }
()


def p_class_item_9(p):
    '''class_item : K_extern method_qualifier_opt K_function data_type_or_implicit_or_void IDENTIFIER '(' tf_port_list_opt ')' ';' '''
    if(parse_debug):
        print('class_item_9', list(p))


    # { yyerror(@1, "sorry: External methods are not yet supported.");
    #   delete[] p[5];
    #       }
()


def p_class_item_10(p):
    '''class_item : K_extern method_qualifier_opt K_task IDENTIFIER ';' '''
    if(parse_debug):
        print('class_item_10', list(p))


    # { yyerror(@1, "sorry: External methods are not yet supported.");
    #   delete[] p[4];
    #       }
()


def p_class_item_11(p):
    '''class_item : K_extern method_qualifier_opt K_task IDENTIFIER '(' tf_port_list_opt ')' ';' '''
    if(parse_debug):
        print('class_item_11', list(p))


    # { yyerror(@1, "sorry: External methods are not yet supported.");
    #   delete[] p[4];
    #       }
()


def p_class_item_12(p):
    '''class_item : class_constraint '''
    if(parse_debug):
        print('class_item_12', list(p))


()


def p_class_item_13(p):
    '''class_item : property_qualifier_opt data_type error ';' '''
    if(parse_debug):
        print('class_item_13', list(p))


    # { yyerror(@3, "error: Errors in variable names after data type.");
    #   yyerrok;
    #       }
()


def p_class_item_14(p):
    '''class_item : property_qualifier_opt IDENTIFIER error ';' '''
    if(parse_debug):
        print('class_item_14', list(p))


    # { yyerror(@3, "error: %s doesn't name a type.", p[2]);
    #   yyerrok;
    #       }
()


def p_class_item_15(p):
    '''class_item : method_qualifier_opt K_function K_new error K_endfunction endnew_opt '''
    if(parse_debug):
        print('class_item_15', list(p))


    # { yyerror(@1, "error: I give up on this class constructor declaration.");
    #   yyerrok;
    #       }
()


def p_class_item_16(p):
    '''class_item : error ';' '''
    if(parse_debug):
        print('class_item_16', list(p))


    # { yyerror(@2, "error: invalid class item.");
    #   yyerrok;
    #       }
()


def p__embed0_class_item(p):
    '''_embed0_class_item : '''


    # { assert(current_function==0);
    #   current_function = pform_push_constructor_scope(@3);
    #       }
()


def p_class_item_qualifier_1(p):
    '''class_item_qualifier : K_static '''
    if(parse_debug):
        print('class_item_qualifier_1', list(p))


    # { p[0] = property_qualifier_t::make_static(); }
()


def p_class_item_qualifier_2(p):
    '''class_item_qualifier : K_protected '''
    if(parse_debug):
        print('class_item_qualifier_2', list(p))


    # { p[0] = property_qualifier_t::make_protected(); }
()


def p_class_item_qualifier_3(p):
    '''class_item_qualifier : K_local '''
    if(parse_debug):
        print('class_item_qualifier_3', list(p))


    # { p[0] = property_qualifier_t::make_local(); }
()


def p_class_item_qualifier_list_1(p):
    '''class_item_qualifier_list : class_item_qualifier_list class_item_qualifier '''
    if(parse_debug):
        print('class_item_qualifier_list_1', list(p))


    # { p[0] = p[1] | p[2]; }
()


def p_class_item_qualifier_list_2(p):
    '''class_item_qualifier_list : class_item_qualifier '''
    if(parse_debug):
        print('class_item_qualifier_list_2', list(p))
    p[0] = p[1]


()


def p_class_item_qualifier_opt_1(p):
    '''class_item_qualifier_opt : class_item_qualifier_list '''
    if(parse_debug):
        print('class_item_qualifier_opt_1', list(p))
    p[0] = p[1]


()


def p_class_item_qualifier_opt_2(p):
    '''class_item_qualifier_opt :  '''
    if(parse_debug):
        print('class_item_qualifier_opt_2', list(p))


    # { p[0] = property_qualifier_t::make_none(); }
()


def p_class_new_1(p):
    '''class_new : K_new '(' expression_list_with_nuls ')' '''
    if(parse_debug):
        print('class_new_1', list(p))


    # { list<PExpr*>*expr_list = p[3];
    #   strip_tail_items(expr_list);
    #   PENewClass*tmp = new PENewClass(*expr_list);
    #   FILE_NAME(tmp, @1);
    #   delete p[3];
    #   p[0] = tmp;
    #       }
()


def p_class_new_2(p):
    '''class_new : K_new hierarchy_identifier '''
    if(parse_debug):
        print('class_new_2', list(p))


    # { PEIdent*tmpi = new PEIdent(*p[2]);
    #   FILE_NAME(tmpi, @2);
    #   PENewCopy*tmp = new PENewCopy(tmpi);
    #   FILE_NAME(tmp, @1);
    #   delete p[2];
    #   p[0] = tmp;
    #       }
()


def p_class_new_3(p):
    '''class_new : K_new '''
    if(parse_debug):
        print('class_new_3', list(p))


    # { PENewClass*tmp = new PENewClass;
    #   FILE_NAME(tmp, @1);
    #   p[0] = tmp;
    #       }
()


def p_concurrent_assertion_item_1(p):
    '''concurrent_assertion_item : block_identifier_opt K_assert K_property '(' property_spec ')' statement_or_null '''
    if(parse_debug):
        print('concurrent_assertion_item_1', list(p))


    # { /* */
    #   if (gn_assertions_flag) {
    #         yyerror(@2, "sorry: concurrent_assertion_item not supported."
    #                 " Try -gno-assertion to turn this message off.");
    #   }
    #       }
()


def p_concurrent_assertion_item_2(p):
    '''concurrent_assertion_item : block_identifier_opt K_assert K_property '(' error ')' statement_or_null '''
    if(parse_debug):
        print('concurrent_assertion_item_2', list(p))


    # { yyerrok;
    #         yyerror(@2, "error: Error in property_spec of concurrent assertion item.");
    #       }
()


def p_constraint_block_item_1(p):
    '''constraint_block_item : constraint_expression '''
    if(parse_debug):
        print('constraint_block_item_1', list(p))


()


def p_constraint_block_item_list_1(p):
    '''constraint_block_item_list : constraint_block_item_list constraint_block_item '''
    if(parse_debug):
        print('constraint_block_item_list_1', list(p))


()


def p_constraint_block_item_list_2(p):
    '''constraint_block_item_list : constraint_block_item '''
    if(parse_debug):
        print('constraint_block_item_list_2', list(p))


()


def p_constraint_block_item_list_opt_1(p):
    '''constraint_block_item_list_opt :  '''
    if(parse_debug):
        print('constraint_block_item_list_opt_1', list(p))


()


def p_constraint_block_item_list_opt_2(p):
    '''constraint_block_item_list_opt : constraint_block_item_list '''
    if(parse_debug):
        print('constraint_block_item_list_opt_2', list(p))


()


def p_constraint_declaration_1(p):
    '''constraint_declaration : K_static_opt K_constraint IDENTIFIER '{' constraint_block_item_list_opt '}' '''
    if(parse_debug):
        print('constraint_declaration_1', list(p))


    # { yyerror(@2, "sorry: Constraint declarations not supported."); }
()


def p_constraint_declaration_2(p):
    '''constraint_declaration : K_static_opt K_constraint IDENTIFIER '{' error '}' '''
    if(parse_debug):
        print('constraint_declaration_2', list(p))


    # { yyerror(@4, "error: Errors in the constraint block item list."); }
()


def p_constraint_expression_1(p):
    '''constraint_expression : expression ';' '''
    if(parse_debug):
        print('constraint_expression_1', list(p))


()


def p_constraint_expression_2(p):
    '''constraint_expression : expression K_dist '{' '}' ';' '''
    if(parse_debug):
        print('constraint_expression_2', list(p))


()


def p_constraint_expression_3(p):
    '''constraint_expression : expression K_TRIGGER constraint_set '''
    if(parse_debug):
        print('constraint_expression_3', list(p))


()


def p_constraint_expression_4(p):
    '''constraint_expression : K_if '(' expression ')' constraint_set %prec less_than_K_else '''
    if(parse_debug):
        print('constraint_expression_4', list(p))


()


def p_constraint_expression_5(p):
    '''constraint_expression : K_if '(' expression ')' constraint_set K_else constraint_set '''
    if(parse_debug):
        print('constraint_expression_5', list(p))


()


def p_constraint_expression_6(p):
    '''constraint_expression : K_foreach '(' IDENTIFIER '[' loop_variables ']' ')' constraint_set '''
    if(parse_debug):
        print('constraint_expression_6', list(p))


()


def p_constraint_expression_list_1(p):
    '''constraint_expression_list : constraint_expression_list constraint_expression '''
    if(parse_debug):
        print('constraint_expression_list_1', list(p))


()


def p_constraint_expression_list_2(p):
    '''constraint_expression_list : constraint_expression '''
    if(parse_debug):
        print('constraint_expression_list_2', list(p))


()


def p_constraint_prototype_1(p):
    '''constraint_prototype : K_static_opt K_constraint IDENTIFIER ';' '''
    if(parse_debug):
        print('constraint_prototype_1', list(p))


    # { yyerror(@2, "sorry: Constraint prototypes not supported."); }
()


def p_constraint_set_1(p):
    '''constraint_set : constraint_expression '''
    if(parse_debug):
        print('constraint_set_1', list(p))


()


def p_constraint_set_2(p):
    '''constraint_set : '{' constraint_expression_list '}' '''
    if(parse_debug):
        print('constraint_set_2', list(p))


()


def p_data_declaration_1(p):
    '''data_declaration : attribute_list_opt data_type_or_implicit list_of_variable_decl_assignments ';' '''
    if(parse_debug):
        print('data_declaration_1', list(p))


    # { data_type_t*data_type = p[2];
    #   if (data_type == 0) {
    #         data_type = new vector_type_t(IVL_VT_LOGIC, false, 0);
    #         FILE_NAME(data_type, @2);
    #   }
    #   pform_makewire(@2, 0, str_strength, p[3], NetNet::IMPLICIT_REG, data_type);
    #       }
()


def p_data_type_1(p):
    '''data_type : integer_vector_type unsigned_signed_opt dimensions_opt '''
    if(parse_debug):
        print('data_type_1', list(p))
    use_vtype = p[1]
    reg_flag = False
    if (use_vtype == IVL_VT_NO_TYPE):
        use_vtype = IVL_VT_LOGIC
        reg_flag = True
    dt = DataType(use_vtype, signed=p[2])
    dt.dims = p[3]
    dt.reg_flag = reg_flag
    p[0] = dt


    # { ivl_variable_type_t use_vtype = p[1];
    #   bool reg_flag = false;
    #   if (use_vtype == IVL_VT_NO_TYPE) {
    #         use_vtype = IVL_VT_LOGIC;
    #         reg_flag = true;
    #   }
    #   vector_type_t*tmp = new vector_type_t(use_vtype, p[2], p[3]);
    #   tmp->reg_flag = reg_flag;
    #   FILE_NAME(tmp, @1);
    #   p[0] = tmp;
    #       }
()


def p_data_type_2(p):
    '''data_type : non_integer_type '''
    if(parse_debug):
        print('data_type_2', list(p))
    p[0] = p[1]


    # { real_type_t*tmp = new real_type_t(p[1]);
    #   FILE_NAME(tmp, @1);
    #   p[0] = tmp;
    #       }
()


def p_data_type_3(p):
    '''data_type : struct_data_type '''
    if(parse_debug):
        print('data_type_3', list(p))
    p[0] = p[1]


    # { if (!p[1]->packed_flag) {
    #         yyerror(@1, "sorry: Unpacked structs not supported.");
    #   }
    #   p[0] = p[1];
    #       }
()


def p_data_type_4(p):
    '''data_type : enum_data_type '''
    if(parse_debug):
        print('data_type_4', list(p))
    p[0] = p[1]


()


def p_data_type_5(p):
    '''data_type : atom2_type signed_unsigned_opt '''
    if(parse_debug):
        print('data_type_5', list(p))


    # { atom2_type_t*tmp = new atom2_type_t(p[1], p[2]);
    #   FILE_NAME(tmp, @1);
    #   p[0] = tmp;
    #       }
()


def p_data_type_6(p):
    '''data_type : K_integer signed_unsigned_opt '''
    if(parse_debug):
        print('data_type_6', list(p))


    # { list<pform_range_t>*pd = make_range_from_width(integer_width);
    #   vector_type_t*tmp = new vector_type_t(IVL_VT_LOGIC, p[2], pd);
    #   tmp->reg_flag = true;
    #   tmp->integer_flag = true;
    #   p[0] = tmp;
    #       }
()


def p_data_type_7(p):
    '''data_type : K_time '''
    if(parse_debug):
        print('data_type_7', list(p))


    # { list<pform_range_t>*pd = make_range_from_width(64);
    #   vector_type_t*tmp = new vector_type_t(IVL_VT_LOGIC, false, pd);
    #   tmp->reg_flag = !gn_system_verilog();
    #   p[0] = tmp;
    #       }
()


def p_data_type_8(p):
    '''data_type : TYPE_IDENTIFIER dimensions_opt '''
    if(parse_debug):
        print('data_type_8', list(p))


    # { if (p[2]) {
    #         parray_type_t*tmp = new parray_type_t(p[1].type, p[2]);
    #         FILE_NAME(tmp, @1);
    #         p[0] = tmp;
    #   } else p[0] = p[1].type;
    #   delete[]p[1].text;
    #       }
()


def p_data_type_9(p):
    '''data_type : PACKAGE_IDENTIFIER K_SCOPE_RES _embed0_data_type TYPE_IDENTIFIER '''
    if(parse_debug):
        print('data_type_9', list(p))


    # { lex_in_package_scope(0);
    #   p[0] = p[4].type;
    #   delete[]p[4].text;
    #       }
()


def p_data_type_10(p):
    '''data_type : K_string '''
    if(parse_debug):
        print('data_type_10', list(p))


    # { string_type_t*tmp = new string_type_t;
    #   FILE_NAME(tmp, @1);
    #   p[0] = tmp;
    #       }
()


def p__embed0_data_type(p):
    '''_embed0_data_type : '''


    # { lex_in_package_scope(p[1]); }
()


def p_data_type_or_implicit_1(p):
    '''data_type_or_implicit : data_type '''
    if(parse_debug):
        print('data_type_or_implicit_1', list(p))
    p[0] = p[1]


()


def p_data_type_or_implicit_2(p):
    '''data_type_or_implicit : signing dimensions_opt '''
    if(parse_debug):
        print('data_type_or_implicit_2', list(p))


    # { vector_type_t*tmp = new vector_type_t(IVL_VT_LOGIC, p[1], p[2]);
    #   tmp->implicit_flag = true;
    #   FILE_NAME(tmp, @1);
    #   p[0] = tmp;
    #       }
()


def p_data_type_or_implicit_3(p):
    '''data_type_or_implicit : dimensions '''
    if(parse_debug):
        print('data_type_or_implicit_3', list(p))
    p[0] = list(p)


    # { vector_type_t*tmp = new vector_type_t(IVL_VT_LOGIC, false, p[1]);
    #   tmp->implicit_flag = true;
    #   FILE_NAME(tmp, @1);
    #   p[0] = tmp;
    #       }
()


def p_data_type_or_implicit_4(p):
    '''data_type_or_implicit :  '''
    if(parse_debug > 2):
        print('data_type_or_implicit_4', list(p))


    # { p[0] = None }
()


def p_data_type_or_implicit_or_void_1(p):
    '''data_type_or_implicit_or_void : data_type_or_implicit '''
    if(parse_debug):
        print('data_type_or_implicit_or_void_1', list(p))
    p[0] = p[1]


()


def p_data_type_or_implicit_or_void_2(p):
    '''data_type_or_implicit_or_void : K_void '''
    if(parse_debug):
        print('data_type_or_implicit_or_void_2', list(p))


    # { void_type_t*tmp = new void_type_t;
    #   FILE_NAME(tmp, @1);
    #   p[0] = tmp;
    #       }
()


def p_description_1(p):
    '''description : module '''
    if(parse_debug > 2):
        print('description_1', list(p))


()


def p_description_2(p):
    '''description : udp_primitive '''
    if(parse_debug):
        print('description_2', list(p))


()


def p_description_3(p):
    '''description : config_declaration '''
    if(parse_debug):
        print('description_3', list(p))


()


def p_description_4(p):
    '''description : nature_declaration '''
    if(parse_debug):
        print('description_4', list(p))


()


def p_description_5(p):
    '''description : package_declaration '''
    if(parse_debug):
        print('description_5', list(p))


()


def p_description_6(p):
    '''description : discipline_declaration '''
    if(parse_debug):
        print('description_6', list(p))


()


def p_description_7(p):
    '''description : package_item '''
    if(parse_debug):
        print('description_7', list(p))


()


def p_description_8(p):
    '''description : KK_attribute '(' IDENTIFIER ',' STRING ',' STRING ')' '''
    if(parse_debug):
        print('description_8', list(p))


    # { perm_string tmp3 = lex_strings.make(p[3]);
    #   pform_set_type_attrib(tmp3, p[5], p[7]);
    #   delete[] p[3];
    #   delete[] p[5];
    #       }
()


def p_description_list_1(p):
    '''description_list : description '''
    if(parse_debug > 2):
        print('description_list_1', list(p))


()


def p_description_list_2(p):
    '''description_list : description_list description '''
    if(parse_debug):
        print('description_list_2', list(p))


()


def p_endnew_opt_1(p):
    '''endnew_opt : ':' K_new '''
    if(parse_debug):
        print('endnew_opt_1', list(p))


()


def p_endnew_opt_2(p):
    '''endnew_opt :  '''
    if(parse_debug):
        print('endnew_opt_2', list(p))


()


def p_dynamic_array_new_1(p):
    '''dynamic_array_new : K_new '[' expression ']' '''
    if(parse_debug):
        print('dynamic_array_new_1', list(p))


    # { p[0] = new PENewArray(p[3], 0);
    #   FILE_NAME(p[0], @1);
    #       }
()


def p_dynamic_array_new_2(p):
    '''dynamic_array_new : K_new '[' expression ']' '(' expression ')' '''
    if(parse_debug):
        print('dynamic_array_new_2', list(p))


    # { p[0] = new PENewArray(p[3], p[6]);
    #   FILE_NAME(p[0], @1);
    #       }
()


def p_for_step_1(p):
    '''for_step : lpvalue '=' expression '''
    if(parse_debug):
        print('for_step_1', list(p))


    # { PAssign*tmp = new PAssign(p[1],p[3]);
    #   FILE_NAME(tmp, @1);
    #   p[0] = tmp;
    #       }
()


def p_for_step_2(p):
    '''for_step : inc_or_dec_expression '''
    if(parse_debug):
        print('for_step_2', list(p))


    # { p[0] = pform_compressed_assign_from_inc_dec(@1, p[1]); }
()


def p_for_step_3(p):
    '''for_step : compressed_statement '''
    if(parse_debug):
        print('for_step_3', list(p))
    p[0] = p[1]


()


def p_function_declaration_1(p):
    '''function_declaration : K_function lifetime_opt data_type_or_implicit_or_void IDENTIFIER ';' _embed0_function_declaration function_item_list statement_or_null_list_opt K_endfunction _embed1_function_declaration endlabel_opt '''
    if(parse_debug):
        print('function_declaration_1', list(p))


    # { // Last step: check any closing name.
    #   if (p[11]) {
    #         if (strcmp(p[4],p[11]) != 0) {
    #               yyerror(@11, "error: End label doesn't match "
    #                            "function name");
    #         }
    #         if (! gn_system_verilog()) {
    #               yyerror(@11, "error: Function end labels require "
    #                            "SystemVerilog.");
    #         }
    #         delete[]p[11];
    #   }
    #   delete[]p[4];
    #       }
()


def p_function_declaration_2(p):
    '''function_declaration : K_function lifetime_opt data_type_or_implicit_or_void IDENTIFIER _embed2_function_declaration '(' tf_port_list_opt ')' ';' block_item_decls_opt statement_or_null_list_opt K_endfunction _embed3_function_declaration endlabel_opt '''
    if(parse_debug):
        print('function_declaration_2', list(p))


    # { // Last step: check any closing name.
    #   if (p[14]) {
    #         if (strcmp(p[4],p[14]) != 0) {
    #               yyerror(@14, "error: End label doesn't match "
    #                            "function name");
    #         }
    #         if (! gn_system_verilog()) {
    #               yyerror(@14, "error: Function end labels require "
    #                            "SystemVerilog.");
    #         }
    #         delete[]p[14];
    #   }
    #   delete[]p[4];
    #       }
()


def p_function_declaration_3(p):
    '''function_declaration : K_function lifetime_opt data_type_or_implicit_or_void IDENTIFIER error K_endfunction _embed4_function_declaration endlabel_opt '''
    if(parse_debug):
        print('function_declaration_3', list(p))


    # { // Last step: check any closing name.
    #   if (p[8]) {
    #         if (strcmp(p[4],p[8]) != 0) {
    #               yyerror(@8, "error: End label doesn't match function name");
    #         }
    #         if (! gn_system_verilog()) {
    #               yyerror(@8, "error: Function end labels require "
    #                            "SystemVerilog.");
    #         }
    #         delete[]p[8];
    #   }
    #   delete[]p[4];
    #       }
()


def p__embed0_function_declaration(p):
    '''_embed0_function_declaration : '''


    # { assert(current_function == 0);
    #   current_function = pform_push_function_scope(@1, p[4], p[2]);
    #       }
()


def p__embed1_function_declaration(p):
    '''_embed1_function_declaration : '''


    # { current_function->set_ports(p[7]);
    #   current_function->set_return(p[3]);
    #   current_function_set_statement(p[8]? @8 : @4, p[8]);
    #   pform_set_this_class(@4, current_function);
    #   pform_pop_scope();
    #   current_function = 0;
    #       }
()


def p__embed2_function_declaration(p):
    '''_embed2_function_declaration : '''


    # { assert(current_function == 0);
    #   current_function = pform_push_function_scope(@1, p[4], p[2]);
    #       }
()


def p__embed3_function_declaration(p):
    '''_embed3_function_declaration : '''


    # { current_function->set_ports(p[7]);
    #   current_function->set_return(p[3]);
    #   current_function_set_statement(p[11]? @11 : @4, p[11]);
    #   pform_set_this_class(@4, current_function);
    #   pform_pop_scope();
    #   current_function = 0;
    #   if (p[7]==0 && !gn_system_verilog()) {
    #         yyerror(@4, "error: Empty parenthesis syntax requires SystemVerilog.");
    #   }
    #       }
()


def p__embed4_function_declaration(p):
    '''_embed4_function_declaration : '''


    # { /* */
    #   if (current_function) {
    #         pform_pop_scope();
    #         current_function = 0;
    #   }
    #   assert(current_function == 0);
    #   yyerror(@1, "error: Syntax error defining function.");
    #   yyerrok;
    #       }
()


def p_import_export_1(p):
    '''import_export : K_import '''
    if(parse_debug):
        print('import_export_1', list(p))
    p[0] = True


()


def p_import_export_2(p):
    '''import_export : K_export '''
    if(parse_debug):
        print('import_export_2', list(p))
    p[0] = False


()


def p_implicit_class_handle_1(p):
    '''implicit_class_handle : K_this '''
    if(parse_debug):
        print('implicit_class_handle_1', list(p))


    # { p[0] = pform_create_this(); }
()


def p_implicit_class_handle_2(p):
    '''implicit_class_handle : K_super '''
    if(parse_debug):
        print('implicit_class_handle_2', list(p))


    # { p[0] = pform_create_super(); }
()


def p_inc_or_dec_expression_1(p):
    '''inc_or_dec_expression : K_INCR lpvalue %prec UNARY_PREC '''
    if(parse_debug):
        print('inc_or_dec_expression_1', list(p))


    # { PEUnary*tmp = new PEUnary('I', p[2]);
    #   FILE_NAME(tmp, @2);
    #   p[0] = tmp;
    #       }
()


def p_inc_or_dec_expression_2(p):
    '''inc_or_dec_expression : lpvalue K_INCR %prec UNARY_PREC '''
    if(parse_debug):
        print('inc_or_dec_expression_2', list(p))


    # { PEUnary*tmp = new PEUnary('i', p[1]);
    #   FILE_NAME(tmp, @1);
    #   p[0] = tmp;
    #       }
()


def p_inc_or_dec_expression_3(p):
    '''inc_or_dec_expression : K_DECR lpvalue %prec UNARY_PREC '''
    if(parse_debug):
        print('inc_or_dec_expression_3', list(p))


    # { PEUnary*tmp = new PEUnary('D', p[2]);
    #   FILE_NAME(tmp, @2);
    #   p[0] = tmp;
    #       }
()


def p_inc_or_dec_expression_4(p):
    '''inc_or_dec_expression : lpvalue K_DECR %prec UNARY_PREC '''
    if(parse_debug):
        print('inc_or_dec_expression_4', list(p))


    # { PEUnary*tmp = new PEUnary('d', p[1]);
    #   FILE_NAME(tmp, @1);
    #   p[0] = tmp;
    #       }
()


def p_inside_expression_1(p):
    '''inside_expression : expression K_inside '{' open_range_list '}' '''
    if(parse_debug):
        print('inside_expression_1', list(p))


    # { yyerror(@2, "sorry: \"inside\" expressions not supported yet.");
    #   p[0] = None
    #       }
()


def p_integer_vector_type_1(p):
    '''integer_vector_type : K_reg '''
    if(parse_debug):
        print('integer_vector_type_1', list(p))
    p[0] = IVL_VT_NO_TYPE


()


def p_integer_vector_type_2(p):
    '''integer_vector_type : K_bit '''
    if(parse_debug):
        print('integer_vector_type_2', list(p))
    p[0] = IVL_VT_BOOL


()


def p_integer_vector_type_3(p):
    '''integer_vector_type : K_logic '''
    if(parse_debug):
        print('integer_vector_type_3', list(p))
    p[0] = IVL_VT_LOGIC


()


def p_integer_vector_type_4(p):
    '''integer_vector_type : K_bool '''
    if(parse_debug):
        print('integer_vector_type_4', list(p))


    # { p[0] = IVL_VT_BOOL; }
()


def p_join_keyword_1(p):
    '''join_keyword : K_join '''
    if(parse_debug):
        print('join_keyword_1', list(p))


    # { p[0] = PBlock::BL_PAR; }
()


def p_join_keyword_2(p):
    '''join_keyword : K_join_none '''
    if(parse_debug):
        print('join_keyword_2', list(p))


    # { p[0] = PBlock::BL_JOIN_NONE; }
()


def p_join_keyword_3(p):
    '''join_keyword : K_join_any '''
    if(parse_debug):
        print('join_keyword_3', list(p))


    # { p[0] = PBlock::BL_JOIN_ANY; }
()


def p_jump_statement_1(p):
    '''jump_statement : K_break ';' '''
    if(parse_debug):
        print('jump_statement_1', list(p))


    # { yyerror(@1, "sorry: break statements not supported.");
    #   p[0] = None
    #       }
()


def p_jump_statement_2(p):
    '''jump_statement : K_return ';' '''
    if(parse_debug):
        print('jump_statement_2', list(p))


    # { PReturn*tmp = new PReturn(0);
    #   FILE_NAME(tmp, @1);
    #   p[0] = tmp;
    #       }
()


def p_jump_statement_3(p):
    '''jump_statement : K_return expression ';' '''
    if(parse_debug):
        print('jump_statement_3', list(p))


    # { PReturn*tmp = new PReturn(p[2]);
    #   FILE_NAME(tmp, @1);
    #   p[0] = tmp;
    #       }
()


def p_lifetime_1(p):
    '''lifetime : K_automatic '''
    if(parse_debug):
        print('lifetime_1', list(p))


    # { p[0] = LexicalScope::AUTOMATIC; }
()


def p_lifetime_2(p):
    '''lifetime : K_static '''
    if(parse_debug):
        print('lifetime_2', list(p))


    # { p[0] = LexicalScope::STATIC; }
()


def p_lifetime_opt_1(p):
    '''lifetime_opt : lifetime '''
    if(parse_debug):
        print('lifetime_opt_1', list(p))
    p[0] = p[1]


()


def p_lifetime_opt_2(p):
    '''lifetime_opt :  '''
    if(parse_debug > 2):
        print('lifetime_opt_2', list(p))


    # { p[0] = LexicalScope::INHERITED; }
()


def p_loop_statement_1(p):
    '''loop_statement : K_for '(' lpvalue '=' expression ';' expression ';' for_step ')' statement_or_null '''
    if(parse_debug):
        print('loop_statement_1', list(p))


    # { PForStatement*tmp = new PForStatement(p[3], p[5], p[7], p[9], p[11]);
    #   FILE_NAME(tmp, @1);
    #   p[0] = tmp;
    #       }
()


def p_loop_statement_2(p):
    '''loop_statement : K_for '(' data_type IDENTIFIER '=' expression ';' expression ';' for_step ')' _embed0_loop_statement statement_or_null '''
    if(parse_debug):
        print('loop_statement_2', list(p))


    # { pform_name_t tmp_hident;
    #   tmp_hident.push_back(name_component_t(lex_strings.make(p[4])));
    #
    #   PEIdent*tmp_ident = pform_new_ident(tmp_hident);
    #   FILE_NAME(tmp_ident, @4);
    #
    #   PForStatement*tmp_for = new PForStatement(tmp_ident, p[6], p[8], p[10], p[13]);
    #   FILE_NAME(tmp_for, @1);
    #
    #   pform_pop_scope();
    #   vector<Statement*>tmp_for_list (1);
    #   tmp_for_list[0] = tmp_for;
    #   PBlock*tmp_blk = current_block_stack.top();
    #   current_block_stack.pop();
    #   tmp_blk->set_statement(tmp_for_list);
    #   p[0] = tmp_blk;
    #   delete[]p[4];
    #       }
()


def p_loop_statement_3(p):
    '''loop_statement : K_forever statement_or_null '''
    if(parse_debug):
        print('loop_statement_3', list(p))


    # { PForever*tmp = new PForever(p[2]);
    #   FILE_NAME(tmp, @1);
    #   p[0] = tmp;
    #       }
()


def p_loop_statement_4(p):
    '''loop_statement : K_repeat '(' expression ')' statement_or_null '''
    if(parse_debug):
        print('loop_statement_4', list(p))


    # { PRepeat*tmp = new PRepeat(p[3], p[5]);
    #   FILE_NAME(tmp, @1);
    #   p[0] = tmp;
    #       }
()


def p_loop_statement_5(p):
    '''loop_statement : K_while '(' expression ')' statement_or_null '''
    if(parse_debug):
        print('loop_statement_5', list(p))


    # { PWhile*tmp = new PWhile(p[3], p[5]);
    #   FILE_NAME(tmp, @1);
    #   p[0] = tmp;
    #       }
()


def p_loop_statement_6(p):
    '''loop_statement : K_do statement_or_null K_while '(' expression ')' ';' '''
    if(parse_debug):
        print('loop_statement_6', list(p))


    # { PDoWhile*tmp = new PDoWhile(p[5], p[2]);
    #   FILE_NAME(tmp, @1);
    #   p[0] = tmp;
    #       }
()


def p_loop_statement_7(p):
    '''loop_statement : K_foreach '(' IDENTIFIER '[' loop_variables ']' ')' _embed1_loop_statement statement_or_null '''
    if(parse_debug):
        print('loop_statement_7', list(p))


    # { PForeach*tmp_for = pform_make_foreach(@1, p[3], p[5], p[9]);
    #
    #   pform_pop_scope();
    #   vector<Statement*>tmp_for_list(1);
    #   tmp_for_list[0] = tmp_for;
    #   PBlock*tmp_blk = current_block_stack.top();
    #   current_block_stack.pop();
    #   tmp_blk->set_statement(tmp_for_list);
    #   p[0] = tmp_blk;
    #       }
()


def p_loop_statement_8(p):
    '''loop_statement : K_for '(' lpvalue '=' expression ';' expression ';' error ')' statement_or_null '''
    if(parse_debug):
        print('loop_statement_8', list(p))


    # { p[0] = None
    #   yyerror(@1, "error: Error in for loop step assignment.");
    #       }
()


def p_loop_statement_9(p):
    '''loop_statement : K_for '(' lpvalue '=' expression ';' error ';' for_step ')' statement_or_null '''
    if(parse_debug):
        print('loop_statement_9', list(p))


    # { p[0] = None
    #   yyerror(@1, "error: Error in for loop condition expression.");
    #       }
()


def p_loop_statement_10(p):
    '''loop_statement : K_for '(' error ')' statement_or_null '''
    if(parse_debug):
        print('loop_statement_10', list(p))


    # { p[0] = None
    #   yyerror(@1, "error: Incomprehensible for loop.");
    #       }
()


def p_loop_statement_11(p):
    '''loop_statement : K_while '(' error ')' statement_or_null '''
    if(parse_debug):
        print('loop_statement_11', list(p))


    # { p[0] = None
    #   yyerror(@1, "error: Error in while loop condition.");
    #       }
()


def p_loop_statement_12(p):
    '''loop_statement : K_do statement_or_null K_while '(' error ')' ';' '''
    if(parse_debug):
        print('loop_statement_12', list(p))


    # { p[0] = None
    #   yyerror(@1, "error: Error in do/while loop condition.");
    #       }
()


def p_loop_statement_13(p):
    '''loop_statement : K_foreach '(' IDENTIFIER '[' error ']' ')' statement_or_null '''
    if(parse_debug):
        print('loop_statement_13', list(p))


    # { p[0] = None
    #         yyerror(@4, "error: Errors in foreach loop variables list.");
    #       }
()


def p__embed0_loop_statement(p):
    '''_embed0_loop_statement : '''


    # { static unsigned for_counter = 0;
    #   char for_block_name [64];
    #   snif(parse_debug): printf(for_block_name, sizeof for_block_name, "$ivl_for_loop%u", for_counter);
    #   for_counter += 1;
    #   PBlock*tmp = pform_push_block_scope(for_block_name, PBlock::BL_SEQ);
    #   FILE_NAME(tmp, @1);
    #   current_block_stack.push(tmp);
    #
    #   list<decl_assignment_t*>assign_list;
    #   decl_assignment_t*tmp_assign = new decl_assignment_t;
    #   tmp_assign->name = lex_strings.make(p[4]);
    #   assign_list.push_back(tmp_assign);
    #   pform_makewire(@4, 0, str_strength, &assign_list, NetNet::REG, p[3]);
    #       }
()


def p__embed1_loop_statement(p):
    '''_embed1_loop_statement : '''


    # { static unsigned foreach_counter = 0;
    #   char for_block_name[64];
    #   snif(parse_debug): printf(for_block_name, sizeof for_block_name, "$ivl_foreach%u", foreach_counter);
    #   foreach_counter += 1;
    #
    #   PBlock*tmp = pform_push_block_scope(for_block_name, PBlock::BL_SEQ);
    #   FILE_NAME(tmp, @1);
    #   current_block_stack.push(tmp);
    #
    #   pform_make_foreach_declarations(@1, p[5]);
    #       }
()


def p_list_of_variable_decl_assignments_1(p):
    '''list_of_variable_decl_assignments : variable_decl_assignment '''
    if(parse_debug):
        print('list_of_variable_decl_assignments_1', list(p))


    # { list<decl_assignment_t*>*tmp = new list<decl_assignment_t*>;
    #   tmp->push_back(p[1]);
    #   p[0] = tmp;
    #       }
()


def p_list_of_variable_decl_assignments_2(p):
    '''list_of_variable_decl_assignments : list_of_variable_decl_assignments ',' variable_decl_assignment '''
    if(parse_debug):
        print('list_of_variable_decl_assignments_2', list(p))


    # { list<decl_assignment_t*>*tmp = p[1];
    #   tmp->push_back(p[3]);
    #   p[0] = tmp;
    #       }
()


def p_variable_decl_assignment_1(p):
    '''variable_decl_assignment : IDENTIFIER dimensions_opt '''
    if(parse_debug):
        print('variable_decl_assignment_1', list(p))


    # { decl_assignment_t*tmp = new decl_assignment_t;
    #   tmp->name = lex_strings.make(p[1]);
    #   if (p[2]) {
    #         tmp->index = *p[2];
    #         delete p[2];
    #   }
    #   delete[]p[1];
    #   p[0] = tmp;
    #       }
()


def p_variable_decl_assignment_2(p):
    '''variable_decl_assignment : IDENTIFIER '=' expression '''
    if(parse_debug):
        print('variable_decl_assignment_2', list(p))


    # { decl_assignment_t*tmp = new decl_assignment_t;
    #   tmp->name = lex_strings.make(p[1]);
    #   tmp->expr .reset(p[3]);
    #   delete[]p[1];
    #   p[0] = tmp;
    #       }
()


def p_variable_decl_assignment_3(p):
    '''variable_decl_assignment : IDENTIFIER '=' K_new '(' ')' '''
    if(parse_debug):
        print('variable_decl_assignment_3', list(p))


    # { decl_assignment_t*tmp = new decl_assignment_t;
    #   tmp->name = lex_strings.make(p[1]);
    #   PENewClass*expr = new PENewClass;
    #   FILE_NAME(expr, @3);
    #   tmp->expr .reset(expr);
    #   delete[]p[1];
    #   p[0] = tmp;
    #       }
()


def p_loop_variables_1(p):
    '''loop_variables : loop_variables ',' IDENTIFIER '''
    if(parse_debug):
        print('loop_variables_1', list(p))


    # { list<perm_string>*tmp = p[1];
    #   tmp->push_back(lex_strings.make(p[3]));
    #   delete[]p[3];
    #   p[0] = tmp;
    #       }
()


def p_loop_variables_2(p):
    '''loop_variables : IDENTIFIER '''
    if(parse_debug):
        print('loop_variables_2', list(p))


    # { list<perm_string>*tmp = new list<perm_string>;
    #   tmp->push_back(lex_strings.make(p[1]));
    #   delete[]p[1];
    #   p[0] = tmp;
    #       }
()


def p_method_qualifier_1(p):
    '''method_qualifier : K_virtual '''
    if(parse_debug):
        print('method_qualifier_1', list(p))


()


def p_method_qualifier_2(p):
    '''method_qualifier : class_item_qualifier '''
    if(parse_debug):
        print('method_qualifier_2', list(p))


()


def p_method_qualifier_opt_1(p):
    '''method_qualifier_opt : method_qualifier '''
    if(parse_debug):
        print('method_qualifier_opt_1', list(p))


()


def p_method_qualifier_opt_2(p):
    '''method_qualifier_opt :  '''
    if(parse_debug):
        print('method_qualifier_opt_2', list(p))


()


def p_modport_declaration_1(p):
    '''modport_declaration : K_modport _embed0_modport_declaration modport_item_list ';' '''
    if(parse_debug):
        print('modport_declaration_1', list(p))


()


def p__embed0_modport_declaration(p):
    '''_embed0_modport_declaration : '''


    # { if (!pform_in_interface())
    #         yyerror(@1, "error: modport declarations are only allowed "
    #                     "in interfaces.");
    #       }
()


def p_modport_item_list_1(p):
    '''modport_item_list : modport_item '''
    if(parse_debug):
        print('modport_item_list_1', list(p))


()


def p_modport_item_list_2(p):
    '''modport_item_list : modport_item_list ',' modport_item '''
    if(parse_debug):
        print('modport_item_list_2', list(p))


()


def p_modport_item_1(p):
    '''modport_item : IDENTIFIER _embed0_modport_item '(' modport_ports_list ')' '''
    if(parse_debug):
        print('modport_item_1', list(p))


    # { pform_end_modport_item(@1); }
()


def p__embed0_modport_item(p):
    '''_embed0_modport_item : '''


    # { pform_start_modport_item(@1, p[1]); }
()


def p_modport_ports_list_1(p):
    '''modport_ports_list : modport_ports_declaration '''
    if(parse_debug):
        print('modport_ports_list_1', list(p))


()


def p_modport_ports_list_2(p):
    '''modport_ports_list : modport_ports_list ',' modport_ports_declaration '''
    if(parse_debug):
        print('modport_ports_list_2', list(p))


()


def p_modport_ports_list_3(p):
    '''modport_ports_list : modport_ports_list ',' modport_simple_port '''
    if(parse_debug):
        print('modport_ports_list_3', list(p))


    # { if (last_modport_port.type == MP_SIMPLE) {
    #         pform_add_modport_port(@3, last_modport_port.direction,
    #                                p[3]->name, p[3]->parm);
    #   } else {
    #         yyerror(@3, "error: modport expression not allowed here.");
    #   }
    #   delete p[3];
    #       }
()


def p_modport_ports_list_4(p):
    '''modport_ports_list : modport_ports_list ',' modport_tf_port '''
    if(parse_debug):
        print('modport_ports_list_4', list(p))


    # { if (last_modport_port.type != MP_TF)
    #         yyerror(@3, "error: task/function declaration not allowed here.");
    #       }
()


def p_modport_ports_list_5(p):
    '''modport_ports_list : modport_ports_list ',' IDENTIFIER '''
    if(parse_debug):
        print('modport_ports_list_5', list(p))


    # { if (last_modport_port.type == MP_SIMPLE) {
    #         pform_add_modport_port(@3, last_modport_port.direction,
    #                                lex_strings.make(p[3]), 0);
    #   } else if (last_modport_port.type != MP_TF) {
    #         yyerror(@3, "error: list of identifiers not allowed here.");
    #   }
    #   delete[] p[3];
    #       }
()


def p_modport_ports_list_6(p):
    '''modport_ports_list : modport_ports_list ',' '''
    if(parse_debug):
        print('modport_ports_list_6', list(p))


    # { yyerror(@2, "error: NULL port declarations are not allowed"); }
()


def p_modport_ports_declaration_1(p):
    '''modport_ports_declaration : attribute_list_opt port_direction IDENTIFIER '''
    if(parse_debug):
        print('modport_ports_declaration_1', list(p))


    # { last_modport_port.type = MP_SIMPLE;
    #   last_modport_port.direction = p[2];
    #   pform_add_modport_port(@3, p[2], lex_strings.make(p[3]), 0);
    #   delete[] p[3];
    #   delete p[1];
    #       }
()


def p_modport_ports_declaration_2(p):
    '''modport_ports_declaration : attribute_list_opt port_direction modport_simple_port '''
    if(parse_debug):
        print('modport_ports_declaration_2', list(p))


    # { last_modport_port.type = MP_SIMPLE;
    #   last_modport_port.direction = p[2];
    #   pform_add_modport_port(@3, p[2], p[3]->name, p[3]->parm);
    #   delete p[3];
    #   delete p[1];
    #       }
()


def p_modport_ports_declaration_3(p):
    '''modport_ports_declaration : attribute_list_opt import_export IDENTIFIER '''
    if(parse_debug):
        print('modport_ports_declaration_3', list(p))


    # { last_modport_port.type = MP_TF;
    #   last_modport_port.is_import = p[2];
    #   yyerror(@3, "sorry: modport task/function ports are not yet supported.");
    #   delete[] p[3];
    #   delete p[1];
    #       }
()


def p_modport_ports_declaration_4(p):
    '''modport_ports_declaration : attribute_list_opt import_export modport_tf_port '''
    if(parse_debug):
        print('modport_ports_declaration_4', list(p))


    # { last_modport_port.type = MP_TF;
    #   last_modport_port.is_import = p[2];
    #   yyerror(@3, "sorry: modport task/function ports are not yet supported.");
    #   delete p[1];
    #       }
()


def p_modport_ports_declaration_5(p):
    '''modport_ports_declaration : attribute_list_opt K_clocking IDENTIFIER '''
    if(parse_debug):
        print('modport_ports_declaration_5', list(p))


    # { last_modport_port.type = MP_CLOCKING;
    #   last_modport_port.direction = NetNet::NOT_A_PORT;
    #   yyerror(@3, "sorry: modport clocking declaration is not yet supported.");
    #   delete[] p[3];
    #   delete p[1];
    #       }
()


def p_modport_simple_port_1(p):
    '''modport_simple_port : '.' IDENTIFIER '(' expression ')' '''
    if(parse_debug):
        print('modport_simple_port_1', list(p))


    # { named_pexpr_t*tmp = new named_pexpr_t;
    #   tmp->name = lex_strings.make(p[2]);
    #   tmp->parm = p[4];
    #   delete[]p[2];
    #   p[0] = tmp;
    #       }
()


def p_modport_tf_port_1(p):
    '''modport_tf_port : K_task IDENTIFIER '''
    if(parse_debug):
        print('modport_tf_port_1', list(p))


()


def p_modport_tf_port_2(p):
    '''modport_tf_port : K_task IDENTIFIER '(' tf_port_list_opt ')' '''
    if(parse_debug):
        print('modport_tf_port_2', list(p))


()


def p_modport_tf_port_3(p):
    '''modport_tf_port : K_function data_type_or_implicit_or_void IDENTIFIER '''
    if(parse_debug):
        print('modport_tf_port_3', list(p))


()


def p_modport_tf_port_4(p):
    '''modport_tf_port : K_function data_type_or_implicit_or_void IDENTIFIER '(' tf_port_list_opt ')' '''
    if(parse_debug):
        print('modport_tf_port_4', list(p))


()


def p_non_integer_type_1(p):
    '''non_integer_type : K_real '''
    if(parse_debug):
        print('non_integer_type_1', list(p))


    # { p[0] = real_type_t::REAL; }
()


def p_non_integer_type_2(p):
    '''non_integer_type : K_realtime '''
    if(parse_debug):
        print('non_integer_type_2', list(p))


    # { p[0] = real_type_t::REAL; }
()


def p_non_integer_type_3(p):
    '''non_integer_type : K_shortreal '''
    if(parse_debug):
        print('non_integer_type_3', list(p))


    # { p[0] = real_type_t::SHORTREAL; }
()


def p_number_1(p):
    '''number : BASED_NUMBER '''
    if(parse_debug):
        print('number_1', list(p))

    p[1] = p[1].replace("'b", "0b")
    p[1] = p[1].replace("'x", "0x")
    num = Leaf(token.NUMBER, "%s" % (p[1]))
    p[0] = num


    # { p[0] = p[1]; based_size = 0;}
()


def p_number_2(p):
    '''number : DEC_NUMBER '''
    if(parse_debug):
        print('number_2', list(p))
    p[1] = p[1].replace("'b", "0b")
    p[1] = p[1].replace("'x", "0x")
    num = Leaf(token.NUMBER, "%s" % (p[1]))
    p[0] = num


    # { p[0] = p[1]; based_size = 0;}
()


def p_number_3(p):
    '''number : DEC_NUMBER BASED_NUMBER '''
    if(parse_debug):
        print('number_3', list(p))

    p[2] = p[2].replace("'b", "0b")
    p[2] = p[2].replace("'x", "0x")

    num = Leaf(token.NUMBER, "%s" % (p[2]))
    p[0] = num


    # { p[0] = pform_verinum_with_size(p[1],p[2], @2.text, @2.first_line);
    #          based_size = 0; }
()


def p_number_4(p):
    '''number : UNBASED_NUMBER '''
    if(parse_debug):
        print('number_4', list(p))


    # { p[0] = p[1]; based_size = 0;}
()


def p_number_5(p):
    '''number : DEC_NUMBER UNBASED_NUMBER '''
    if(parse_debug):
        print('number_5', list(p))


    # { yyerror(@1, "error: Unbased SystemVerilog literal cannot have "
    #                      "a size.");
    #          p[0] = p[1]; based_size = 0;}
()


def p_open_range_list_1(p):
    '''open_range_list : open_range_list ',' value_range '''
    if(parse_debug):
        print('open_range_list_1', list(p))


()


def p_open_range_list_2(p):
    '''open_range_list : value_range '''
    if(parse_debug):
        print('open_range_list_2', list(p))


()


def p_package_declaration_1(p):
    '''package_declaration : K_package lifetime_opt IDENTIFIER ';' _embed0_package_declaration timeunits_declaration_opt _embed1_package_declaration package_item_list_opt K_endpackage endlabel_opt '''
    if(parse_debug):
        print('package_declaration_1', list(p))


    # { pform_end_package_declaration(@1);
    #   // If an end label is present make sure it match the package name.
    #   if (p[10]) {
    #         if (strcmp(p[3],p[10]) != 0) {
    #               yyerror(@10, "error: End label doesn't match package name");
    #         }
    #         delete[]p[10];
    #   }
    #   delete[]p[3];
    #       }
()


def p__embed0_package_declaration(p):
    '''_embed0_package_declaration : '''


    # { pform_start_package_declaration(@1, p[3], p[2]); }
()


def p__embed1_package_declaration(p):
    '''_embed1_package_declaration : '''


    # { pform_set_scope_timescale(@1); }
()


def p_module_package_import_list_opt_1(p):
    '''module_package_import_list_opt :  '''
    if(parse_debug > 1):
        print('module_package_import_list_opt_1', list(p))


()


def p_module_package_import_list_opt_2(p):
    '''module_package_import_list_opt : package_import_list '''
    if(parse_debug):
        print('module_package_import_list_opt_2', list(p))


()


def p_package_import_list_1(p):
    '''package_import_list : package_import_declaration '''
    if(parse_debug):
        print('package_import_list_1', list(p))


()


def p_package_import_list_2(p):
    '''package_import_list : package_import_list package_import_declaration '''
    if(parse_debug):
        print('package_import_list_2', list(p))


()


def p_package_import_declaration_1(p):
    '''package_import_declaration : K_import package_import_item_list ';' '''
    if(parse_debug):
        print('package_import_declaration_1', list(p))


    # { }
()


def p_package_import_item_1(p):
    '''package_import_item : PACKAGE_IDENTIFIER K_SCOPE_RES IDENTIFIER '''
    if(parse_debug):
        print('package_import_item_1', list(p))


    # { pform_package_import(@2, p[1], p[3]);
    #   delete[]p[3];
    #       }
()


def p_package_import_item_2(p):
    '''package_import_item : PACKAGE_IDENTIFIER K_SCOPE_RES '*' '''
    if(parse_debug):
        print('package_import_item_2', list(p))


    # { pform_package_import(@2, p[1], 0);
    #       }
()


def p_package_import_item_list_1(p):
    '''package_import_item_list : package_import_item_list ',' package_import_item '''
    if(parse_debug):
        print('package_import_item_list_1', list(p))


()


def p_package_import_item_list_2(p):
    '''package_import_item_list : package_import_item '''
    if(parse_debug):
        print('package_import_item_list_2', list(p))


()


def p_package_item_1(p):
    '''package_item : timeunits_declaration '''
    if(parse_debug):
        print('package_item_1', list(p))


()


def p_package_item_2(p):
    '''package_item : K_parameter param_type parameter_assign_list ';' '''
    if(parse_debug):
        print('package_item_2', list(p))


()


def p_package_item_3(p):
    '''package_item : K_localparam param_type localparam_assign_list ';' '''
    if(parse_debug):
        print('package_item_3', list(p))


()


def p_package_item_4(p):
    '''package_item : type_declaration '''
    if(parse_debug):
        print('package_item_4', list(p))


()


def p_package_item_5(p):
    '''package_item : function_declaration '''
    if(parse_debug):
        print('package_item_5', list(p))


()


def p_package_item_6(p):
    '''package_item : task_declaration '''
    if(parse_debug):
        print('package_item_6', list(p))


()


def p_package_item_7(p):
    '''package_item : data_declaration '''
    if(parse_debug):
        print('package_item_7', list(p))


()


def p_package_item_8(p):
    '''package_item : class_declaration '''
    if(parse_debug):
        print('package_item_8', list(p))


()


def p_package_item_list_1(p):
    '''package_item_list : package_item_list package_item '''
    if(parse_debug):
        print('package_item_list_1', list(p))


()


def p_package_item_list_2(p):
    '''package_item_list : package_item '''
    if(parse_debug):
        print('package_item_list_2', list(p))


()


def p_package_item_list_opt_1(p):
    '''package_item_list_opt : package_item_list '''
    if(parse_debug):
        print('package_item_list_opt_1', list(p))


()


def p_package_item_list_opt_2(p):
    '''package_item_list_opt :  '''
    if(parse_debug):
        print('package_item_list_opt_2', list(p))


()


def p_port_direction_1(p):
    '''port_direction : K_input '''
    if(parse_debug):
        print('port_direction_1', list(p))


    # { p[0] = NetNet::PINPUT; }
()


def p_port_direction_2(p):
    '''port_direction : K_output '''
    if(parse_debug):
        print('port_direction_2', list(p))


    # { p[0] = NetNet::POUTPUT; }
()


def p_port_direction_3(p):
    '''port_direction : K_inout '''
    if(parse_debug):
        print('port_direction_3', list(p))


    # { p[0] = NetNet::PINOUT; }
()


def p_port_direction_4(p):
    '''port_direction : K_ref '''
    if(parse_debug):
        print('port_direction_4', list(p))


    # { p[0] = NetNet::PREF;
    #         if (!gn_system_verilog()) {
    #         yyerror(@1, "error: Reference ports (ref) require SystemVerilog.");
    #         p[0] = NetNet::PINPUT;
    #   }
    #       }
()


def p_port_direction_opt_1(p):
    '''port_direction_opt : port_direction '''
    if(parse_debug):
        print('port_direction_opt_1', list(p))
    p[0] = p[1]


()


def p_port_direction_opt_2(p):
    '''port_direction_opt :  '''
    if(parse_debug):
        print('port_direction_opt_2', list(p))


    # { p[0] = NetNet::PIMPLICIT; }
()


def p_property_expr_1(p):
    '''property_expr : expression '''
    if(parse_debug):
        print('property_expr_1', list(p))


()


def p_procedural_assertion_statement_1(p):
    '''procedural_assertion_statement : K_assert '(' expression ')' statement %prec less_than_K_else '''
    if(parse_debug):
        print('procedural_assertion_statement_1', list(p))


    # { yyerror(@1, "sorry: Simple immediate assertion statements not implemented.");
    #   p[0] = None
    #       }
()


def p_procedural_assertion_statement_2(p):
    '''procedural_assertion_statement : K_assert '(' expression ')' K_else statement '''
    if(parse_debug):
        print('procedural_assertion_statement_2', list(p))


    # { yyerror(@1, "sorry: Simple immediate assertion statements not implemented.");
    #   p[0] = None
    #       }
()


def p_procedural_assertion_statement_3(p):
    '''procedural_assertion_statement : K_assert '(' expression ')' statement K_else statement '''
    if(parse_debug):
        print('procedural_assertion_statement_3', list(p))


    # { yyerror(@1, "sorry: Simple immediate assertion statements not implemented.");
    #   p[0] = None
    #       }
()


def p_property_qualifier_1(p):
    '''property_qualifier : class_item_qualifier '''
    if(parse_debug):
        print('property_qualifier_1', list(p))


()


def p_property_qualifier_2(p):
    '''property_qualifier : random_qualifier '''
    if(parse_debug):
        print('property_qualifier_2', list(p))


()


def p_property_qualifier_opt_1(p):
    '''property_qualifier_opt : property_qualifier_list '''
    if(parse_debug):
        print('property_qualifier_opt_1', list(p))
    p[0] = p[1]


()


def p_property_qualifier_opt_2(p):
    '''property_qualifier_opt :  '''
    if(parse_debug):
        print('property_qualifier_opt_2', list(p))


    # { p[0] = property_qualifier_t::make_none(); }
()


def p_property_qualifier_list_1(p):
    '''property_qualifier_list : property_qualifier_list property_qualifier '''
    if(parse_debug):
        print('property_qualifier_list_1', list(p))


    # { p[0] = p[1] | p[2]; }
()


def p_property_qualifier_list_2(p):
    '''property_qualifier_list : property_qualifier '''
    if(parse_debug):
        print('property_qualifier_list_2', list(p))
    p[0] = p[1]


()


def p_property_spec_1(p):
    '''property_spec : clocking_event_opt property_spec_disable_iff_opt property_expr '''
    if(parse_debug):
        print('property_spec_1', list(p))


()


def p_property_spec_disable_iff_opt_1(p):
    '''property_spec_disable_iff_opt : K_disable K_iff '(' expression ')' '''
    if(parse_debug):
        print('property_spec_disable_iff_opt_1', list(p))


()


def p_property_spec_disable_iff_opt_2(p):
    '''property_spec_disable_iff_opt :  '''
    if(parse_debug):
        print('property_spec_disable_iff_opt_2', list(p))


()


def p_random_qualifier_1(p):
    '''random_qualifier : K_rand '''
    if(parse_debug):
        print('random_qualifier_1', list(p))


    # { p[0] = property_qualifier_t::make_rand(); }
()


def p_random_qualifier_2(p):
    '''random_qualifier : K_randc '''
    if(parse_debug):
        print('random_qualifier_2', list(p))


    # { p[0] = property_qualifier_t::make_randc(); }
()


def p_real_or_realtime_1(p):
    '''real_or_realtime : K_real '''
    if(parse_debug):
        print('real_or_realtime_1', list(p))


()


def p_real_or_realtime_2(p):
    '''real_or_realtime : K_realtime '''
    if(parse_debug):
        print('real_or_realtime_2', list(p))


()


def p_signing_1(p):
    '''signing : K_signed '''
    if(parse_debug):
        print('signing_1', list(p))
    p[0] = True


()


def p_signing_2(p):
    '''signing : K_unsigned '''
    if(parse_debug):
        print('signing_2', list(p))
    p[0] = False


()


def p_simple_type_or_string_1(p):
    '''simple_type_or_string : integer_vector_type '''
    if(parse_debug):
        print('simple_type_or_string_1', list(p))


    # { ivl_variable_type_t use_vtype = p[1];
    #   bool reg_flag = false;
    #   if (use_vtype == IVL_VT_NO_TYPE) {
    #         use_vtype = IVL_VT_LOGIC;
    #         reg_flag = true;
    #   }
    #   vector_type_t*tmp = new vector_type_t(use_vtype, false, 0);
    #   tmp->reg_flag = reg_flag;
    #   FILE_NAME(tmp, @1);
    #   p[0] = tmp;
    #       }
()


def p_simple_type_or_string_2(p):
    '''simple_type_or_string : non_integer_type '''
    if(parse_debug):
        print('simple_type_or_string_2', list(p))


    # { real_type_t*tmp = new real_type_t(p[1]);
    #   FILE_NAME(tmp, @1);
    #   p[0] = tmp;
    #       }
()


def p_simple_type_or_string_3(p):
    '''simple_type_or_string : atom2_type '''
    if(parse_debug):
        print('simple_type_or_string_3', list(p))


    # { atom2_type_t*tmp = new atom2_type_t(p[1], true);
    #   FILE_NAME(tmp, @1);
    #   p[0] = tmp;
    #       }
()


def p_simple_type_or_string_4(p):
    '''simple_type_or_string : K_integer '''
    if(parse_debug):
        print('simple_type_or_string_4', list(p))


    # { list<pform_range_t>*pd = make_range_from_width(integer_width);
    #   vector_type_t*tmp = new vector_type_t(IVL_VT_LOGIC, true, pd);
    #   tmp->reg_flag = true;
    #   tmp->integer_flag = true;
    #   p[0] = tmp;
    #       }
()


def p_simple_type_or_string_5(p):
    '''simple_type_or_string : K_time '''
    if(parse_debug):
        print('simple_type_or_string_5', list(p))


    # { list<pform_range_t>*pd = make_range_from_width(64);
    #   vector_type_t*tmp = new vector_type_t(IVL_VT_LOGIC, false, pd);
    #   tmp->reg_flag = !gn_system_verilog();
    #   p[0] = tmp;
    #       }
()


def p_simple_type_or_string_6(p):
    '''simple_type_or_string : TYPE_IDENTIFIER '''
    if(parse_debug):
        print('simple_type_or_string_6', list(p))


    # { p[0] = p[1].type;
    #   delete[]p[1].text;
    #       }
()


def p_simple_type_or_string_7(p):
    '''simple_type_or_string : PACKAGE_IDENTIFIER K_SCOPE_RES _embed0_simple_type_or_string TYPE_IDENTIFIER '''
    if(parse_debug):
        print('simple_type_or_string_7', list(p))


    # { lex_in_package_scope(0);
    #   p[0] = p[4].type;
    #   delete[]p[4].text;
    #       }
()


def p_simple_type_or_string_8(p):
    '''simple_type_or_string : K_string '''
    if(parse_debug):
        print('simple_type_or_string_8', list(p))


    # { string_type_t*tmp = new string_type_t;
    #   FILE_NAME(tmp, @1);
    #   p[0] = tmp;
    #       }
()


def p__embed0_simple_type_or_string(p):
    '''_embed0_simple_type_or_string : '''


    # { lex_in_package_scope(p[1]); }
()


def p_statement_1(p):
    '''statement : attribute_list_opt statement_item '''
    if(parse_debug):
        print('statement_1', list(p))

    # { pform_bind_attributes(p[2]->attributes, p[1]);
    p[0] = p[2]

    #       }
()


def p_statement_or_null_1(p):
    '''statement_or_null : statement '''
    if(parse_debug):
        print('statement_or_null_1', list(p))
    p[0] = p[1]


()


def p_statement_or_null_2(p):
    '''statement_or_null : attribute_list_opt ';' '''
    if(parse_debug):
        print('statement_or_null_2', list(p))

    raise(Exception("p_statement_or_null_2"))


    # { p[0] = None }
()


def p_stream_expression_1(p):
    '''stream_expression : expression '''
    if(parse_debug):
        print('stream_expression_1', list(p))


()


def p_stream_expression_list_1(p):
    '''stream_expression_list : stream_expression_list ',' stream_expression '''
    if(parse_debug):
        print('stream_expression_list_1', list(p))


()


def p_stream_expression_list_2(p):
    '''stream_expression_list : stream_expression '''
    if(parse_debug):
        print('stream_expression_list_2', list(p))


()


def p_stream_operator_1(p):
    '''stream_operator : K_LS '''
    if(parse_debug):
        print('stream_operator_1', list(p))


()


def p_stream_operator_2(p):
    '''stream_operator : K_RS '''
    if(parse_debug):
        print('stream_operator_2', list(p))


()


def p_streaming_concatenation_1(p):
    '''streaming_concatenation : '{' stream_operator '{' stream_expression_list '}' '}' '''
    if(parse_debug):
        print('streaming_concatenation_1', list(p))


    # { /* streaming concatenation is a SystemVerilog thing. */
    #   if (gn_system_verilog()) {
    #         yyerror(@2, "sorry: Streaming concatenation not supported.");
    #         p[0] = None
    #   } else {
    #         yyerror(@2, "error: Streaming concatenation requires SystemVerilog");
    #         p[0] = None
    #   }
    #       }
()


def p_task_declaration_1(p):
    '''task_declaration : K_task lifetime_opt IDENTIFIER ';' _embed0_task_declaration task_item_list_opt statement_or_null_list_opt K_endtask _embed1_task_declaration endlabel_opt '''
    if(parse_debug):
        print('task_declaration_1', list(p))


    # { // Last step: check any closing name. This is done late so
    #   // that the parser can look ahead to detect the present
    #   // endlabel_opt but still have the pform_endmodule() called
    #   // early enough that the lexor can know we are outside the
    #   // module.
    #   if (p[10]) {
    #         if (strcmp(p[3],p[10]) != 0) {
    #               yyerror(@10, "error: End label doesn't match task name");
    #         }
    #         if (! gn_system_verilog()) {
    #               yyerror(@10, "error: Task end labels require "
    #                            "SystemVerilog.");
    #         }
    #         delete[]p[10];
    #   }
    #   delete[]p[3];
    #       }
()


def p_task_declaration_2(p):
    '''task_declaration : K_task lifetime_opt IDENTIFIER '(' _embed2_task_declaration tf_port_list ')' ';' block_item_decls_opt statement_or_null_list_opt K_endtask _embed3_task_declaration endlabel_opt '''
    if(parse_debug):
        print('task_declaration_2', list(p))


    # { // Last step: check any closing name. This is done late so
    #   // that the parser can look ahead to detect the present
    #   // endlabel_opt but still have the pform_endmodule() called
    #   // early enough that the lexor can know we are outside the
    #   // module.
    #   if (p[13]) {
    #         if (strcmp(p[3],p[13]) != 0) {
    #               yyerror(@13, "error: End label doesn't match task name");
    #         }
    #         if (! gn_system_verilog()) {
    #               yyerror(@13, "error: Task end labels require "
    #                            "SystemVerilog.");
    #         }
    #         delete[]p[13];
    #   }
    #   delete[]p[3];
    #       }
()


def p_task_declaration_3(p):
    '''task_declaration : K_task lifetime_opt IDENTIFIER '(' ')' ';' _embed4_task_declaration block_item_decls_opt statement_or_null_list K_endtask _embed5_task_declaration endlabel_opt '''
    if(parse_debug):
        print('task_declaration_3', list(p))


    # { // Last step: check any closing name. This is done late so
    #   // that the parser can look ahead to detect the present
    #   // endlabel_opt but still have the pform_endmodule() called
    #   // early enough that the lexor can know we are outside the
    #   // module.
    #   if (p[12]) {
    #         if (strcmp(p[3],p[12]) != 0) {
    #               yyerror(@12, "error: End label doesn't match task name");
    #         }
    #         if (! gn_system_verilog()) {
    #               yyerror(@12, "error: Task end labels require "
    #                            "SystemVerilog.");
    #         }
    #         delete[]p[12];
    #   }
    #   delete[]p[3];
    #       }
()


def p_task_declaration_4(p):
    '''task_declaration : K_task lifetime_opt IDENTIFIER error K_endtask _embed6_task_declaration endlabel_opt '''
    if(parse_debug):
        print('task_declaration_4', list(p))


    # { // Last step: check any closing name. This is done late so
    #   // that the parser can look ahead to detect the present
    #   // endlabel_opt but still have the pform_endmodule() called
    #   // early enough that the lexor can know we are outside the
    #   // module.
    #   if (p[7]) {
    #         if (strcmp(p[3],p[7]) != 0) {
    #               yyerror(@7, "error: End label doesn't match task name");
    #         }
    #         if (! gn_system_verilog()) {
    #               yyerror(@7, "error: Task end labels require "
    #                            "SystemVerilog.");
    #         }
    #         delete[]p[7];
    #   }
    #   delete[]p[3];
    #       }
()


def p__embed0_task_declaration(p):
    '''_embed0_task_declaration : '''


    # { assert(current_task == 0);
    #   current_task = pform_push_task_scope(@1, p[3], p[2]);
    #       }
()


def p__embed1_task_declaration(p):
    '''_embed1_task_declaration : '''


    # { current_task->set_ports(p[6]);
    #   current_task_set_statement(@3, p[7]);
    #   pform_set_this_class(@3, current_task);
    #   pform_pop_scope();
    #   current_task = 0;
    #   if (p[7] && p[7]->size() > 1 && !gn_system_verilog()) {
    #         yyerror(@7, "error: Task body with multiple statements requires SystemVerilog.");
    #   }
    #   delete p[7];
    #       }
()


def p__embed2_task_declaration(p):
    '''_embed2_task_declaration : '''


    # { assert(current_task == 0);
    #   current_task = pform_push_task_scope(@1, p[3], p[2]);
    #       }
()


def p__embed3_task_declaration(p):
    '''_embed3_task_declaration : '''


    # { current_task->set_ports(p[6]);
    #   current_task_set_statement(@3, p[10]);
    #   pform_set_this_class(@3, current_task);
    #   pform_pop_scope();
    #   current_task = 0;
    #   if (p[10]) delete p[10];
    #       }
()


def p__embed4_task_declaration(p):
    '''_embed4_task_declaration : '''


    # { assert(current_task == 0);
    #   current_task = pform_push_task_scope(@1, p[3], p[2]);
    #       }
()


def p__embed5_task_declaration(p):
    '''_embed5_task_declaration : '''


    # { current_task->set_ports(0);
    #   current_task_set_statement(@3, p[9]);
    #   pform_set_this_class(@3, current_task);
    #   if (! current_task->method_of()) {
    #         cerr << @3 << ": warning: task definition for \"" << p[3]
    #              << "\" has an empty port declaration list!" << endl;
    #   }
    #   pform_pop_scope();
    #   current_task = 0;
    #   if (p[9]->size() > 1 && !gn_system_verilog()) {
    #         yyerror(@9, "error: Task body with multiple statements requires SystemVerilog.");
    #   }
    #   delete p[9];
    #       }
()


def p__embed6_task_declaration(p):
    '''_embed6_task_declaration : '''


    # {
    #   if (current_task) {
    #         pform_pop_scope();
    #         current_task = 0;
    #   }
    #       }
()


def p_tf_port_declaration_1(p):
    '''tf_port_declaration : port_direction K_reg_opt unsigned_signed_opt dimensions_opt list_of_identifiers ';' '''
    if(parse_debug):
        print('tf_port_declaration_1', list(p))


    # { vector<pform_tf_port_t>*tmp = pform_make_task_ports(@1, p[1],
    #                                           p[2] ? IVL_VT_LOGIC :
    #                                                IVL_VT_NO_TYPE,
    #                                           p[3], p[4], p[5]);
    #   p[0] = tmp;
    #       }
()


def p_tf_port_declaration_2(p):
    '''tf_port_declaration : port_direction K_integer list_of_identifiers ';' '''
    if(parse_debug):
        print('tf_port_declaration_2', list(p))


    # { list<pform_range_t>*range_stub = make_range_from_width(integer_width);
    #   vector<pform_tf_port_t>*tmp = pform_make_task_ports(@1, p[1], IVL_VT_LOGIC, true,
    #                                               range_stub, p[3], true);
    #   p[0] = tmp;
    #       }
()


def p_tf_port_declaration_3(p):
    '''tf_port_declaration : port_direction K_time list_of_identifiers ';' '''
    if(parse_debug):
        print('tf_port_declaration_3', list(p))


    # { list<pform_range_t>*range_stub = make_range_from_width(64);
    #   vector<pform_tf_port_t>*tmp = pform_make_task_ports(@1, p[1], IVL_VT_LOGIC, false,
    #                                              range_stub, p[3]);
    #   p[0] = tmp;
    #       }
()


def p_tf_port_declaration_4(p):
    '''tf_port_declaration : port_direction real_or_realtime list_of_identifiers ';' '''
    if(parse_debug):
        print('tf_port_declaration_4', list(p))


    # { vector<pform_tf_port_t>*tmp = pform_make_task_ports(@1, p[1], IVL_VT_REAL, true,
    #                                              0, p[3]);
    #   p[0] = tmp;
    #       }
()


def p_tf_port_declaration_5(p):
    '''tf_port_declaration : port_direction K_string list_of_identifiers ';' '''
    if(parse_debug):
        print('tf_port_declaration_5', list(p))


    # { vector<pform_tf_port_t>*tmp = pform_make_task_ports(@1, p[1], IVL_VT_STRING, true,
    #                                              0, p[3]);
    #   p[0] = tmp;
    #       }
()


def p_tf_port_item_1(p):
    '''tf_port_item : port_direction_opt data_type_or_implicit IDENTIFIER dimensions_opt tf_port_item_expr_opt '''
    if(parse_debug):
        print('tf_port_item_1', list(p))


    # { vector<pform_tf_port_t>*tmp;
    #   NetNet::PortType use_port_type = p[1];
    #         if ((use_port_type == NetNet::PIMPLICIT) && (gn_system_verilog() || (p[2] == 0)))
    #               use_port_type = port_declaration_context.port_type;
    #   perm_string name = lex_strings.make(p[3]);
    #   list<perm_string>* ilist = list_from_identifier(p[3]);
    #
    #   if (use_port_type == NetNet::PIMPLICIT) {
    #         yyerror(@1, "error: missing task/function port direction.");
    #         use_port_type = NetNet::PINPUT; // for error recovery
    #   }
    #   if ((p[2] == 0) && (p[1]==NetNet::PIMPLICIT)) {
    #           // Detect special case this is an undecorated
    #           // identifier and we need to get the declaration from
    #           // left context.
    #         if (p[4] != 0) {
    #               yyerror(@4, "internal error: How can there be an unpacked range here?\n");
    #         }
    #         tmp = pform_make_task_ports(@3, use_port_type,
    #                                     port_declaration_context.data_type,
    #                                     ilist);
    #
    #   } else {
    #           // Otherwise, the decorations for this identifier
    #           // indicate the type. Save the type for any right
    #           // context that may come later.
    #         port_declaration_context.port_type = use_port_type;
    #         if (p[2] == 0) {
    #               p[2] = new vector_type_t(IVL_VT_LOGIC, false, 0);
    #               FILE_NAME(p[2], @3);
    #         }
    #         port_declaration_context.data_type = p[2];
    #         tmp = pform_make_task_ports(@3, use_port_type, p[2], ilist);
    #   }
    #   if (p[4] != 0) {
    #         pform_set_reg_idx(name, p[4]);
    #   }
    #
    #   p[0] = tmp;
    #   if (p[5]) {
    #         assert(tmp->size()==1);
    #         tmp->front().defe = p[5];
    #   }
    #       }
()


def p_tf_port_item_2(p):
    '''tf_port_item : port_direction_opt data_type_or_implicit IDENTIFIER error '''
    if(parse_debug):
        print('tf_port_item_2', list(p))


    # { yyerror(@3, "error: Error in task/function port item after port name %s.", p[3]);
    #   yyerrok;
    #   p[0] = None
    #       }
()


def p_tf_port_item_expr_opt_1(p):
    '''tf_port_item_expr_opt : '=' expression '''
    if(parse_debug):
        print('tf_port_item_expr_opt_1', list(p))


    # { if (! gn_system_verilog()) {
    #         yyerror(@1, "error: Task/function default arguments require "
    #                     "SystemVerilog.");
    #   }
    #   p[0] = p[2];
    #       }
()


def p_tf_port_item_expr_opt_2(p):
    '''tf_port_item_expr_opt :  '''
    if(parse_debug):
        print('tf_port_item_expr_opt_2', list(p))


    # { p[0] = None }
()


def p_tf_port_list_1(p):
    '''tf_port_list : _embed0_tf_port_list tf_port_item_list '''
    if(parse_debug):
        print('tf_port_list_1', list(p))
    p[0] = p[2]


()


def p__embed0_tf_port_list(p):
    '''_embed0_tf_port_list : '''


    # { port_declaration_context.port_type = gn_system_verilog() ? NetNet::PINPUT : NetNet::PIMPLICIT;
    #   port_declaration_context.data_type = 0;
    #       }
()


def p_tf_port_item_list_1(p):
    '''tf_port_item_list : tf_port_item_list ',' tf_port_item '''
    if(parse_debug):
        print('tf_port_item_list_1', list(p))


    # { vector<pform_tf_port_t>*tmp;
    #   if (p[1] && p[3]) {
    #         size_t s1 = p[1]->size();
    #         tmp = p[1];
    #         tmp->resize(tmp->size()+p[3]->size());
    #         for (size_t idx = 0 ; idx < p[3]->size() ; idx += 1)
    #               tmp->at(s1+idx) = p[3]->at(idx);
    #         delete p[3];
    #   } else if (p[1]) {
    #         tmp = p[1];
    #   } else {
    #         tmp = p[3];
    #   }
    #   p[0] = tmp;
    #       }
()


def p_tf_port_item_list_2(p):
    '''tf_port_item_list : tf_port_item '''
    if(parse_debug):
        print('tf_port_item_list_2', list(p))
    p[0] = p[1]


()


def p_tf_port_item_list_3(p):
    '''tf_port_item_list : error ',' tf_port_item '''
    if(parse_debug):
        print('tf_port_item_list_3', list(p))


    # { yyerror(@2, "error: Syntax error in task/function port declaration.");
    #   p[0] = p[3];
    #       }
()


def p_tf_port_item_list_4(p):
    '''tf_port_item_list : tf_port_item_list ',' '''
    if(parse_debug):
        print('tf_port_item_list_4', list(p))


    # { yyerror(@2, "error: NULL port declarations are not allowed.");
    #   p[0] = p[1];
    #       }
()


def p_tf_port_item_list_5(p):
    '''tf_port_item_list : tf_port_item_list ';' '''
    if(parse_debug):
        print('tf_port_item_list_5', list(p))


    # { yyerror(@2, "error: ';' is an invalid port declaration separator.");
    #   p[0] = p[1];
    #       }
()


def p_timeunits_declaration_1(p):
    '''timeunits_declaration : K_timeunit TIME_LITERAL ';' '''
    if(parse_debug):
        print('timeunits_declaration_1', list(p))


    # { pform_set_timeunit(p[2], allow_timeunit_decl); }
()


def p_timeunits_declaration_2(p):
    '''timeunits_declaration : K_timeunit TIME_LITERAL '/' TIME_LITERAL ';' '''
    if(parse_debug):
        print('timeunits_declaration_2', list(p))


    # { bool initial_decl = allow_timeunit_decl && allow_timeprec_decl;
    #         pform_set_timeunit(p[2], initial_decl);
    #         pform_set_timeprec(p[4], initial_decl);
    #       }
()


def p_timeunits_declaration_3(p):
    '''timeunits_declaration : K_timeprecision TIME_LITERAL ';' '''
    if(parse_debug):
        print('timeunits_declaration_3', list(p))


    # { pform_set_timeprec(p[2], allow_timeprec_decl); }
()


def p_timeunits_declaration_opt_1(p):
    '''timeunits_declaration_opt : %prec no_timeunits_declaration '''
    if(parse_debug > 2):
        print('timeunits_declaration_opt_1', list(p))


()


def p_timeunits_declaration_opt_2(p):
    '''timeunits_declaration_opt : timeunits_declaration %prec one_timeunits_declaration '''
    if(parse_debug):
        print('timeunits_declaration_opt_2', list(p))


()


def p_timeunits_declaration_opt_3(p):
    '''timeunits_declaration_opt : timeunits_declaration timeunits_declaration '''
    if(parse_debug):
        print('timeunits_declaration_opt_3', list(p))


()


def p_value_range_1(p):
    '''value_range : expression '''
    if(parse_debug):
        print('value_range_1', list(p))


    # { }
()


def p_value_range_2(p):
    '''value_range : '[' expression ':' expression ']' '''
    if(parse_debug):
        print('value_range_2', list(p))


    # { }
()


def p_variable_dimension_1(p):
    '''variable_dimension : '[' expression ':' expression ']' '''
    if(parse_debug):
        print('variable_dimension_1', list(p))
    # { list<pform_range_t> *tmp = new list<pform_range_t>;
    #   pform_range_t index (p[2],p[4]);
    #   tmp->push_back(index);
    #   p[0] = tmp;
    #       }
    # XXX TODO: subscriptlist
    start = str(p[4])
    end = str(p[2])
    if end.endswith("-1"):
        end = end[:-2]
    elif end.isdigit():
        end = str(int(end)+1)
    else:
        end = "1+%s" % end
    p[0] = '[%s:%s]' % (start, end)  # python slice is LO:HI+1


()


def p_variable_dimension_2(p):
    '''variable_dimension : '[' expression ']' '''
    if(parse_debug):
        print('variable_dimension_2', list(p))


    # { // SystemVerilog canonical range
    #   if (!gn_system_verilog()) {
    #         warn_count += 1;
    #         cerr << @2 << ": warning: Use of SystemVerilog [size] dimension. "
    #              << "Use at least -g2005-sv to remove this warning." << endl;
    #   }
    #   list<pform_range_t> *tmp = new list<pform_range_t>;
    #   pform_range_t index;
    #   index.first = new PENumber(new verinum((uint64_t)0, integer_width));
    #   index.second = new PEBinary('-', p[2], new PENumber(new verinum((uint64_t)1, integer_width)));
    #   tmp->push_back(index);
    #   p[0] = tmp;
    #       }
()


def p_variable_dimension_3(p):
    '''variable_dimension : '[' ']' '''
    if(parse_debug):
        print('variable_dimension_3', list(p))


    # { list<pform_range_t> *tmp = new list<pform_range_t>;
    #   pform_range_t index (0,0);
    #   tmp->push_back(index);
    #   p[0] = tmp;
    #       }
()


def p_variable_dimension_4(p):
    '''variable_dimension : '[' '$' ']' '''
    if(parse_debug):
        print('variable_dimension_4', list(p))


    # { // SystemVerilog queue
    #   list<pform_range_t> *tmp = new list<pform_range_t>;
    #   pform_range_t index (new PENull,0);
    #   if (!gn_system_verilog()) {
    #         yyerror("error: Queue declarations require SystemVerilog.");
    #   }
    #   tmp->push_back(index);
    #   p[0] = tmp;
    #       }
()


def p_variable_lifetime_1(p):
    '''variable_lifetime : lifetime '''
    if(parse_debug):
        print('variable_lifetime_1', list(p))


    # { if (!gn_system_verilog()) {
    #         yyerror(@1, "error: overriding the default variable lifetime "
    #                     "requires SystemVerilog.");
    #   } else if (p[1] != pform_peek_scope()->default_lifetime) {
    #         yyerror(@1, "sorry: overriding the default variable lifetime "
    #                     "is not yet supported.");
    #   }
    #   var_lifetime = p[1];
    #       }
()


def p_attribute_list_opt_1(p):
    '''attribute_list_opt : attribute_instance_list '''
    if(parse_debug):
        print('attribute_list_opt_1', list(p))
    p[0] = p[1]


()


def p_attribute_list_opt_2(p):
    '''attribute_list_opt :  '''
    if(parse_debug > 2):
        print('attribute_list_opt_2', list(p))


    # { p[0] = None }
()


def p_attribute_instance_list_1(p):
    '''attribute_instance_list : K_PSTAR K_STARP '''
    if(parse_debug):
        print('attribute_instance_list_1', list(p))


    # { p[0] = None }
()


def p_attribute_instance_list_2(p):
    '''attribute_instance_list : K_PSTAR attribute_list K_STARP '''
    if(parse_debug):
        print('attribute_instance_list_2', list(p))
    p[0] = p[2]


()


def p_attribute_instance_list_3(p):
    '''attribute_instance_list : attribute_instance_list K_PSTAR K_STARP '''
    if(parse_debug):
        print('attribute_instance_list_3', list(p))
    p[0] = p[1]


()


def p_attribute_instance_list_4(p):
    '''attribute_instance_list : attribute_instance_list K_PSTAR attribute_list K_STARP '''
    if(parse_debug):
        print('attribute_instance_list_4', list(p))


    # { list<named_pexpr_t>*tmp = p[1];
    #   if (tmp) {
    #       tmp->splice(tmp->end(), *p[3]);
    #       delete p[3];
    #       p[0] = tmp;
    #   } else p[0] = p[3];
    #       }
()


def p_attribute_list_1(p):
    '''attribute_list : attribute_list ',' attribute '''
    if(parse_debug):
        print('attribute_list_1', list(p))


    # { list<named_pexpr_t>*tmp = p[1];
    #         tmp->push_back(*p[3]);
    #   delete p[3];
    #   p[0] = tmp;
    #       }
()


def p_attribute_list_2(p):
    '''attribute_list : attribute '''
    if(parse_debug):
        print('attribute_list_2', list(p))


    # { list<named_pexpr_t>*tmp = new list<named_pexpr_t>;
    #         tmp->push_back(*p[1]);
    #   delete p[1];
    #   p[0] = tmp;
    #       }
()


def p_attribute_1(p):
    '''attribute : IDENTIFIER '''
    if(parse_debug):
        print('attribute_1', list(p))


    # { named_pexpr_t*tmp = new named_pexpr_t;
    #             tmp->name = lex_strings.make(p[1]);
    #             tmp->parm = 0;
    #             delete[]p[1];
    #             p[0] = tmp;
    #           }
()


def p_attribute_2(p):
    '''attribute : IDENTIFIER '=' expression '''
    if(parse_debug):
        print('attribute_2', list(p))


    # { PExpr*tmp = p[3];
    #             named_pexpr_t*tmp2 = new named_pexpr_t;
    #             tmp2->name = lex_strings.make(p[1]);
    #             tmp2->parm = tmp;
    #             delete[]p[1];
    #             p[0] = tmp2;
    #           }
()


def p_block_item_decl_1(p):
    '''block_item_decl : data_type register_variable_list ';' '''
    if(parse_debug):
        print('block_item_decl_1', list(p))


    # { if (p[1]) pform_set_data_type(@1, p[1], p[2], NetNet::REG, attributes_in_context);
    #       }
()


def p_block_item_decl_2(p):
    '''block_item_decl : variable_lifetime data_type register_variable_list ';' '''
    if(parse_debug):
        print('block_item_decl_2', list(p))


    # { if (p[2]) pform_set_data_type(@2, p[2], p[3], NetNet::REG, attributes_in_context);
    #   var_lifetime = LexicalScope::INHERITED;
    #       }
()


def p_block_item_decl_3(p):
    '''block_item_decl : K_reg data_type register_variable_list ';' '''
    if(parse_debug):
        print('block_item_decl_3', list(p))


    # { if (p[2]) pform_set_data_type(@2, p[2], p[3], NetNet::REG, attributes_in_context);
    #       }
()


def p_block_item_decl_4(p):
    '''block_item_decl : variable_lifetime K_reg data_type register_variable_list ';' '''
    if(parse_debug):
        print('block_item_decl_4', list(p))


    # { if (p[3]) pform_set_data_type(@3, p[3], p[4], NetNet::REG, attributes_in_context);
    #   var_lifetime = LexicalScope::INHERITED;
    #       }
()


def p_block_item_decl_5(p):
    '''block_item_decl : K_event event_variable_list ';' '''
    if(parse_debug):
        print('block_item_decl_5', list(p))


    # { if (p[2]) pform_make_events(p[2], @1.text, @1.first_line);
    #       }
()


def p_block_item_decl_6(p):
    '''block_item_decl : K_parameter param_type parameter_assign_list ';' '''
    if(parse_debug):
        print('block_item_decl_6', list(p))


()


def p_block_item_decl_7(p):
    '''block_item_decl : K_localparam param_type localparam_assign_list ';' '''
    if(parse_debug):
        print('block_item_decl_7', list(p))


()


def p_block_item_decl_8(p):
    '''block_item_decl : type_declaration '''
    if(parse_debug):
        print('block_item_decl_8', list(p))


()


def p_block_item_decl_9(p):
    '''block_item_decl : K_integer error ';' '''
    if(parse_debug):
        print('block_item_decl_9', list(p))


    # { yyerror(@1, "error: syntax error in integer variable list.");
    #   yyerrok;
    #       }
()


def p_block_item_decl_10(p):
    '''block_item_decl : K_time error ';' '''
    if(parse_debug):
        print('block_item_decl_10', list(p))


    # { yyerror(@1, "error: syntax error in time variable list.");
    #   yyerrok;
    #       }
()


def p_block_item_decl_11(p):
    '''block_item_decl : K_parameter error ';' '''
    if(parse_debug):
        print('block_item_decl_11', list(p))


    # { yyerror(@1, "error: syntax error in parameter list.");
    #   yyerrok;
    #       }
()


def p_block_item_decl_12(p):
    '''block_item_decl : K_localparam error ';' '''
    if(parse_debug):
        print('block_item_decl_12', list(p))


    # { yyerror(@1, "error: syntax error localparam list.");
    #   yyerrok;
    #       }
()


def p_block_item_decls_1(p):
    '''block_item_decls : block_item_decl '''
    if(parse_debug):
        print('block_item_decls_1', list(p))


()


def p_block_item_decls_2(p):
    '''block_item_decls : block_item_decls block_item_decl '''
    if(parse_debug):
        print('block_item_decls_2', list(p))


()


def p_block_item_decls_opt_1(p):
    '''block_item_decls_opt : block_item_decls '''
    if(parse_debug):
        print('block_item_decls_opt_1', list(p))
    p[0] = True


()


def p_block_item_decls_opt_2(p):
    '''block_item_decls_opt :  '''
    if(parse_debug):
        print('block_item_decls_opt_2', list(p))
    p[0] = False


()


def p_type_declaration_1(p):
    '''type_declaration : K_typedef data_type IDENTIFIER dimensions_opt ';' '''
    if(parse_debug):
        print('type_declaration_1', list(p))


    # { perm_string name = lex_strings.make(p[3]);
    #   pform_set_typedef(name, p[2], p[4]);
    #   delete[]p[3];
    #       }
()


def p_type_declaration_2(p):
    '''type_declaration : K_typedef data_type TYPE_IDENTIFIER ';' '''
    if(parse_debug):
        print('type_declaration_2', list(p))


    # { perm_string name = lex_strings.make(p[3].text);
    #   if (pform_test_type_identifier_local(name)) {
    #         yyerror(@3, "error: Typedef identifier \"%s\" is already a type name.", p[3].text);
    #
    #   } else {
    #         pform_set_typedef(name, p[2], NULL);
    #   }
    #   delete[]p[3].text;
    #       }
()


def p_type_declaration_3(p):
    '''type_declaration : K_typedef K_class IDENTIFIER ';' '''
    if(parse_debug):
        print('type_declaration_3', list(p))


    # { // Create a synthetic typedef for the class name so that the
    #   // lexor detects the name as a type.
    #   perm_string name = lex_strings.make(p[3]);
    #   class_type_t*tmp = new class_type_t(name);
    #   FILE_NAME(tmp, @3);
    #   pform_set_typedef(name, tmp, NULL);
    #   delete[]p[3];
    #       }
()


def p_type_declaration_4(p):
    '''type_declaration : K_typedef K_enum IDENTIFIER ';' '''
    if(parse_debug):
        print('type_declaration_4', list(p))


    # { yyerror(@1, "sorry: Enum forward declarations not supported yet."); }
()


def p_type_declaration_5(p):
    '''type_declaration : K_typedef K_struct IDENTIFIER ';' '''
    if(parse_debug):
        print('type_declaration_5', list(p))


    # { yyerror(@1, "sorry: Struct forward declarations not supported yet."); }
()


def p_type_declaration_6(p):
    '''type_declaration : K_typedef K_union IDENTIFIER ';' '''
    if(parse_debug):
        print('type_declaration_6', list(p))


    # { yyerror(@1, "sorry: Union forward declarations not supported yet."); }
()


def p_type_declaration_7(p):
    '''type_declaration : K_typedef IDENTIFIER ';' '''
    if(parse_debug):
        print('type_declaration_7', list(p))


    # { // Create a synthetic typedef for the class name so that the
    #   // lexor detects the name as a type.
    #   perm_string name = lex_strings.make(p[2]);
    #   class_type_t*tmp = new class_type_t(name);
    #   FILE_NAME(tmp, @2);
    #   pform_set_typedef(name, tmp, NULL);
    #   delete[]p[2];
    #       }
()


def p_type_declaration_8(p):
    '''type_declaration : K_typedef error ';' '''
    if(parse_debug):
        print('type_declaration_8', list(p))


    # { yyerror(@2, "error: Syntax error in typedef clause.");
    #   yyerrok;
    #       }
()


def p_enum_data_type_1(p):
    '''enum_data_type : K_enum '{' enum_name_list '}' '''
    if(parse_debug):
        print('enum_data_type_1', list(p))


    # { enum_type_t*enum_type = new enum_type_t;
    #   FILE_NAME(enum_type, @1);
    #   enum_type->names .reset(p[3]);
    #   enum_type->base_type = IVL_VT_BOOL;
    #   enum_type->signed_flag = true;
    #   enum_type->integer_flag = false;
    #   enum_type->range.reset(make_range_from_width(32));
    #   p[0] = enum_type;
    #       }
()


def p_enum_data_type_2(p):
    '''enum_data_type : K_enum atom2_type signed_unsigned_opt '{' enum_name_list '}' '''
    if(parse_debug):
        print('enum_data_type_2', list(p))


    # { enum_type_t*enum_type = new enum_type_t;
    #   FILE_NAME(enum_type, @1);
    #   enum_type->names .reset(p[5]);
    #   enum_type->base_type = IVL_VT_BOOL;
    #   enum_type->signed_flag = p[3];
    #   enum_type->integer_flag = false;
    #   enum_type->range.reset(make_range_from_width(p[2]));
    #   p[0] = enum_type;
    #       }
()


def p_enum_data_type_3(p):
    '''enum_data_type : K_enum K_integer signed_unsigned_opt '{' enum_name_list '}' '''
    if(parse_debug):
        print('enum_data_type_3', list(p))


    # { enum_type_t*enum_type = new enum_type_t;
    #   FILE_NAME(enum_type, @1);
    #   enum_type->names .reset(p[5]);
    #   enum_type->base_type = IVL_VT_LOGIC;
    #   enum_type->signed_flag = p[3];
    #   enum_type->integer_flag = true;
    #   enum_type->range.reset(make_range_from_width(integer_width));
    #   p[0] = enum_type;
    #       }
()


def p_enum_data_type_4(p):
    '''enum_data_type : K_enum K_logic unsigned_signed_opt dimensions_opt '{' enum_name_list '}' '''
    if(parse_debug):
        print('enum_data_type_4', list(p))


    # { enum_type_t*enum_type = new enum_type_t;
    #   FILE_NAME(enum_type, @1);
    #   enum_type->names .reset(p[6]);
    #   enum_type->base_type = IVL_VT_LOGIC;
    #   enum_type->signed_flag = p[3];
    #   enum_type->integer_flag = false;
    #   enum_type->range.reset(p[4] ? p[4] : make_range_from_width(1));
    #   p[0] = enum_type;
    #       }
()


def p_enum_data_type_5(p):
    '''enum_data_type : K_enum K_reg unsigned_signed_opt dimensions_opt '{' enum_name_list '}' '''
    if(parse_debug):
        print('enum_data_type_5', list(p))


    # { enum_type_t*enum_type = new enum_type_t;
    #   FILE_NAME(enum_type, @1);
    #   enum_type->names .reset(p[6]);
    #   enum_type->base_type = IVL_VT_LOGIC;
    #   enum_type->signed_flag = p[3];
    #   enum_type->integer_flag = false;
    #   enum_type->range.reset(p[4] ? p[4] : make_range_from_width(1));
    #   p[0] = enum_type;
    #       }
()


def p_enum_data_type_6(p):
    '''enum_data_type : K_enum K_bit unsigned_signed_opt dimensions_opt '{' enum_name_list '}' '''
    if(parse_debug):
        print('enum_data_type_6', list(p))


    # { enum_type_t*enum_type = new enum_type_t;
    #   FILE_NAME(enum_type, @1);
    #   enum_type->names .reset(p[6]);
    #   enum_type->base_type = IVL_VT_BOOL;
    #   enum_type->signed_flag = p[3];
    #   enum_type->integer_flag = false;
    #   enum_type->range.reset(p[4] ? p[4] : make_range_from_width(1));
    #   p[0] = enum_type;
    #       }
()


def p_enum_name_list_1(p):
    '''enum_name_list : enum_name '''
    if(parse_debug):
        print('enum_name_list_1', list(p))


    # { p[0] = p[1];
    #       }
()


def p_enum_name_list_2(p):
    '''enum_name_list : enum_name_list ',' enum_name '''
    if(parse_debug):
        print('enum_name_list_2', list(p))


    # { list<named_pexpr_t>*lst = p[1];
    #   lst->splice(lst->end(), *p[3]);
    #   delete p[3];
    #   p[0] = lst;
    #       }
()


def p_pos_neg_number_1(p):
    '''pos_neg_number : number '''
    if(parse_debug):
        print('pos_neg_number_1', list(p))


    # { p[0] = p[1];
    #       }
()


def p_pos_neg_number_2(p):
    '''pos_neg_number : '-' number '''
    if(parse_debug):
        print('pos_neg_number_2', list(p))


    # { verinum tmp = -(*(p[2]));
    #   *(p[2]) = tmp;
    #   p[0] = p[2];
    #       }
()


def p_enum_name_1(p):
    '''enum_name : IDENTIFIER '''
    if(parse_debug):
        print('enum_name_1', list(p))


    # { perm_string name = lex_strings.make(p[1]);
    #   delete[]p[1];
    #   p[0] = make_named_number(name);
    #       }
()


def p_enum_name_2(p):
    '''enum_name : IDENTIFIER '[' pos_neg_number ']' '''
    if(parse_debug):
        print('enum_name_2', list(p))


    # { perm_string name = lex_strings.make(p[1]);
    #   long count = check_enum_seq_value(@1, p[3], false);
    #   delete[]p[1];
    #   p[0] = make_named_numbers(name, 0, count-1);
    #   delete p[3];
    #       }
()


def p_enum_name_3(p):
    '''enum_name : IDENTIFIER '[' pos_neg_number ':' pos_neg_number ']' '''
    if(parse_debug):
        print('enum_name_3', list(p))


    # { perm_string name = lex_strings.make(p[1]);
    #   p[0] = make_named_numbers(name, check_enum_seq_value(@1, p[3], true),
    #                                 check_enum_seq_value(@1, p[5], true));
    #   delete[]p[1];
    #   delete p[3];
    #   delete p[5];
    #       }
()


def p_enum_name_4(p):
    '''enum_name : IDENTIFIER '=' expression '''
    if(parse_debug):
        print('enum_name_4', list(p))


    # { perm_string name = lex_strings.make(p[1]);
    #   delete[]p[1];
    #   p[0] = make_named_number(name, p[3]);
    #       }
()


def p_enum_name_5(p):
    '''enum_name : IDENTIFIER '[' pos_neg_number ']' '=' expression '''
    if(parse_debug):
        print('enum_name_5', list(p))


    # { perm_string name = lex_strings.make(p[1]);
    #   long count = check_enum_seq_value(@1, p[3], false);
    #   p[0] = make_named_numbers(name, 0, count-1, p[6]);
    #   delete[]p[1];
    #   delete p[3];
    #       }
()


def p_enum_name_6(p):
    '''enum_name : IDENTIFIER '[' pos_neg_number ':' pos_neg_number ']' '=' expression '''
    if(parse_debug):
        print('enum_name_6', list(p))


    # { perm_string name = lex_strings.make(p[1]);
    #   p[0] = make_named_numbers(name, check_enum_seq_value(@1, p[3], true),
    #                                 check_enum_seq_value(@1, p[5], true), p[8]);
    #   delete[]p[1];
    #   delete p[3];
    #   delete p[5];
    #       }
()


def p_struct_data_type_1(p):
    '''struct_data_type : K_struct K_packed_opt '{' struct_union_member_list '}' '''
    if(par