// -*- mode: C++; c-file-style: "cc-mode" -*-
//*************************************************************************
// DESCRIPTION: Verilator: Bison grammer file
//
// Code available from: https://verilator.org
//
//*************************************************************************
//
// Copyright 2003-2020 by Wilson Snyder. This program is free software; you
// can redistribute it and/or modify it under the terms of either the GNU
// Lesser General Public License Version 3 or the Perl Artistic License
// Version 2.0.
// SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
//
//*************************************************************************
// Original code here by Paul Wasson and Duane Galbi
//*************************************************************************
// clang-format off

%{
#ifdef NEVER_JUST_FOR_CLANG_FORMAT
 }
#endif
// clang-format on
#include "V3Ast.h"
#include "V3Global.h"
#include "V3Config.h"
#include "V3ParseImp.h"  // Defines YYTYPE; before including bison header

#include <cstdlib>
#include <cstdarg>
#include <stack>

#define YYERROR_VERBOSE 1  // For prior to Bison 3.6
#define YYINITDEPTH 10000  // Older bisons ignore YYMAXDEPTH
#define YYMAXDEPTH 10000

// Pick up new lexer
#define yylex PARSEP->tokenToBison
#define BBUNSUP(fl, msg) (fl)->v3warn(E_UNSUPPORTED, msg)
#define GATEUNSUP(fl, tok) \
    { BBUNSUP((fl), "Unsupported: Verilog 1995 gate primitive: " << (tok)); }

//======================================================================
// Statics (for here only)

#define PARSEP V3ParseImp::parsep()
#define SYMP PARSEP->symp()
#define GRAMMARP V3ParseGrammar::singletonp()

class V3ParseGrammar {
public:
    bool m_impliedDecl = false;  // Allow implied wire declarations
    AstVarType m_varDecl;  // Type for next signal declaration (reg/wire/etc)
    bool m_varDeclTyped = false;  // Var got reg/wire for dedup check
    VDirection m_varIO;  // Direction for next signal declaration (reg/wire/etc)
    VLifetime m_varLifetime;  // Static/Automatic for next signal
    AstVar* m_varAttrp = nullptr;  // Current variable for attribute adding
    AstRange* m_gateRangep = nullptr;  // Current range for gate declarations
    AstCase* m_caseAttrp = nullptr;  // Current case statement for attribute adding
    AstNodeDType* m_varDTypep = nullptr;  // Pointer to data type for next signal declaration
    AstNodeDType* m_memDTypep = nullptr;  // Pointer to data type for next member declaration
    AstNodeModule* m_modp = nullptr;  // Last module for timeunits
    bool m_pinAnsi = false;  // In ANSI port list
    FileLine* m_instModuleFl = nullptr;  // Fileline of module referenced for instantiations
    string m_instModule;  // Name of module referenced for instantiations
    AstPin* m_instParamp = nullptr;  // Parameters for instantiations
    bool m_tracingParse = true;  // Tracing disable for parser

    int m_pinNum = -1;  // Pin number currently parsing
    std::stack<int> m_pinStack;  // Queue of pin numbers being parsed

    static int s_modTypeImpNum;  // Implicit type number, incremented each module

    // CONSTRUCTORS
    V3ParseGrammar() {
        m_varDecl = AstVarType::UNKNOWN;
        m_varIO = VDirection::NONE;
    }
    static V3ParseGrammar* singletonp() {
        static V3ParseGrammar singleton;
        return &singleton;
    }

    // METHODS
    AstNode* argWrapList(AstNode* nodep);
    bool allTracingOn(FileLine* fl) {
        return v3Global.opt.trace() && m_tracingParse && fl->tracingOn();
    }
    AstRange* scrubRange(AstNodeRange* rangep);
    AstNodeDType* createArray(AstNodeDType* basep, AstNodeRange* rangep, bool isPacked);
    AstVar* createVariable(FileLine* fileline, const string& name, AstNodeRange* arrayp,
                           AstNode* attrsp);
    AstNode* createSupplyExpr(FileLine* fileline, const string& name, int value);
    AstText* createTextQuoted(FileLine* fileline, const string& text) {
        string newtext = deQuote(fileline, text);
        return new AstText(fileline, newtext);
    }
    AstDisplay* createDisplayError(FileLine* fileline) {
        AstDisplay* nodep
            = new AstDisplay(fileline, AstDisplayType::DT_ERROR, "", nullptr, nullptr);
        nodep->addNext(new AstStop(fileline, true));
        return nodep;
    }
    AstNode* createGatePin(AstNode* exprp) {
        AstRange* rangep = m_gateRangep;
        if (!rangep) {
            return exprp;
        } else {
            return new AstGatePin(rangep->fileline(), exprp, rangep->cloneTree(true));
        }
    }
    AstNode* createTypedef(FileLine* fl, const string& name, AstNode* attrsp, AstNodeDType* basep,
                           AstNodeRange* rangep) {
        AstNode* nodep = new AstTypedef(fl, name, attrsp, VFlagChildDType(),
                                        GRAMMARP->createArray(basep, rangep, false));
        SYMP->reinsert(nodep);
        PARSEP->tagNodep(nodep);
        return nodep;
    }
    AstNode* createTypedefFwd(FileLine* fl, const string& name) {
        AstNode* nodep = new AstTypedefFwd(fl, name);
        SYMP->reinsert(nodep);
        PARSEP->tagNodep(nodep);
        return nodep;
    }
    void endLabel(FileLine* fl, AstNode* nodep, string* endnamep) {
        endLabel(fl, nodep->prettyName(), endnamep);
    }
    void endLabel(FileLine* fl, const string& name, string* endnamep) {
        if (fl && endnamep && *endnamep != "" && name != *endnamep
            && name != AstNode::prettyName(*endnamep)) {
            fl->v3warn(ENDLABEL, "End label '" << *endnamep << "' does not match begin label '"
                                               << name << "'");
        }
    }
    void setVarDecl(AstVarType type) { m_varDecl = type; }
    void setDType(AstNodeDType* dtypep) {
        if (m_varDTypep) VL_DO_CLEAR(m_varDTypep->deleteTree(), m_varDTypep = nullptr);
        m_varDTypep = dtypep;
    }
    void pinPush() {
        m_pinStack.push(m_pinNum);
        m_pinNum = 1;
    }
    void pinPop(FileLine* fl) {
        if (VL_UNCOVERABLE(m_pinStack.empty())) { fl->v3fatalSrc("Underflow of pin stack"); }
        m_pinNum = m_pinStack.top();
        m_pinStack.pop();
    }
    AstPackage* unitPackage(FileLine* fl) {
        // Find one made earlier?
        VSymEnt* symp = SYMP->symRootp()->findIdFlat(AstPackage::dollarUnitName());
        AstPackage* pkgp;
        if (!symp) {
            pkgp = PARSEP->rootp()->dollarUnitPkgAddp();
            SYMP->reinsert(pkgp, SYMP->symRootp());  // Don't push/pop scope as they're global
        } else {
            pkgp = VN_CAST(symp->nodep(), Package);
        }
        return pkgp;
    }
    AstNodeDType* addRange(AstBasicDType* dtypep, AstNodeRange* rangesp, bool isPacked) {
        // If dtypep isn't basic, don't use this, call createArray() instead
        if (!rangesp) {
            return dtypep;
        } else {
            // If rangesp is "wire [3:3][2:2][1:1] foo [5:5][4:4]"
            // then [1:1] becomes the basicdtype range; everything else is arraying
            // the final [5:5][4:4] will be passed in another call to createArray
            AstNodeRange* rangearraysp = nullptr;
            if (dtypep->isRanged()) {
                rangearraysp = rangesp;  // Already a range; everything is an array
            } else {
                AstNodeRange* finalp = rangesp;
                while (finalp->nextp()) finalp = VN_CAST(finalp->nextp(), Range);
                if (finalp != rangesp) {
                    finalp->unlinkFrBack();
                    rangearraysp = rangesp;
                }
                if (AstRange* finalRangep = VN_CAST(finalp, Range)) {  // not an UnsizedRange
                    if (dtypep->implicit()) {
                        // It's no longer implicit but a wire logic type
                        AstBasicDType* newp = new AstBasicDType(
                            dtypep->fileline(), AstBasicDTypeKwd::LOGIC, dtypep->numeric(),
                            dtypep->width(), dtypep->widthMin());
                        VL_DO_DANGLING(dtypep->deleteTree(), dtypep);
                        dtypep = newp;
                    }
                    dtypep->rangep(finalRangep);
                }
            }
            return createArray(dtypep, rangearraysp, isPacked);
        }
    }
    string deQuote(FileLine* fileline, string text);
    void checkDpiVer(FileLine* fileline, const string& str) {
        if (str != "DPI-C" && !v3Global.opt.bboxSys()) {
            fileline->v3error("Unsupported DPI type '" << str << "': Use 'DPI-C'");
        }
    }
};

const AstBasicDTypeKwd LOGIC = AstBasicDTypeKwd::LOGIC;  // Shorthand "LOGIC"
const AstBasicDTypeKwd LOGIC_IMPLICIT = AstBasicDTypeKwd::LOGIC_IMPLICIT;

int V3ParseGrammar::s_modTypeImpNum = 0;

//======================================================================
// Macro functions

#define CRELINE() \
    (PARSEP->copyOrSameFileLine())  // Only use in empty rules, so lines point at beginnings
#define FILELINE_OR_CRE(nodep) ((nodep) ? (nodep)->fileline() : CRELINE())

#define VARRESET_LIST(decl) \
    { \
        GRAMMARP->m_pinNum = 1; \
        GRAMMARP->m_pinAnsi = false; \
        VARRESET(); \
        VARDECL(decl); \
    }  // Start of pinlist
#define VARRESET_NONLIST(decl) \
    { \
        GRAMMARP->m_pinNum = 0; \
        GRAMMARP->m_pinAnsi = false; \
        VARRESET(); \
        VARDECL(decl); \
    }  // Not in a pinlist
#define VARRESET() \
    { \
        VARDECL(UNKNOWN); \
        VARIO(NONE); \
        VARDTYPE_NDECL(nullptr); \
        GRAMMARP->m_varLifetime = VLifetime::NONE; \
        GRAMMARP->m_varDeclTyped = false; \
    }
#define VARDECL(type) \
    { GRAMMARP->setVarDecl(AstVarType::type); }
#define VARIO(type) \
    { GRAMMARP->m_varIO = VDirection::type; }
#define VARLIFE(flag) \
    { GRAMMARP->m_varLifetime = flag; }
#define VARDTYPE(dtypep) \
    { \
        GRAMMARP->setDType(dtypep); \
        GRAMMARP->m_varDeclTyped = true; \
    }
#define VARDTYPE_NDECL(dtypep) \
    { GRAMMARP->setDType(dtypep); }  // Port that is range or signed only (not a decl)

#define VARDONEA(fl, name, array, attrs) GRAMMARP->createVariable((fl), (name), (array), (attrs))
#define VARDONEP(portp, array, attrs) \
    GRAMMARP->createVariable((portp)->fileline(), (portp)->name(), (array), (attrs))
#define PINNUMINC() (GRAMMARP->m_pinNum++)

#define GATERANGE(rangep) \
    { GRAMMARP->m_gateRangep = rangep; }

#define INSTPREP(modfl, modname, paramsp) \
    { \
        GRAMMARP->m_impliedDecl = true; \
        GRAMMARP->m_instModuleFl = modfl; \
        GRAMMARP->m_instModule = modname; \
        GRAMMARP->m_instParamp = paramsp; \
    }

#define DEL(nodep) \
    { \
        if (nodep) nodep->deleteTree(); \
    }

static void ERRSVKWD(FileLine* fileline, const string& tokname) {
    static int toldonce = 0;
    fileline->v3error(
        string("Unexpected '") + tokname + "': '" + tokname
        + "' is a SystemVerilog keyword misused as an identifier."
        + (!toldonce++ ? "\n" + V3Error::warnMore()
                             + "... Suggest modify the Verilog-2001 code to avoid SV keywords,"
                             + " or use `begin_keywords or --language."
                       : ""));
}

static void UNSUPREAL(FileLine* fileline) {
    fileline->v3warn(SHORTREAL,
                     "Unsupported: shortreal being promoted to real (suggest use real instead)");
}

//======================================================================

void yyerror(const char* errmsg) {
    PARSEP->bisonLastFileline()->v3error(errmsg);
    static const char* const colonmsg = "syntax error, unexpected";
}

void yyerrorf(const char* format, ...) {
    const int maxlen = 2000;
    char msg[maxlen];

    va_list ap;
    va_start(ap, format);
    VL_VSNPRINTF(msg, maxlen, format, ap);
    msg[maxlen - 1] = '\0';
    va_end(ap);

    yyerror(msg);
}

//======================================================================

class AstSenTree;
// clang-format off
%}

// Bison 3.0 and newer
BISONPRE_VERSION(3.0,%define parse.error verbose)

// We run bison with the -d argument. This tells it to generate a
// header file with token names. Old versions of bison pasted the
// contents of that file into the generated source as well; newer
// versions just include it.
//
// Since we run bison through ../bisonpre, it doesn't know the correct
// header file name, so we need to tell it.
BISONPRE_VERSION(3.7,%define api.header.include {"V3ParseBison.h"})

// When writing Bison patterns we use yTOKEN instead of "token",
// so Bison will error out on unknown "token"s.

// Generic lexer tokens, for example a number
// IEEE: real_number
%token<cdouble>         yaFLOATNUM      "FLOATING-POINT NUMBER"

// IEEE: identifier, class_identifier, class_variable_identifier,
// covergroup_variable_identifier, dynamic_array_variable_identifier,
// enum_identifier, interface_identifier, interface_instance_identifier,
// package_identifier, type_identifier, variable_identifier,
%token<strp>            yaID__ETC       "IDENTIFIER"
%token<strp>            yaID__CC        "IDENTIFIER-::"
%token<strp>            yaID__LEX       "IDENTIFIER-in-lex"
%token<strp>            yaID__aTYPE     "TYPE-IDENTIFIER"
//                      Can't predecode aFUNCTION, can declare after use
//                      Can't predecode aINTERFACE, can declare after use
//                      Can't predecode aTASK, can declare after use

// IEEE: integral_number
%token<nump>            yaINTNUM        "INTEGER NUMBER"
// IEEE: time_literal + time_unit
%token<cdouble>         yaTIMENUM       "TIME NUMBER"
// IEEE: string_literal
%token<strp>            yaSTRING        "STRING"
%token<strp>            yaSTRING__IGNORE "STRING-ignored"       // Used when expr:string not allowed

%token<fl>              yaTIMINGSPEC    "TIMING SPEC ELEMENT"

%token<fl>              ygenSTRENGTH    "STRENGTH keyword (strong1/etc)"

%token<strp>            yaTABLELINE     "TABLE LINE"

%token<strp>            yaSCHDR         "`systemc_header BLOCK"
%token<strp>            yaSCINT         "`systemc_ctor BLOCK"
%token<strp>            yaSCIMP         "`systemc_dtor BLOCK"
%token<strp>            yaSCIMPH        "`systemc_interface BLOCK"
%token<strp>            yaSCCTOR        "`systemc_implementation BLOCK"
%token<strp>            yaSCDTOR        "`systemc_imp_header BLOCK"

%token<fl>              yVLT_CLOCKER                "clocker"
%token<fl>              yVLT_CLOCK_ENABLE           "clock_enable"
%token<fl>              yVLT_COVERAGE_BLOCK_OFF     "coverage_block_off"
%token<fl>              yVLT_COVERAGE_OFF           "coverage_off"
%token<fl>              yVLT_COVERAGE_ON            "coverage_on"
%token<fl>              yVLT_FULL_CASE              "full_case"
%token<fl>              yVLT_HIER_BLOCK             "hier_block"
%token<fl>              yVLT_INLINE                 "inline"
%token<fl>              yVLT_ISOLATE_ASSIGNMENTS    "isolate_assignments"
%token<fl>              yVLT_LINT_OFF               "lint_off"
%token<fl>              yVLT_LINT_ON                "lint_on"
%token<fl>              yVLT_NO_CLOCKER             "no_clocker"
%token<fl>              yVLT_NO_INLINE              "no_inline"
%token<fl>              yVLT_PARALLEL_CASE          "parallel_case"
%token<fl>              yVLT_PUBLIC                 "public"
%token<fl>              yVLT_PUBLIC_FLAT            "public_flat"
%token<fl>              yVLT_PUBLIC_FLAT_RD         "public_flat_rd"
%token<fl>              yVLT_PUBLIC_FLAT_RW         "public_flat_rw"
%token<fl>              yVLT_PUBLIC_MODULE          "public_module"
%token<fl>              yVLT_SC_BV                  "sc_bv"
%token<fl>              yVLT_SFORMAT                "sformat"
%token<fl>              yVLT_SPLIT_VAR              "split_var"
%token<fl>              yVLT_TRACING_OFF            "tracing_off"
%token<fl>              yVLT_TRACING_ON             "tracing_on"

%token<fl>              yVLT_D_BLOCK    "--block"
%token<fl>              yVLT_D_FILE     "--file"
%token<fl>              yVLT_D_FUNCTION "--function"
%token<fl>              yVLT_D_LINES    "--lines"
%token<fl>              yVLT_D_MODULE   "--module"
%token<fl>              yVLT_D_MATCH    "--match"
%token<fl>              yVLT_D_MSG      "--msg"
%token<fl>              yVLT_D_RULE     "--rule"
%token<fl>              yVLT_D_TASK     "--task"
%token<fl>              yVLT_D_VAR      "--var"

%token<strp>            yaD_PLI         "${pli-system}"

%token<fl>              yaT_NOUNCONNECTED  "`nounconnecteddrive"
%token<fl>              yaT_RESETALL    "`resetall"
%token<fl>              yaT_UNCONNECTED_PULL0  "`unconnected_drive pull0"
%token<fl>              yaT_UNCONNECTED_PULL1  "`unconnected_drive pull1"

// <fl> is the fileline, abbreviated to shorten "$<fl>1" references
%token<fl>              '!'
%token<fl>              '#'
%token<fl>              '%'
%token<fl>              '&'
%token<fl>              '('  // See also yP_PAR__STRENGTH
%token<fl>              ')'
%token<fl>              '*'
%token<fl>              '+'
%token<fl>              ','
%token<fl>              '-'
%token<fl>              '.'
%token<fl>              '/'
%token<fl>              ':'  // See also yP_COLON__BEGIN or yP_COLON__FORK
%token<fl>              ';'
%token<fl>              '<'
%token<fl>              '='
%token<fl>              '>'
%token<fl>              '?'
%token<fl>              '@'
%token<fl>              '['
%token<fl>              ']'
%token<fl>              '^'
%token<fl>              '{'
%token<fl>              '|'
%token<fl>              '}'
%token<fl>              '~'

// Specific keywords
// yKEYWORD means match "keyword"
// Other cases are yXX_KEYWORD where XX makes it unique,
// for example yP_ for punctuation based operators.
// Double underscores "yX__Y" means token X followed by Y,
// and "yX__ETC" means X folled by everything but Y(s).
//UNSUP %token<fl>      yACCEPT_ON      "accept_on"
%token<fl>              yALIAS          "alias"
%token<fl>              yALWAYS         "always"
%token<fl>              yALWAYS_COMB    "always_comb"
%token<fl>              yALWAYS_FF      "always_ff"
%token<fl>              yALWAYS_LATCH   "always_latch"
%token<fl>              yAND            "and"
%token<fl>              yASSERT         "assert"
%token<fl>              yASSIGN         "assign"
%token<fl>              yASSUME         "assume"
%token<fl>              yAUTOMATIC      "automatic"
%token<fl>              yBEFORE         "before"
%token<fl>              yBEGIN          "begin"
%token<fl>              yBIND           "bind"
//UNSUP %token<fl>      yBINS           "bins"
//UNSUP %token<fl>      yBINSOF         "binsof"
%token<fl>              yBIT            "bit"
%token<fl>              yBREAK          "break"
%token<fl>              yBUF            "buf"
%token<fl>              yBUFIF0         "bufif0"
%token<fl>              yBUFIF1         "bufif1"
%token<fl>              yBYTE           "byte"
%token<fl>              yCASE           "case"
%token<fl>              yCASEX          "casex"
%token<fl>              yCASEZ          "casez"
%token<fl>              yCHANDLE        "chandle"
//UNSUP %token<fl>      yCHECKER        "checker"
%token<fl>              yCLASS          "class"
//UNSUP %token<fl>      yCLOCK          "clock"
%token<fl>              yCLOCKING       "clocking"
%token<fl>              yCMOS           "cmos"
%token<fl>              yCONSTRAINT     "constraint"
%token<fl>              yCONST__ETC     "const"
%token<fl>              yCONST__LEX     "const-in-lex"
//UNSUP %token<fl>      yCONST__LOCAL   "const-then-local"
%token<fl>              yCONST__REF     "const-then-ref"
%token<fl>              yCONTEXT        "context"
%token<fl>              yCONTINUE       "continue"
%token<fl>              yCOVER          "cover"
//UNSUP %token<fl>      yCOVERGROUP     "covergroup"
//UNSUP %token<fl>      yCOVERPOINT     "coverpoint"
//UNSUP %token<fl>      yCROSS          "cross"
%token<fl>              yDEASSIGN       "deassign"
%token<fl>              yDEFAULT        "default"
%token<fl>              yDEFPARAM       "defparam"
%token<fl>              yDISABLE        "disable"
%token<fl>              yDIST           "dist"
%token<fl>              yDO             "do"
%token<fl>              yEDGE           "edge"
%token<fl>              yELSE           "else"
%token<fl>              yEND            "end"
%token<fl>              yENDCASE        "endcase"
//UNSUP %token<fl>      yENDCHECKER     "endchecker"
%token<fl>              yENDCLASS       "endclass"
%token<fl>              yENDCLOCKING    "endclocking"
%token<fl>              yENDFUNCTION    "endfunction"
%token<fl>              yENDGENERATE    "endgenerate"
//UNSUP %token<fl>      yENDGROUP       "endgroup"
%token<fl>              yENDINTERFACE   "endinterface"
%token<fl>              yENDMODULE      "endmodule"
%token<fl>              yENDPACKAGE     "endpackage"
%token<fl>              yENDPRIMITIVE   "endprimitive"
%token<fl>              yENDPROGRAM     "endprogram"
%token<fl>              yENDPROPERTY    "endproperty"
//UNSUP %token<fl>      yENDSEQUENCE    "endsequence"
%token<fl>              yENDSPECIFY     "endspecify"
%token<fl>              yENDTABLE       "endtable"
%token<fl>              yENDTASK        "endtask"
%token<fl>              yENUM           "enum"
%token<fl>              yEVENT          "event"
//UNSUP %token<fl>      yEVENTUALLY     "eventually"
//UNSUP %token<fl>      yEXPECT         "expect"
%token<fl>              yEXPORT         "export"
%token<fl>              yEXTENDS        "extends"
%token<fl>              yEXTERN         "extern"
%token<fl>              yFINAL          "final"
//UNSUP %token<fl>      yFIRST_MATCH    "first_match"
%token<fl>              yFOR            "for"
%token<fl>              yFORCE          "force"
%token<fl>              yFOREACH        "foreach"
%token<fl>              yFOREVER        "forever"
%token<fl>              yFORK           "fork"
%token<fl>              yFORKJOIN       "forkjoin"
%token<fl>              yFUNCTION       "function"
//UNSUP %token<fl>      yFUNCTION__ETC  "function"
//UNSUP %token<fl>      yFUNCTION__LEX  "function-in-lex"
//UNSUP %token<fl>      yFUNCTION__aPUREV "function-is-pure-virtual"
%token<fl>              yGENERATE       "generate"
%token<fl>              yGENVAR         "genvar"
%token<fl>              yGLOBAL__CLOCKING "global-then-clocking"
%token<fl>              yGLOBAL__ETC    "global"
%token<fl>              yGLOBAL__LEX    "global-in-lex"
%token<fl>              yIF             "if"
%token<fl>              yIFF            "iff"
//UNSUP %token<fl>      yIGNORE_BINS    "ignore_bins"
//UNSUP %token<fl>      yILLEGAL_BINS   "illegal_bins"
%token<fl>              yIMPLEMENTS     "implements"
//UNSUP %token<fl>      yIMPLIES        "implies"
%token<fl>              yIMPORT         "import"
%token<fl>              yINITIAL        "initial"
%token<fl>              yINOUT          "inout"
%token<fl>              yINPUT          "input"
%token<fl>              yINSIDE         "inside"
%token<fl>              yINT            "int"
%token<fl>              yINTEGER        "integer"
//UNSUP %token<fl>      yINTERCONNECT   "interconnect"
%token<fl>              yINTERFACE      "interface"
//UNSUP %token<fl>      yINTERSECT      "intersect"
%token<fl>              yJOIN           "join"
%token<fl>              yJOIN_ANY       "join_any"
%token<fl>              yJOIN_NONE      "join_none"
//UNSUP %token<fl>      yLET            "let"
%token<fl>              yLOCALPARAM     "localparam"
%token<fl>              yLOCAL__COLONCOLON "local-then-::"
%token<fl>              yLOCAL__ETC     "local"
%token<fl>              yLOCAL__LEX     "local-in-lex"
%token<fl>              yLOGIC          "logic"
%token<fl>              yLONGINT        "longint"
//UNSUP %token<fl>      yMATCHES        "matches"
%token<fl>              yMODPORT        "modport"
%token<fl>              yMODULE         "module"
%token<fl>              yNAND           "nand"
%token<fl>              yNEGEDGE        "negedge"
//UNSUP %token<fl>      yNETTYPE        "nettype"
%token<fl>              yNEW__ETC       "new"
%token<fl>              yNEW__LEX       "new-in-lex"
%token<fl>              yNEW__PAREN     "new-then-paren"
//UNSUP %token<fl>      yNEXTTIME       "nexttime"
%token<fl>              yNMOS           "nmos"
%token<fl>              yNOR            "nor"
%token<fl>              yNOT            "not"
%token<fl>              yNOTIF0         "notif0"
%token<fl>              yNOTIF1         "notif1"
%token<fl>              yNULL           "null"
%token<fl>              yOR             "or"
%token<fl>              yOUTPUT         "output"
%token<fl>              yPACKAGE        "package"
%token<fl>              yPACKED         "packed"
%token<fl>              yPARAMETER      "parameter"
%token<fl>              yPMOS           "pmos"
%token<fl>              yPOSEDGE        "posedge"
%token<fl>              yPRIMITIVE      "primitive"
%token<fl>              yPRIORITY       "priority"
%token<fl>              yPROGRAM        "program"
%token<fl>              yPROPERTY       "property"
%token<fl>              yPROTECTED      "protected"
%token<fl>              yPULLDOWN       "pulldown"
%token<fl>              yPULLUP         "pullup"
%token<fl>              yPURE           "pure"
%token<fl>              yRAND           "rand"
%token<fl>              yRANDC          "randc"
%token<fl>              yRANDCASE       "randcase"
%token<fl>              yRANDOMIZE      "randomize"
//UNSUP %token<fl>      yRANDSEQUENCE   "randsequence"
%token<fl>              yRCMOS          "rcmos"
%token<fl>              yREAL           "real"
%token<fl>              yREALTIME       "realtime"
%token<fl>              yREF            "ref"
%token<fl>              yREG            "reg"
//UNSUP %token<fl>      yREJECT_ON      "reject_on"
%token<fl>              yRELEASE        "release"
%token<fl>              yREPEAT         "repeat"
%token<fl>              yRESTRICT       "restrict"
%token<fl>              yRETURN         "return"
%token<fl>              yRNMOS          "rnmos"
%token<fl>              yRPMOS          "rpmos"
%token<fl>              yRTRAN          "rtran"
%token<fl>              yRTRANIF0       "rtranif0"
%token<fl>              yRTRANIF1       "rtranif1"
%token<fl>              ySCALARED       "scalared"
//UNSUP %token<fl>      ySEQUENCE       "sequence"
%token<fl>              ySHORTINT       "shortint"
%token<fl>              ySHORTREAL      "shortreal"
%token<fl>              ySIGNED         "signed"
%token<fl>              ySOFT           "soft"
%token<fl>              ySOLVE          "solve"
%token<fl>              ySPECIFY        "specify"
%token<fl>              ySPECPARAM      "specparam"
%token<fl>              ySTATIC__CONSTRAINT "static-then-constraint"
%token<fl>              ySTATIC__ETC    "static"
%token<fl>              ySTATIC__LEX    "static-in-lex"
%token<fl>              ySTRING         "string"
//UNSUP %token<fl>      ySTRONG         "strong"
%token<fl>              ySTRUCT         "struct"
%token<fl>              ySUPER          "super"
%token<fl>              ySUPPLY0        "supply0"
%token<fl>              ySUPPLY1        "supply1"
//UNSUP %token<fl>      ySYNC_ACCEPT_ON "sync_accept_on"
//UNSUP %token<fl>      ySYNC_REJECT_ON "sync_reject_on"
//UNSUP %token<fl>      yS_ALWAYS       "s_always"
//UNSUP %token<fl>      yS_EVENTUALLY   "s_eventually"
//UNSUP %token<fl>      yS_NEXTTIME     "s_nexttime"
//UNSUP %token<fl>      yS_UNTIL        "s_until"
//UNSUP %token<fl>      yS_UNTIL_WITH   "s_until_with"
%token<fl>              yTABLE          "table"
//UNSUP %token<fl>      yTAGGED         "tagged"
%token<fl>              yTASK           "task"
//UNSUP %token<fl>      yTASK__ETC      "task"
//UNSUP %token<fl>      yTASK__LEX      "task-in-lex"
//UNSUP %token<fl>      yTASK__aPUREV   "task-is-pure-virtual"
%token<fl>              yTHIS           "this"
//UNSUP %token<fl>      yTHROUGHOUT     "throughout"
%token<fl>              yTIME           "time"
%token<fl>              yTIMEPRECISION  "timeprecision"
%token<fl>              yTIMEUNIT       "timeunit"
%token<fl>              yTRAN           "tran"
%token<fl>              yTRANIF0        "tranif0"
%token<fl>              yTRANIF1        "tranif1"
%token<fl>              yTRI            "tri"
%token<fl>              yTRI0           "tri0"
%token<fl>              yTRI1           "tri1"
%token<fl>              yTRIAND         "triand"
%token<fl>              yTRIOR          "trior"
%token<fl>              yTRIREG         "trireg"
%token<fl>              yTRUE           "true"
%token<fl>              yTYPE           "type"
%token<fl>              yTYPEDEF        "typedef"
%token<fl>              yUNION          "union"
%token<fl>              yUNIQUE         "unique"
%token<fl>              yUNIQUE0        "unique0"
%token<fl>              yUNSIGNED       "unsigned"
//UNSUP %token<fl>      yUNTIL          "until"
//UNSUP %token<fl>      yUNTIL_WITH     "until_with"
//UNSUP %token<fl>      yUNTYPED        "untyped"
%token<fl>              yVAR            "var"
%token<fl>              yVECTORED       "vectored"
%token<fl>              yVIRTUAL__CLASS "virtual-then-class"
%token<fl>              yVIRTUAL__ETC   "virtual"
%token<fl>              yVIRTUAL__INTERFACE     "virtual-then-interface"
%token<fl>              yVIRTUAL__LEX   "virtual-in-lex"
%token<fl>              yVIRTUAL__anyID "virtual-then-identifier"
%token<fl>              yVOID           "void"
%token<fl>              yWAIT           "wait"
//UNSUP %token<fl>      yWAIT_ORDER     "wait_order"
%token<fl>              yWAND           "wand"
//UNSUP %token<fl>      yWEAK           "weak"
%token<fl>              yWHILE          "while"
//UNSUP %token<fl>      yWILDCARD       "wildcard"
%token<fl>              yWIRE           "wire"
//UNSUP %token<fl>      yWITHIN         "within"
%token<fl>              yWITH__BRA      "with-then-["
%token<fl>              yWITH__CUR      "with-then-{"
%token<fl>              yWITH__ETC      "with"
%token<fl>              yWITH__LEX      "with-in-lex"
%token<fl>              yWITH__PAREN    "with-then-("
%token<fl>              yWOR            "wor"
%token<fl>              yWREAL          "wreal"
%token<fl>              yXNOR           "xnor"
%token<fl>              yXOR            "xor"

%token<fl>              yD_ACOS         "$acos"
%token<fl>              yD_ACOSH        "$acosh"
%token<fl>              yD_ASIN         "$asin"
%token<fl>              yD_ASINH        "$asinh"
%token<fl>              yD_ATAN         "$atan"
%token<fl>              yD_ATAN2        "$atan2"
%token<fl>              yD_ATANH        "$atanh"
%token<fl>              yD_BITS         "$bits"
%token<fl>              yD_BITSTOREAL   "$bitstoreal"
%token<fl>              yD_BITSTOSHORTREAL "$bitstoshortreal"
%token<fl>              yD_C            "$c"
%token<fl>              yD_CAST         "$cast"
%token<fl>              yD_CEIL         "$ceil"
%token<fl>              yD_CHANGED      "$changed"
%token<fl>              yD_CLOG2        "$clog2"
%token<fl>              yD_COS          "$cos"
%token<fl>              yD_COSH         "$cosh"
%token<fl>              yD_COUNTBITS    "$countbits"
%token<fl>              yD_COUNTONES    "$countones"
%token<fl>              yD_DIMENSIONS   "$dimensions"
%token<fl>              yD_DISPLAY      "$display"
%token<fl>              yD_DISPLAYB     "$displayb"
%token<fl>              yD_DISPLAYH     "$displayh"
%token<fl>              yD_DISPLAYO     "$displayo"
%token<fl>              yD_DUMPALL      "$dumpall"
%token<fl>              yD_DUMPFILE     "$dumpfile"
%token<fl>              yD_DUMPFLUSH    "$dumpflush"
%token<fl>              yD_DUMPLIMIT    "$dumplimit"
%token<fl>              yD_DUMPOFF      "$dumpoff"
%token<fl>              yD_DUMPON       "$dumpon"
%token<fl>              yD_DUMPPORTS    "$dumpports"
%token<fl>              yD_DUMPVARS     "$dumpvars"
%token<fl>              yD_ERROR        "$error"
%token<fl>              yD_EXIT         "$exit"
%token<fl>              yD_EXP          "$exp"
%token<fl>              yD_FATAL        "$fatal"
%token<fl>              yD_FCLOSE       "$fclose"
%token<fl>              yD_FDISPLAY     "$fdisplay"
%token<fl>              yD_FDISPLAYB    "$fdisplayb"
%token<fl>              yD_FDISPLAYH    "$fdisplayh"
%token<fl>              yD_FDISPLAYO    "$fdisplayo"
%token<fl>              yD_FELL         "$fell"
%token<fl>              yD_FEOF         "$feof"
%token<fl>              yD_FERROR       "$ferror"
%token<fl>              yD_FFLUSH       "$fflush"
%token<fl>              yD_FGETC        "$fgetc"
%token<fl>              yD_FGETS        "$fgets"
%token<fl>              yD_FINISH       "$finish"
%token<fl>              yD_FLOOR        "$floor"
%token<fl>              yD_FOPEN        "$fopen"
%token<fl>              yD_FREAD        "$fread"
%token<fl>              yD_FREWIND      "$frewind"
%token<fl>              yD_FSCANF       "$fscanf"
%token<fl>              yD_FSEEK        "$fseek"
%token<fl>              yD_FTELL        "$ftell"
%token<fl>              yD_FWRITE       "$fwrite"
%token<fl>              yD_FWRITEB      "$fwriteb"
%token<fl>              yD_FWRITEH      "$fwriteh"
%token<fl>              yD_FWRITEO      "$fwriteo"
%token<fl>              yD_HIGH         "$high"
%token<fl>              yD_HYPOT        "$hypot"
%token<fl>              yD_INCREMENT    "$increment"
%token<fl>              yD_INFO         "$info"
%token<fl>              yD_ISUNBOUNDED  "$isunbounded"
%token<fl>              yD_ISUNKNOWN    "$isunknown"
%token<fl>              yD_ITOR         "$itor"
%token<fl>              yD_LEFT         "$left"
%token<fl>              yD_LN           "$ln"
%token<fl>              yD_LOG10        "$log10"
%token<fl>              yD_LOW          "$low"
%token<fl>              yD_ONEHOT       "$onehot"
%token<fl>              yD_ONEHOT0      "$onehot0"
%token<fl>              yD_PAST         "$past"
%token<fl>              yD_POW          "$pow"
%token<fl>              yD_PRINTTIMESCALE "$printtimescale"
%token<fl>              yD_RANDOM       "$random"
%token<fl>              yD_READMEMB     "$readmemb"
%token<fl>              yD_READMEMH     "$readmemh"
%token<fl>              yD_REALTIME     "$realtime"
%token<fl>              yD_REALTOBITS   "$realtobits"
%token<fl>              yD_REWIND       "$rewind"
%token<fl>              yD_RIGHT        "$right"
%token<fl>              yD_ROOT         "$root"
%token<fl>              yD_ROSE         "$rose"
%token<fl>              yD_RTOI         "$rtoi"
%token<fl>              yD_SAMPLED      "$sampled"
%token<fl>              yD_SFORMAT      "$sformat"
%token<fl>              yD_SFORMATF     "$sformatf"
%token<fl>              yD_SHORTREALTOBITS "$shortrealtobits"
%token<fl>              yD_SIGNED       "$signed"
%token<fl>              yD_SIN          "$sin"
%token<fl>              yD_SINH         "$sinh"
%token<fl>              yD_SIZE         "$size"
%token<fl>              yD_SQRT         "$sqrt"
%token<fl>              yD_SSCANF       "$sscanf"
%token<fl>              yD_STABLE       "$stable"
%token<fl>              yD_STIME        "$stime"
%token<fl>              yD_STOP         "$stop"
%token<fl>              yD_SWRITE       "$swrite"
%token<fl>              yD_SWRITEB      "$swriteb"
%token<fl>              yD_SWRITEH      "$swriteh"
%token<fl>              yD_SWRITEO      "$swriteo"
%token<fl>              yD_SYSTEM       "$system"
%token<fl>              yD_TAN          "$tan"
%token<fl>              yD_TANH         "$tanh"
%token<fl>              yD_TESTPLUSARGS "$test$plusargs"
%token<fl>              yD_TIME         "$time"
%token<fl>              yD_TIMEFORMAT   "$timeformat"
%token<fl>              yD_TYPENAME     "$typename"
%token<fl>              yD_UNGETC       "$ungetc"
%token<fl>              yD_UNIT         "$unit"
%token<fl>              yD_UNPACKED_DIMENSIONS "$unpacked_dimensions"
%token<fl>              yD_UNSIGNED     "$unsigned"
%token<fl>              yD_URANDOM      "$urandom"
%token<fl>              yD_URANDOM_RANGE "$urandom_range"
%token<fl>              yD_VALUEPLUSARGS "$value$plusargs"
%token<fl>              yD_WARNING      "$warning"
%token<fl>              yD_WRITE        "$write"
%token<fl>              yD_WRITEB       "$writeb"
%token<fl>              yD_WRITEH       "$writeh"
%token<fl>              yD_WRITEMEMB    "$writememb"
%token<fl>              yD_WRITEMEMH    "$writememh"
%token<fl>              yD_WRITEO       "$writeo"

%token<fl>              yVL_CLOCKER             "/*verilator clocker*/"
%token<fl>              yVL_CLOCK_ENABLE        "/*verilator clock_enable*/"
%token<fl>              yVL_COVERAGE_BLOCK_OFF  "/*verilator coverage_block_off*/"
%token<fl>              yVL_FULL_CASE           "/*verilator full_case*/"
%token<fl>              yVL_HIER_BLOCK          "/*verilator hier_block*/"
%token<fl>              yVL_INLINE_MODULE       "/*verilator inline_module*/"
%token<fl>              yVL_ISOLATE_ASSIGNMENTS "/*verilator isolate_assignments*/"
%token<fl>              yVL_NO_CLOCKER          "/*verilator no_clocker*/"
%token<fl>              yVL_NO_INLINE_MODULE    "/*verilator no_inline_module*/"
%token<fl>              yVL_NO_INLINE_TASK      "/*verilator no_inline_task*/"
%token<fl>              yVL_PARALLEL_CASE       "/*verilator parallel_case*/"
%token<fl>              yVL_PUBLIC              "/*verilator public*/"
%token<fl>              yVL_PUBLIC_FLAT         "/*verilator public_flat*/"
%token<fl>              yVL_PUBLIC_FLAT_RD      "/*verilator public_flat_rd*/"
%token<fl>              yVL_PUBLIC_FLAT_RW      "/*verilator public_flat_rw*/"
%token<fl>              yVL_PUBLIC_MODULE       "/*verilator public_module*/"
%token<fl>              yVL_SC_BV               "/*verilator sc_bv*/"
%token<fl>              yVL_SFORMAT             "/*verilator sformat*/"
%token<fl>              yVL_SPLIT_VAR           "/*verilator split_var*/"
%token<strp>            yVL_TAG                 "/*verilator tag*/"

%token<fl>              yP_TICK         "'"
%token<fl>              yP_TICKBRA      "'{"
%token<fl>              yP_OROR         "||"
%token<fl>              yP_ANDAND       "&&"
%token<fl>              yP_NOR          "~|"
%token<fl>              yP_XNOR         "^~"
%token<fl>              yP_NAND         "~&"
%token<fl>              yP_EQUAL        "=="
%token<fl>              yP_NOTEQUAL     "!="
%token<fl>              yP_CASEEQUAL    "==="
%token<fl>              yP_CASENOTEQUAL "!=="
%token<fl>              yP_WILDEQUAL    "==?"
%token<fl>              yP_WILDNOTEQUAL "!=?"
%token<fl>              yP_GTE          ">="
%token<fl>              yP_LTE          "<="
%token<fl>              yP_LTE__IGNORE  "<=-ignored"    // Used when expr:<= means assignment
%token<fl>              yP_SLEFT        "<<"
%token<fl>              yP_SRIGHT       ">>"
%token<fl>              yP_SSRIGHT      ">>>"
%token<fl>              yP_POW          "**"

%token<fl>              yP_COLON__BEGIN ":-begin"
%token<fl>              yP_COLON__FORK  ":-fork"
//UNSUP %token<fl>      yP_PAR__IGNORE  "(-ignored"     // Used when sequence_expr:expr:( is ignored
%token<fl>              yP_PAR__STRENGTH "(-for-strength"

%token<fl>              yP_LTMINUSGT    "<->"
%token<fl>              yP_PLUSCOLON    "+:"
%token<fl>              yP_MINUSCOLON   "-:"
%token<fl>              yP_MINUSGT      "->"
%token<fl>              yP_MINUSGTGT    "->>"
%token<fl>              yP_EQGT         "=>"
%token<fl>              yP_ASTGT        "*>"
%token<fl>              yP_ANDANDAND    "&&&"
%token<fl>              yP_POUNDPOUND   "##"
//UNSUP %token<fl>      yP_POUNDMINUSPD "#-#"
//UNSUP %token<fl>      yP_POUNDEQPD    "#=#"
%token<fl>              yP_DOTSTAR      ".*"

%token<fl>              yP_ATAT         "@@"
%token<fl>              yP_COLONCOLON   "::"
%token<fl>              yP_COLONEQ      ":="
%token<fl>              yP_COLONDIV     ":/"
%token<fl>              yP_ORMINUSGT    "|->"
%token<fl>              yP_OREQGT       "|=>"
%token<fl>              yP_BRASTAR      "[*"
%token<fl>              yP_BRAEQ        "[="
%token<fl>              yP_BRAMINUSGT   "[->"
//UNSUP %token<fl>      yP_BRAPLUSKET   "[+]"

%token<fl>              yP_PLUSPLUS     "++"
%token<fl>              yP_MINUSMINUS   "--"
%token<fl>              yP_PLUSEQ       "+="
%token<fl>              yP_MINUSEQ      "-="
%token<fl>              yP_TIMESEQ      "*="
%token<fl>              yP_DIVEQ        "/="
%token<fl>              yP_MODEQ        "%="
%token<fl>              yP_ANDEQ        "&="
%token<fl>              yP_OREQ         "|="
%token<fl>              yP_XOREQ        "^="
%token<fl>              yP_SLEFTEQ      "<<="
%token<fl>              yP_SRIGHTEQ     ">>="
%token<fl>              yP_SSRIGHTEQ    ">>>="

// [* is not a operator, as "[ * ]" is legal
// [= and [-> could be repitition operators, but to match [* we don't add them.
// '( is not a operator, as "' (" is legal

//********************
// Verilog op precedence
//UNSUP %token<fl>      prUNARYARITH
//UNSUP %token<fl>      prREDUCTION
//UNSUP %token<fl>      prNEGATION
//UNSUP %token<fl>      prEVENTBEGIN
//UNSUP %token<fl>      prTAGGED

// These prevent other conflicts
%left           yP_ANDANDAND
//UNSUP %left   yMATCHES
//UNSUP %left   prTAGGED
//UNSUP %left   prSEQ_CLOCKING

// PSL op precedence

// Lowest precedence
// These are in IEEE 17.7.1
//UNSUP %nonassoc       yALWAYS yS_ALWAYS yEVENTUALLY yS_EVENTUALLY yACCEPT_ON yREJECT_ON ySYNC_ACCEPT_ON ySYNC_REJECT_ON

%right          yP_ORMINUSGT yP_OREQGT
//UNSUP %right          yP_ORMINUSGT yP_OREQGT yP_POUNDMINUSPD yP_POUNDEQPD
//UNSUP %right          yUNTIL yS_UNTIL yUNTIL_WITH yS_UNTIL_WITH yIMPLIES
//UNSUP %right          yIFF
//UNSUP %left           yOR
//UNSUP %left           yAND
//UNSUP %nonassoc       yNOT yNEXTTIME yS_NEXTTIME
//UNSUP %left           yINTERSECT
//UNSUP %left           yWITHIN
//UNSUP %right          yTHROUGHOUT
//UNSUP %left           prPOUNDPOUND_MULTI
//UNSUP %left           yP_POUNDPOUND
//UNSUP %left           yP_BRASTAR yP_BRAEQ yP_BRAMINUSGT yP_BRAPLUSKET

// Not specified, but needed higher than yOR, lower than normal non-pexpr expressions
//UNSUP %left           yPOSEDGE yNEGEDGE yEDGE

//UNSUP %left           '{' '}'

// Verilog op precedence
%right          yP_MINUSGT yP_LTMINUSGT
%right          '?' ':' yP_COLON__BEGIN yP_COLON__FORK
%left           yP_OROR
%left           yP_ANDAND
%left           '|' yP_NOR
%left           '^' yP_XNOR
%left           '&' yP_NAND
%left           yP_EQUAL yP_NOTEQUAL yP_CASEEQUAL yP_CASENOTEQUAL yP_WILDEQUAL yP_WILDNOTEQUAL
%left           '>' '<' yP_GTE yP_LTE yP_LTE__IGNORE yINSIDE yDIST
%left           yP_SLEFT yP_SRIGHT yP_SSRIGHT
%left           '+' '-'
%left           '*' '/' '%'
%left           yP_POW
%left           prUNARYARITH yP_MINUSMINUS yP_PLUSPLUS prREDUCTION prNEGATION
%left           '.'
// Not in IEEE, but need to avoid conflicts; TICK should bind tightly just lower than COLONCOLON
%left           yP_TICK
//%left         '(' ')' '[' ']' yP_COLONCOLON '.'

%nonassoc prLOWER_THAN_ELSE
%nonassoc yELSE

//BISONPRE_TYPES
//  Blank lines for type insertion
//  Blank lines for type insertion
//  Blank lines for type insertion
//  Blank lines for type insertion
//  Blank lines for type insertion
//  Blank lines for type insertion
//  Blank lines for type insertion
//  Blank lines for type insertion
//  Blank lines for type insertion
//  Blank lines for type insertion
//  Blank lines for type insertion
//  Blank lines for type insertion
//  Blank lines for type insertion
//  Blank lines for type insertion
//  Blank lines for type insertion
//  Blank lines for type insertion
//  Blank lines for type insertion
//  Blank lines for type insertion
//  Blank lines for type insertion
//  Blank lines for type insertion
//  Blank lines for type insertion
//  Blank lines for type insertion
//  Blank lines for type insertion
//  Blank lines for type insertion
//  Blank lines for type insertion
//  Blank lines for type insertion
//  Blank lines for type insertion
//  Blank lines for type insertion
//  Blank lines for type insertion
//  Blank lines for type insertion
//  Blank lines for type insertion
//  Blank lines for type insertion
//  Blank lines for type insertion
//  Blank lines for type insertion
//  Blank lines for type insertion
//  Blank lines for type insertion
//  Blank lines for type insertion

%start source_text

%%
//**********************************************************************
// Files

source_text:			// ==IEEE: source_text
		/* empty */				{ }
	//			// timeunits_declaration moved into description:package_item
	|	descriptionList				{ }
	;

descriptionList:		// IEEE: part of source_text
		description				{ }
	|	descriptionList description		{ }
	;

description:			// ==IEEE: description
		module_declaration			{ }
	//			// udp_declaration moved into module_declaration
	|	interface_declaration			{ }
	|	program_declaration			{ }
	|	package_declaration			{ }
	|	package_item				{ if ($1) GRAMMARP->unitPackage($1->fileline())->addStmtp($1); }
       	|	bind_directive				{ if ($1) GRAMMARP->unitPackage($1->fileline())->addStmtp($1); }
	//	unsupported	// IEEE: config_declaration
	//			// Verilator only
	|	yaT_RESETALL				{ }  // Else, under design, and illegal based on IEEE 22.3
	|	yaT_NOUNCONNECTED			{ PARSEP->unconnectedDrive(VOptionBool::OPT_DEFAULT_FALSE); }
        |	yaT_UNCONNECTED_PULL0			{ PARSEP->unconnectedDrive(VOptionBool::OPT_FALSE); }
        |	yaT_UNCONNECTED_PULL1			{ PARSEP->unconnectedDrive(VOptionBool::OPT_TRUE); }
	|	vltItem					{ }
	|	error					{ }
	;

timeunits_declaration<nodep>:	// ==IEEE: timeunits_declaration
		yTIMEUNIT yaTIMENUM ';'
			{ PARSEP->timescaleMod($<fl>2, GRAMMARP->m_modp, true, $2, false, 0); $$ = nullptr; }
	|	yTIMEUNIT yaTIMENUM '/' yaTIMENUM ';'
			{ PARSEP->timescaleMod($<fl>2, GRAMMARP->m_modp, true, $2, true, $4); $$ = nullptr; }
	| 	yTIMEPRECISION yaTIMENUM ';'
			{ PARSEP->timescaleMod($<fl>2, GRAMMARP->m_modp, false, 0, true, $2); $$ = nullptr; }
	;

//**********************************************************************
// Packages

package_declaration:		// ==IEEE: package_declaration
		packageFront package_itemListE yENDPACKAGE endLabelE
			{ $1->modTrace(GRAMMARP->allTracingOn($1->fileline()));  // Stash for implicit wires, etc
			  if ($2) $1->addStmtp($2);
			  GRAMMARP->m_modp = nullptr;
			  SYMP->popScope($1);
			  GRAMMARP->endLabel($<fl>4,$1,$4); }
	;

packageFront<modulep>:
		yPACKAGE lifetimeE idAny ';'
			{ $$ = new AstPackage($<fl>3, *$3);
			  $$->inLibrary(true);  // packages are always libraries; don't want to make them a "top"
			  $$->lifetime($2);
			  $$->modTrace(GRAMMARP->allTracingOn($$->fileline()));
			  $$->timeunit(PARSEP->timeLastUnit());
			  PARSEP->rootp()->addModulep($$);
			  SYMP->pushNew($$);
			  GRAMMARP->m_modp = $$; }
	;

package_itemListE<nodep>:	// IEEE: [{ package_item }]
		/* empty */				{ $$ = nullptr; }
	|	package_itemList			{ $$ = $1; }
	;

package_itemList<nodep>:	// IEEE: { package_item }
		package_item				{ $$ = $1; }
	|	package_itemList package_item		{ $$ = $1->addNextNull($2); }
	;

package_item<nodep>:		// ==IEEE: package_item
		package_or_generate_item_declaration	{ $$ = $1; }
	|	anonymous_program			{ $$ = $1; }
	|	package_export_declaration		{ $$ = $1; }
	|	timeunits_declaration			{ $$ = $1; }
	;

package_or_generate_item_declaration<nodep>:	// ==IEEE: package_or_generate_item_declaration
		net_declaration				{ $$ = $1; }
	|	data_declaration			{ $$ = $1; }
	|	task_declaration			{ $$ = $1; }
	|	function_declaration			{ $$ = $1; }
	//UNSUP	checker_declaration			{ $$ = $1; }
	|	dpi_import_export			{ $$ = $1; }
	//UNSUP	extern_constraint_declaration		{ $$ = $1; }
	|	class_declaration			{ $$ = $1; }
	//			// class_constructor_declaration is part of function_declaration
	//			// local_parameter_declaration under parameter_declaration
	|	parameter_declaration ';'		{ $$ = $1; }
	//UNSUP	covergroup_declaration			{ $$ = $1; }
	//UNSUP	assertion_item_declaration		{ $$ = $1; }
	|	';'					{ $$ = nullptr; }
	;

package_import_declarationList<nodep>:
		package_import_declaration		{ $$ = $1; }
	|	package_import_declarationList package_import_declaration { $$ = $1->addNextNull($2); }
	;

package_import_declaration<nodep>:	// ==IEEE: package_import_declaration
		yIMPORT package_import_itemList ';'	{ $$ = $2; }
	;

package_import_itemList<nodep>:
		package_import_item			{ $$ = $1; }
	|	package_import_itemList ',' package_import_item { $$ = $1->addNextNull($3); }
	;

package_import_item<nodep>:	// ==IEEE: package_import_item
		idCC/*package_identifier*/ yP_COLONCOLON package_import_itemObj
			{
			  if (!VN_CAST($<scp>1, Package)) {
			      $$ = nullptr;
			      $<fl>1->v3error("Importing from missing package '" << *$<strp>1 << "'");
			  } else {
			      $$ = new AstPackageImport($<fl>2, VN_CAST($<scp>1, Package), *$3);
			      SYMP->importItem($<scp>1,*$3);
			  } }
	;

package_import_itemObj<strp>:	// IEEE: part of package_import_item
		idAny/*package_identifier*/		{ $<fl>$=$<fl>1; $$=$1; }
	|	'*'					{ $<fl>$=$<fl>1; static string star="*"; $$=&star; }
	;

package_export_declaration<nodep>: // IEEE: package_export_declaration
		yEXPORT '*' yP_COLONCOLON '*' ';'	{ $$ = new AstPackageExportStarStar($<fl>2); SYMP->exportStarStar($<scp>1); }
	|	yEXPORT package_export_itemList ';'	{ $$ = $2; }
	;

package_export_itemList<nodep>:
		package_export_item			{ $$ = $1; }
	|	package_export_itemList ',' package_export_item { $$ = $1->addNextNull($3); }
	;

package_export_item<nodep>:	// ==IEEE: package_export_item
		idCC yP_COLONCOLON package_import_itemObj
			{ $$ = new AstPackageExport($<fl>3, VN_CAST($<scp>1, Package), *$3);
			  SYMP->exportItem($<scp>1,*$3); }
	;

//**********************************************************************
// Module headers

module_declaration:		// ==IEEE: module_declaration
	//			// timeunits_declaration instead in module_item
	//			// IEEE: module_nonansi_header + module_ansi_header
		modFront importsAndParametersE portsStarE ';'
	/*cont*/    module_itemListE yENDMODULE endLabelE
			{ $1->modTrace(GRAMMARP->allTracingOn($1->fileline()));  // Stash for implicit wires, etc
			  if ($2) $1->addStmtp($2); if ($3) $1->addStmtp($3);
			  if ($5) $1->addStmtp($5);
			  GRAMMARP->m_modp = nullptr;
			  SYMP->popScope($1);
			  GRAMMARP->endLabel($<fl>7,$1,$7); }
	|	udpFront parameter_port_listE portsStarE ';'
	/*cont*/    module_itemListE yENDPRIMITIVE endLabelE
			{ $1->modTrace(false);  // Stash for implicit wires, etc
			  if ($2) $1->addStmtp($2); if ($3) $1->addStmtp($3);
			  if ($5) $1->addStmtp($5);
			  GRAMMARP->m_tracingParse = true;
			  GRAMMARP->m_modp = nullptr;
			  SYMP->popScope($1);
			  GRAMMARP->endLabel($<fl>7,$1,$7); }
	//
	|	yEXTERN modFront parameter_port_listE portsStarE ';'
			{ BBUNSUP($<fl>1, "Unsupported: extern module"); }
	;

modFront<modulep>:
	//			// General note: all *Front functions must call symPushNew before
	//			// any formal arguments, as the arguments must land in the new scope.
		yMODULE lifetimeE idAny
			{ $$ = new AstModule($<fl>3,*$3);
			  $$->lifetime($2);
			  $$->inLibrary(PARSEP->inLibrary() || $$->fileline()->celldefineOn());
			  $$->modTrace(GRAMMARP->allTracingOn($$->fileline()));
			  $$->timeunit(PARSEP->timeLastUnit());
			  $$->unconnectedDrive(PARSEP->unconnectedDrive());
			  PARSEP->rootp()->addModulep($$);
			  SYMP->pushNew($$);
			  GRAMMARP->m_modp = $$; }
	;

importsAndParametersE<nodep>:	// IEEE: common part of module_declaration, interface_declaration, program_declaration
	//			// { package_import_declaration } [ parameter_port_list ]
		parameter_port_listE			{ $$ = $1; }
	|	package_import_declarationList parameter_port_listE	{ $$ = $1->addNextNull($2); }
	;

udpFront<modulep>:
		yPRIMITIVE lifetimeE idAny
			{ $$ = new AstPrimitive($<fl>3, *$3); $$->inLibrary(true);
			  $$->lifetime($2);
			  $$->modTrace(false);
			  $$->addStmtp(new AstPragma($<fl>3, AstPragmaType::INLINE_MODULE));
			  GRAMMARP->m_tracingParse = false;
			  PARSEP->rootp()->addModulep($$);
			  SYMP->pushNew($$); }
	;

parameter_value_assignmentE<pinp>:	// IEEE: [ parameter_value_assignment ]
		/* empty */				{ $$ = nullptr; }
	|	parameter_value_assignment		{ $$ = $1; }
	;

parameter_value_assignment<pinp>:	// IEEE: parameter_value_assignment
		'#' '(' cellparamList ')'		{ $$ = $3; }
	//			// Parentheses are optional around a single parameter
	|	'#' yaINTNUM				{ $$ = new AstPin($<fl>2, 1, "", new AstConst($<fl>2, *$2)); }
	|	'#' yaFLOATNUM				{ $$ = new AstPin($<fl>2, 1, "",
									  new AstConst($<fl>2, AstConst::Unsized32(),
										       (int)(($2<0)?($2-0.5):($2+0.5)))); }
	|	'#' timeNumAdjusted			{ $$ = new AstPin($<fl>2, 1, "", $2); }
	|	'#' idClassSel				{ $$ = new AstPin($<fl>2, 1, "", $2); }
	//			// Not needed in Verilator:
	//			// Side effect of combining *_instantiations
	//			// '#' delay_value	{ UNSUP }
	;

parameter_value_assignmentClass<pinp>:	// IEEE: [ parameter_value_assignment ] (for classes)
	//			// Like parameter_value_assignment, but for classes only, which always have #()
		'#' '(' cellparamList ')'		{ $$ = $3; }
	;

parameter_port_listE<nodep>:	// IEEE: parameter_port_list + empty == parameter_value_assignment
		/* empty */				{ $$ = nullptr; }
	|	'#' '(' ')'				{ $$ = nullptr; }
	//			// IEEE: '#' '(' list_of_param_assignments { ',' parameter_port_declaration } ')'
	//			// IEEE: '#' '(' parameter_port_declaration { ',' parameter_port_declaration } ')'
	//			// Can't just do that as "," conflicts with between vars and between stmts, so
	//			// split into pre-comma and post-comma parts
	|	'#' '(' {VARRESET_LIST(GPARAM);} paramPortDeclOrArgList ')'	{ $$ = $4; VARRESET_NONLIST(UNKNOWN); }
	//			// Note legal to start with "a=b" with no parameter statement
	;

paramPortDeclOrArgList<nodep>:	// IEEE: list_of_param_assignments + { parameter_port_declaration }
		paramPortDeclOrArg				{ $$ = $1; }
	|	paramPortDeclOrArgList ',' paramPortDeclOrArg	{ $$ = $1->addNext($3); }
	;

paramPortDeclOrArg<nodep>:	// IEEE: param_assignment + parameter_port_declaration
	//			// We combine the two as we can't tell which follows a comma
		parameter_port_declarationFrontE param_assignment	{ $$ = $2; }
	|	parameter_port_declarationTypeFrontE type_assignment	{ $$ = $2; }
	|	vlTag					{ $$ = nullptr; }
	;

portsStarE<nodep>:		// IEEE: .* + list_of_ports + list_of_port_declarations + empty
		/* empty */				{ $$ = nullptr; }
	|	'(' ')'					{ $$ = nullptr; }
	//			// .* expanded from module_declaration
	//UNSUP	'(' yP_DOTSTAR ')'				{ UNSUP }
	|	'(' {VARRESET_LIST(PORT);} list_of_ports ')'	{ $$ = $3; VARRESET_NONLIST(UNKNOWN); }
	;

list_of_ports<nodep>:		// IEEE: list_of_ports + list_of_port_declarations
		portAndTag				{ $$ = $1; }
	|	list_of_ports ',' portAndTag		{ $$ = $1->addNextNull($3); }
	;

portAndTag<nodep>:
		port					{ $$ = $1; }
	|	vlTag port				{ $$ = $2; }  // Tag will associate with previous port
	;

port<nodep>:			// ==IEEE: port
	//			// SEE ALSO port_declaration, tf_port_declaration,
	//			// data_declarationVarFront
	//
	//			// Though not type for interfaces, we factor out the port direction and type
	//			// so we can simply handle it in one place
	//
	//			// IEEE: interface_port_header port_identifier { unpacked_dimension }
	//			// Expanded interface_port_header
	//			// We use instantCb here because the non-port form looks just like a module instantiation
		portDirNetE id/*interface*/                      portSig variable_dimensionListE sigAttrListE
			{ $$ = $3; VARDECL(IFACEREF); VARIO(NONE);
			  VARDTYPE(new AstIfaceRefDType($<fl>2,"",*$2));
			  $$->addNextNull(VARDONEP($$,$4,$5)); }
	|	portDirNetE id/*interface*/ '.' idAny/*modport*/ portSig variable_dimensionListE sigAttrListE
			{ $$ = $5; VARDECL(IFACEREF); VARIO(NONE);
			  VARDTYPE(new AstIfaceRefDType($<fl>2, $<fl>4, "", *$2, *$4));
			  $$->addNextNull(VARDONEP($$,$6,$7)); }
	|	portDirNetE yINTERFACE                           portSig rangeListE sigAttrListE
			{ $$ = nullptr; BBUNSUP($<fl>2, "Unsupported: virtual or generic interfaces"); }
	|	portDirNetE yINTERFACE      '.' idAny/*modport*/ portSig rangeListE sigAttrListE
			{ $$ = nullptr; BBUNSUP($<fl>2, "Unsupported: virtual or generic interfaces"); }
	//
	//			// IEEE: ansi_port_declaration, with [port_direction] removed
	//			//   IEEE: [ net_port_header | interface_port_header ] port_identifier { unpacked_dimension } [ '=' constant_expression ]
	//			//   IEEE: [ net_port_header | variable_port_header ] '.' port_identifier '(' [ expression ] ')'
	//			//   IEEE: [ variable_port_header ] port_identifier { variable_dimension } [ '=' constant_expression ]
	//			//   Substitute net_port_header = [ port_direction ] net_port_type
	//			//   Substitute variable_port_header = [ port_direction ] variable_port_type
	//			//   Substitute net_port_type = [ net_type ] data_type_or_implicit
	//			//   Substitute variable_port_type = var_data_type
	//			//   Substitute var_data_type = data_type | yVAR data_type_or_implicit
	//			//     [ [ port_direction ] net_port_type | interface_port_header            ] port_identifier { unpacked_dimension }
	//			//     [ [ port_direction ] var_data_type                                    ] port_identifier variable_dimensionListE [ '=' constant_expression ]
	//			//     [ [ port_direction ] net_port_type | [ port_direction ] var_data_type ] '.' port_identifier '(' [ expression ] ')'
	//
	//			// Remove optional '[...] id' is in portAssignment
	//			// Remove optional '[port_direction]' is in port
	//			//     net_port_type | interface_port_header            port_identifier { unpacked_dimension }
	//			//     net_port_type | interface_port_header            port_identifier { unpacked_dimension }
	//			//     var_data_type                                    port_identifier variable_dimensionListE [ '=' constExpr ]
	//			//     net_port_type | [ port_direction ] var_data_type '.' port_identifier '(' [ expr ] ')'
	//			// Expand implicit_type
	//
	//			// variable_dimensionListE instead of rangeListE to avoid conflicts
	//
	//			// Note implicit rules looks just line declaring additional followon port
	//			// No VARDECL("port") for implicit, as we don't want to declare variables for them
	//UNSUP	portDirNetE data_type	       '.' portSig '(' portAssignExprE ')' sigAttrListE
	//UNSUP		{ UNSUP }
	//UNSUP	portDirNetE yVAR data_type     '.' portSig '(' portAssignExprE ')' sigAttrListE
	//UNSUP		{ UNSUP }
	//UNSUP	portDirNetE yVAR implicit_type '.' portSig '(' portAssignExprE ')' sigAttrListE
	//UNSUP		{ UNSUP }
	//UNSUP	portDirNetE signingE rangeList '.' portSig '(' portAssignExprE ')' sigAttrListE
	//UNSUP		{ UNSUP }
	//UNSUP	portDirNetE /*implicit*/       '.' portSig '(' portAssignExprE ')' sigAttrListE
	//UNSUP		{ UNSUP }
	//
	|	portDirNetE data_type           portSig variable_dimensionListE sigAttrListE
			{ $$=$3; VARDTYPE($2); $$->addNextNull(VARDONEP($$,$4,$5)); }
	|	portDirNetE yVAR data_type      portSig variable_dimensionListE sigAttrListE
			{ $$=$4; VARDTYPE($3); $$->addNextNull(VARDONEP($$,$5,$6)); }
	|	portDirNetE yVAR implicit_typeE portSig variable_dimensionListE sigAttrListE
			{ $$=$4; VARDTYPE($3); $$->addNextNull(VARDONEP($$,$5,$6)); }
	|	portDirNetE signing             portSig variable_dimensionListE sigAttrListE
			{ $$=$3; VARDTYPE_NDECL(new AstBasicDType($3->fileline(), LOGIC_IMPLICIT, $2)); $$->addNextNull(VARDONEP($$,$4,$5)); }
	|	portDirNetE signingE rangeList  portSig variable_dimensionListE sigAttrListE
			{ $$=$4; VARDTYPE_NDECL(GRAMMARP->addRange(new AstBasicDType($3->fileline(), LOGIC_IMPLICIT, $2), $3,true)); $$->addNextNull(VARDONEP($$,$5,$6)); }
	|	portDirNetE /*implicit*/        portSig variable_dimensionListE sigAttrListE
			{ $$=$2; /*VARDTYPE-same*/ $$->addNextNull(VARDONEP($$,$3,$4)); }
	//
	|	portDirNetE data_type           portSig variable_dimensionListE sigAttrListE '=' constExpr
			{ $$=$3; VARDTYPE($2); if (AstVar* vp=VARDONEP($$,$4,$5)) { $$->addNextNull(vp); vp->valuep($7); } }
	|	portDirNetE yVAR data_type      portSig variable_dimensionListE sigAttrListE '=' constExpr
			{ $$=$4; VARDTYPE($3); if (AstVar* vp=VARDONEP($$,$5,$6)) { $$->addNextNull(vp); vp->valuep($8); } }
	|	portDirNetE yVAR implicit_typeE portSig variable_dimensionListE sigAttrListE '=' constExpr
			{ $$=$4; VARDTYPE($3); if (AstVar* vp=VARDONEP($$,$5,$6)) { $$->addNextNull(vp); vp->valuep($8); } }
	|	portDirNetE /*implicit*/        portSig variable_dimensionListE sigAttrListE '=' constExpr
			{ $$=$2; /*VARDTYPE-same*/ if (AstVar* vp=VARDONEP($$,$3,$4)) { $$->addNextNull(vp); vp->valuep($6); } }
	;

portDirNetE:			// IEEE: part of port, optional net type and/or direction
		/* empty */				{ }
	//			// Per spec, if direction given default the nettype.
	//			// The higher level rule may override this VARDTYPE with one later in the parse.
	|	port_direction					{ VARDECL(PORT); VARDTYPE_NDECL(nullptr/*default_nettype*/); }
	|	port_direction { VARDECL(PORT); } net_type	{ VARDTYPE_NDECL(nullptr/*default_nettype*/); }  // net_type calls VARDECL
	|	net_type					{ } // net_type calls VARDECL
	;

port_declNetE:			// IEEE: part of port_declaration, optional net type
		/* empty */				{ }
	|	net_type				{ } // net_type calls VARDECL
	;

portSig<nodep>:
		id/*port*/				{ $$ = new AstPort($<fl>1,PINNUMINC(),*$1); }
	|	idSVKwd					{ $$ = new AstPort($<fl>1,PINNUMINC(),*$1); }
	;

//**********************************************************************
// Interface headers

interface_declaration:		// IEEE: interface_declaration + interface_nonansi_header + interface_ansi_header:
	//			// timeunits_delcarationE is instead in interface_item
		intFront parameter_port_listE portsStarE ';'
			interface_itemListE yENDINTERFACE endLabelE
			{ if ($2) $1->addStmtp($2);
			  if ($3) $1->addStmtp($3);
			  if ($5) $1->addStmtp($5);
			  SYMP->popScope($1); }
	|	yEXTERN intFront parameter_port_listE portsStarE ';'
			{ BBUNSUP($<fl>1, "Unsupported: extern interface"); }
	;

intFront<modulep>:
		yINTERFACE lifetimeE idAny/*new_interface*/
			{ $$ = new AstIface($<fl>3, *$3);
			  $$->inLibrary(true);
			  $$->lifetime($2);
			  PARSEP->rootp()->addModulep($$);
			  SYMP->pushNew($$); }
	;

interface_itemListE<nodep>:
		/* empty */				{ $$ = nullptr; }
	|	interface_itemList			{ $$ = $1; }
	;

interface_itemList<nodep>:
		interface_item				{ $$ = $1; }
	|	interface_itemList interface_item	{ $$ = $1->addNextNull($2); }
	;

interface_item<nodep>:		// IEEE: interface_item + non_port_interface_item
		port_declaration ';'			{ $$ = $1; }
	//			// IEEE: non_port_interface_item
	//			// IEEE: generate_region
	|	interface_generate_region		{ $$ = $1; }
	|	interface_or_generate_item		{ $$ = $1; }
	|	program_declaration			{ $$ = nullptr; BBUNSUP(CRELINE(), "Unsupported: program decls within interface decls"); }
	//			// IEEE 1800-2017: modport_item
	//			// See instead old 2012 position in interface_or_generate_item
	|	interface_declaration			{ $$ = nullptr; BBUNSUP(CRELINE(), "Unsupported: interface decls within interface decls"); }
	|	timeunits_declaration			{ $$ = $1; }
	//			// See note in interface_or_generate item
	|	module_common_item			{ $$ = $1; }
	;

interface_generate_region<nodep>:		// ==IEEE: generate_region
		yGENERATE interface_itemList yENDGENERATE	{ $$ = $2; }
	|	yGENERATE yENDGENERATE			{ $$ = nullptr; }
	;

interface_or_generate_item<nodep>:  // ==IEEE: interface_or_generate_item
	//			    // module_common_item in interface_item, as otherwise duplicated
	//			    // with module_or_generate_item's module_common_item
		modport_declaration			{ $$ = $1; }
	|	extern_tf_declaration			{ $$ = $1; }
	;

//**********************************************************************
// Program headers

anonymous_program<nodep>:	// ==IEEE: anonymous_program
	//			// See the spec - this doesn't change the scope, items still go up "top"
		yPROGRAM ';' anonymous_program_itemListE yENDPROGRAM	{ BBUNSUP($<fl>1, "Unsupported: Anonymous programs"); $$ = nullptr; }
	;

anonymous_program_itemListE<nodep>:	// IEEE: { anonymous_program_item }
		/* empty */				{ $$ = nullptr; }
	|	anonymous_program_itemList		{ $$ = $1; }
	;

anonymous_program_itemList<nodep>:	// IEEE: { anonymous_program_item }
		anonymous_program_item			{ $$ = $1; }
	|	anonymous_program_itemList anonymous_program_item	{ $$ = $1->addNextNull($2); }
	;

anonymous_program_item<nodep>:	// ==IEEE: anonymous_program_item
		task_declaration			{ $$ = $1; }
	|	function_declaration			{ $$ = $1; }
	|	class_declaration			{ $$ = $1; }
	//UNSUP	covergroup_declaration			{ $$ = $1; }
	//			// class_constructor_declaration is part of function_declaration
	|	';'					{ $$ = nullptr; }
	;

program_declaration:		// IEEE: program_declaration + program_nonansi_header + program_ansi_header:
	//			// timeunits_delcarationE is instead in program_item
		pgmFront parameter_port_listE portsStarE ';'
	/*cont*/    program_itemListE yENDPROGRAM endLabelE
			{ $1->modTrace(GRAMMARP->allTracingOn($1->fileline()));  // Stash for implicit wires, etc
			  if ($2) $1->addStmtp($2); if ($3) $1->addStmtp($3);
			  if ($5) $1->addStmtp($5);
			  GRAMMARP->m_modp = nullptr;
			  SYMP->popScope($1);
			  GRAMMARP->endLabel($<fl>7,$1,$7); }
	|	yEXTERN	pgmFront parameter_port_listE portsStarE ';'
			{ BBUNSUP($<fl>1, "Unsupported: extern program");
			  SYMP->popScope($2); }
	;

pgmFront<modulep>:
		yPROGRAM lifetimeE idAny/*new_program*/
			{ $$ = new AstModule($<fl>3, *$3, true);
			  $$->lifetime($2);
			  $$->inLibrary(PARSEP->inLibrary() || $$->fileline()->celldefineOn());
			  $$->modTrace(GRAMMARP->allTracingOn($$->fileline()));
			  $$->timeunit(PARSEP->timeLastUnit());
			  PARSEP->rootp()->addModulep($$);
			  SYMP->pushNew($$);
			  GRAMMARP->m_modp = $$; }
	;

program_itemListE<nodep>:	// ==IEEE: [{ program_item }]
		/* empty */				{ $$ = nullptr; }
	|	program_itemList			{ $$ = $1; }
	;

program_itemList<nodep>:	// ==IEEE: { program_item }
		program_item				{ $$ = $1; }
	|	program_itemList program_item		{ $$ = $1->addNextNull($2); }
	;

program_item<nodep>:		// ==IEEE: program_item
		port_declaration ';'			{ $$ = $1; }
	|	non_port_program_item			{ $$ = $1; }
	;

non_port_program_item<nodep>:	// ==IEEE: non_port_program_item
		continuous_assign			{ $$ = $1; }
	|	module_or_generate_item_declaration	{ $$ = $1; }
	|	initial_construct			{ $$ = $1; }
	|	final_construct				{ $$ = $1; }
	|	concurrent_assertion_item		{ $$ = $1; }
	|	timeunits_declaration			{ $$ = $1; }
	|	program_generate_item			{ $$ = $1; }
	;

program_generate_item<nodep>:		// ==IEEE: program_generate_item
		loop_generate_construct			{ $$ = $1; }
	|	conditional_generate_construct		{ $$ = $1; }
	|	generate_region				{ $$ = $1; }
	|	elaboration_system_task			{ $$ = $1; }
	;

extern_tf_declaration<nodep>:		// ==IEEE: extern_tf_declaration
		yEXTERN task_prototype ';'		{ $$ = nullptr; BBUNSUP($<fl>1, "Unsupported: extern task"); }
	|	yEXTERN function_prototype ';'		{ $$ = nullptr; BBUNSUP($<fl>1, "Unsupported: extern function"); }
	|	yEXTERN yFORKJOIN task_prototype ';'	{ $$ = nullptr; BBUNSUP($<fl>1, "Unsupported: extern forkjoin"); }
	;

modport_declaration<nodep>:		// ==IEEE: modport_declaration
		yMODPORT modport_itemList ';'		{ $$ = $2; }
	;

modport_itemList<nodep>:		// IEEE: part of modport_declaration
		modport_item				{ $$ = $1; }
	|	modport_itemList ',' modport_item	{ $$ = $1->addNextNull($3); }
	;

modport_item<nodep>:			// ==IEEE: modport_item
		id/*new-modport*/ '('
	/*mid*/		{ VARRESET_NONLIST(UNKNOWN); VARIO(INOUT); }
	/*cont*/    modportPortsDeclList ')'		{ $$ = new AstModport($<fl>1, *$1, $4); }
	;

modportPortsDeclList<nodep>:
		modportPortsDecl			    { $$ = $1; }
	|	modportPortsDeclList ',' modportPortsDecl   { $$ = $1->addNextNull($3); }
	;

// IEEE: modport_ports_declaration  + modport_simple_ports_declaration
//	+ (modport_tf_ports_declaration+import_export) + modport_clocking_declaration
// We've expanded the lists each take to instead just have standalone ID ports.
// We track the type as with the V2k series of defines, then create as each ID is seen.
modportPortsDecl<nodep>:
	//			// IEEE: modport_simple_ports_declaration
		port_direction modportSimplePort	{ $$ = new AstModportVarRef($<fl>2, *$2, GRAMMARP->m_varIO); }
	//			// IEEE: modport_clocking_declaration
	|	yCLOCKING idAny/*clocking_identifier*/	{ $$ = nullptr; BBUNSUP($<fl>1, "Unsupported: Modport clocking"); }
	//			// IEEE: yIMPORT modport_tf_port
	//			// IEEE: yEXPORT modport_tf_port
	//			// modport_tf_port expanded here
	|	yIMPORT id/*tf_identifier*/		{ $$ = new AstModportFTaskRef($<fl>2, *$2, false); }
	|	yEXPORT id/*tf_identifier*/		{ $$ = new AstModportFTaskRef($<fl>2, *$2, true); }
	|	yIMPORT method_prototype		{ $$ = nullptr; BBUNSUP($<fl>1, "Unsupported: Modport import with prototype"); }
	|	yEXPORT method_prototype		{ $$ = nullptr; BBUNSUP($<fl>1, "Unsupported: Modport export with prototype"); }
	// Continuations of above after a comma.
	//			// IEEE: modport_simple_ports_declaration
	|	modportSimplePort			{ $$ = new AstModportVarRef($<fl>1,*$1,GRAMMARP->m_varIO); }
	;

modportSimplePort<strp>:	// IEEE: modport_simple_port or modport_tf_port, depending what keyword was earlier
		id					{ $$ = $1; }
	//UNSUP	'.' idAny '(' ')'			{ }
	//UNSUP	'.' idAny '(' expr ')'			{ }
	;

//************************************************
// Variable Declarations

genvar_declaration<nodep>:	// ==IEEE: genvar_declaration
		yGENVAR list_of_genvar_identifiers ';'	{ $$ = $2; }
	;

list_of_genvar_identifiers<nodep>:	// IEEE: list_of_genvar_identifiers (for declaration)
		genvar_identifierDecl			{ $$ = $1; }
	|	list_of_genvar_identifiers ',' genvar_identifierDecl	{ $$ = $1->addNext($3); }
	;

genvar_identifierDecl<varp>:		// IEEE: genvar_identifier (for declaration)
		id/*new-genvar_identifier*/ sigAttrListE
			{ VARRESET_NONLIST(GENVAR); VARDTYPE(new AstBasicDType($<fl>1,AstBasicDTypeKwd::INTEGER));
			  $$ = VARDONEA($<fl>1, *$1, nullptr, $2); }
	;

parameter_declaration<nodep>:	// IEEE: local_ or parameter_declaration
	//			// IEEE: yPARAMETER yTYPE list_of_type_assignments ';'
	//			// Instead of list_of_type_assignments
	//			// we use list_of_param_assignments because for port handling
	//			// it already must accept types, so simpler to have code only one place
	//			// Front must execute first so VARDTYPE is ready before list of vars
		parameter_declarationFront list_of_param_assignments		{ $$ = $2; }
	|	parameter_declarationTypeFront list_of_type_assignments		{ $$ = $2; }
	;

parameter_declarationFront:	// IEEE: local_ or parameter_declaration w/o assignment
	//			// Front must execute first so VARDTYPE is ready before list of vars
		varParamReset implicit_typeE 		{ /*VARRESET-in-varParam*/ VARDTYPE($2); }
	|	varParamReset data_type			{ /*VARRESET-in-varParam*/ VARDTYPE($2); }
	;

parameter_declarationTypeFront:	// IEEE: local_ or parameter_declaration w/o assignment
	//			// Front must execute first so VARDTYPE is ready before list of vars
		varParamReset yTYPE			{ /*VARRESET-in-varParam*/ VARDTYPE(new AstParseTypeDType($2)); }
	;

parameter_port_declarationFrontE: // IEEE: local_ or parameter_port_declaration w/o assignment
	//			// IEEE: parameter_declaration (minus assignment)
	//			// IEEE: local_parameter_declaration (minus assignment)
	//			// Front must execute first so VARDTYPE is ready before list of vars
		varParamReset implicit_typeE 		{ /*VARRESET-in-varParam*/ VARDTYPE($2); }
	|	varParamReset data_type			{ /*VARRESET-in-varParam*/ VARDTYPE($2); }
	|	implicit_typeE 				{ /*VARRESET-in-varParam*/ VARDTYPE($1); }
	|	data_type				{ /*VARRESET-in-varParam*/ VARDTYPE($1); }
	;

parameter_port_declarationTypeFrontE: // IEEE: parameter_port_declaration w/o assignment
	//			// IEEE: parameter_declaration (minus assignment)
	//			// IEEE: local_parameter_declaration (minus assignment)
	//			// Front must execute first so VARDTYPE is ready before list of vars
		varParamReset yTYPE			{ /*VARRESET-in-varParam*/ VARDTYPE(new AstParseTypeDType($2)); }
	|	yTYPE					{ /*VARRESET-in-varParam*/ VARDTYPE(new AstParseTypeDType($1)); }
	;

net_declaration<nodep>:		// IEEE: net_declaration - excluding implict
		net_declarationFront netSigList ';'	{ $$ = $2; }
	;

net_declarationFront:		// IEEE: beginning of net_declaration
		net_declRESET net_type   strengthSpecE net_scalaredE net_dataTypeE { VARDTYPE_NDECL($5); }
	//UNSUP	net_declRESET yINTERCONNECT signingE rangeListE { VARNET($2); VARDTYPE(x); }
	;

net_declRESET:
		/* empty */ 				{ VARRESET_NONLIST(UNKNOWN); }
	;

net_scalaredE:
		/* empty */ 				{ }
	//			//UNSUP: ySCALARED/yVECTORED ignored
	|	ySCALARED			 	{ }
	|	yVECTORED				{ }
	;

net_dataTypeE<dtypep>:
	//			// If there's a SV data type there shouldn't be a delay on this wire
	//			// Otherwise #(...) can't be determined to be a delay or parameters
	//			// Submit this as a footnote to the committee
		var_data_type	 			{ $$ = $1; }
	|	signingE rangeList delayE 		{ $$ = GRAMMARP->addRange(new AstBasicDType($2->fileline(), LOGIC, $1),$2,true); }  // not implicit
	|	signing					{ $$ = new AstBasicDType($<fl>1, LOGIC, $1); }  // not implicit
	|	/*implicit*/ delayE 			{ $$ = new AstBasicDType(CRELINE(), LOGIC); }  // not implicit
	;

net_type:			// ==IEEE: net_type
		ySUPPLY0				{ VARDECL(SUPPLY0); }
	|	ySUPPLY1				{ VARDECL(SUPPLY1); }
	|	yTRI 					{ VARDECL(TRIWIRE); }
	|	yTRI0 					{ VARDECL(TRI0); }
	|	yTRI1 					{ VARDECL(TRI1); }
	|	yTRIAND 				{ VARDECL(WIRE); BBUNSUP($1, "Unsupported: triand"); }
	|	yTRIOR 					{ VARDECL(WIRE); BBUNSUP($1, "Unsupported: trior"); }
	|	yTRIREG 				{ VARDECL(WIRE); BBUNSUP($1, "Unsupported: trireg"); }
	|	yWAND 					{ VARDECL(WIRE); BBUNSUP($1, "Unsupported: wand"); }
	|	yWIRE 					{ VARDECL(WIRE); }
	|	yWOR 					{ VARDECL(WIRE); BBUNSUP($1, "Unsupported: wor"); }
	//			// VAMS - somewhat hackish
	|	yWREAL 					{ VARDECL(WREAL); }
	;

varParamReset:
		yPARAMETER				{ VARRESET_NONLIST(GPARAM); }
	|	yLOCALPARAM				{ VARRESET_NONLIST(LPARAM); }
	;

port_direction:			// ==IEEE: port_direction + tf_port_direction
	//			// IEEE 19.8 just "input" FIRST forces type to wire - we'll ignore that here
	//			// Only used for ANSI declarations
		yINPUT					{ GRAMMARP->m_pinAnsi=true; VARIO(INPUT); }
	|	yOUTPUT					{ GRAMMARP->m_pinAnsi=true; VARIO(OUTPUT); }
	|	yINOUT					{ GRAMMARP->m_pinAnsi=true; VARIO(INOUT); }
	|	yREF					{ GRAMMARP->m_pinAnsi=true; VARIO(REF); }
	|	yCONST__REF yREF			{ GRAMMARP->m_pinAnsi=true; VARIO(CONSTREF); }
	;

port_directionReset:		// IEEE: port_direction that starts a port_declaraiton
	//			// Used only for declarations outside the port list
		yINPUT					{ VARRESET_NONLIST(UNKNOWN); VARIO(INPUT); }
	|	yOUTPUT					{ VARRESET_NONLIST(UNKNOWN); VARIO(OUTPUT); }
	|	yINOUT					{ VARRESET_NONLIST(UNKNOWN); VARIO(INOUT); }
	|	yREF					{ VARRESET_NONLIST(UNKNOWN); VARIO(REF); }
	|	yCONST__REF yREF			{ VARRESET_NONLIST(UNKNOWN); VARIO(CONSTREF); }
	;

port_declaration<nodep>:	// ==IEEE: port_declaration
	//			// Non-ANSI; used inside block followed by ';'
	//			// SEE ALSO port, tf_port_declaration, data_declarationVarFront
	//
	//			// IEEE: inout_declaration
	//			// IEEE: input_declaration
	//			// IEEE: output_declaration
	//			// IEEE: ref_declaration
		port_directionReset port_declNetE data_type
	/*mid*/		{ VARDTYPE($3); }
	/*cont*/    list_of_variable_decl_assignments			{ $$ = $5; }
	|	port_directionReset port_declNetE yVAR data_type
	/*mid*/		{ VARDTYPE($4); }
	/*cont*/    list_of_variable_decl_assignments			{ $$ = $6; }
	|	port_directionReset port_declNetE yVAR implicit_typeE
	/*mid*/		{ VARDTYPE($4); }
	/*cont*/    list_of_variable_decl_assignments			{ $$ = $6; }
	|	port_directionReset port_declNetE signingE rangeList
	/*mid*/		{ VARDTYPE_NDECL(GRAMMARP->addRange(new AstBasicDType($4->fileline(), LOGIC_IMPLICIT, $3), $4, true)); }
	/*cont*/    list_of_variable_decl_assignments			{ $$ = $6; }
	|	port_directionReset port_declNetE signing
	/*mid*/		{ VARDTYPE_NDECL(new AstBasicDType($<fl>3, LOGIC_IMPLICIT, $3)); }
	/*cont*/    list_of_variable_decl_assignments			{ $$ = $5; }
	|	port_directionReset port_declNetE /*implicit*/
	/*mid*/		{ VARDTYPE_NDECL(nullptr);/*default_nettype*/}
	/*cont*/    list_of_variable_decl_assignments			{ $$ = $4; }
	//			// IEEE: interface_declaration
	//			// Looks just like variable declaration unless has a period
	//			// See etcInst
	;

tf_port_declaration<nodep>:	// ==IEEE: tf_port_declaration
	//			// Used inside function; followed by ';'
	//			// SEE ALSO port_declaration, port, data_declarationVarFront
	//
		port_directionReset      data_type      { VARDTYPE($2); }  list_of_tf_variable_identifiers ';'	{ $$ = $4; }
	|	port_directionReset      implicit_typeE { VARDTYPE_NDECL($2); }  list_of_tf_variable_identifiers ';'	{ $$ = $4; }
	|	port_directionReset yVAR data_type      { VARDTYPE($3); }  list_of_tf_variable_identifiers ';'	{ $$ = $5; }
	|	port_directionReset yVAR implicit_typeE { VARDTYPE($3); }  list_of_tf_variable_identifiers ';'	{ $$ = $5; }
	;

integer_atom_type<bdtypep>:	// ==IEEE: integer_atom_type
		yBYTE					{ $$ = new AstBasicDType($1,AstBasicDTypeKwd::BYTE); }
	|	ySHORTINT				{ $$ = new AstBasicDType($1,AstBasicDTypeKwd::SHORTINT); }
	|	yINT					{ $$ = new AstBasicDType($1,AstBasicDTypeKwd::INT); }
	|	yLONGINT				{ $$ = new AstBasicDType($1,AstBasicDTypeKwd::LONGINT); }
	|	yINTEGER				{ $$ = new AstBasicDType($1,AstBasicDTypeKwd::INTEGER); }
	|	yTIME					{ $$ = new AstBasicDType($1,AstBasicDTypeKwd::TIME); }
	;

integer_vector_type<bdtypep>:	// ==IEEE: integer_atom_type
		yBIT					{ $$ = new AstBasicDType($1,AstBasicDTypeKwd::BIT); }
	|	yLOGIC					{ $$ = new AstBasicDType($1,AstBasicDTypeKwd::LOGIC); }
	|	yREG					{ $$ = new AstBasicDType($1,AstBasicDTypeKwd::LOGIC); } // logic==reg
	;

non_integer_type<bdtypep>:	// ==IEEE: non_integer_type
		yREAL					{ $$ = new AstBasicDType($1,AstBasicDTypeKwd::DOUBLE); }
	|	yREALTIME				{ $$ = new AstBasicDType($1,AstBasicDTypeKwd::DOUBLE); }
	|	ySHORTREAL				{ $$ = new AstBasicDType($1,AstBasicDTypeKwd::DOUBLE); UNSUPREAL($1); }
	;

signingE<signstate>:		// IEEE: signing - plus empty
		/*empty*/ 				{ $$ = VSigning::NOSIGN; }
	|	signing					{ $$ = $1; }
	;

signing<signstate>:		// ==IEEE: signing
		ySIGNED					{ $<fl>$ = $<fl>1; $$ = VSigning::SIGNED; }
	|	yUNSIGNED				{ $<fl>$ = $<fl>1; $$ = VSigning::UNSIGNED; }
	;

//************************************************
// Data Types

simple_type<dtypep>:		// ==IEEE: simple_type
	//			// IEEE: integer_type
		integer_atom_type			{ $$ = $1; }
	|	integer_vector_type			{ $$ = $1; }
	|	non_integer_type			{ $$ = $1; }
	//			// IEEE: ps_type_identifier
	//			// IEEE: ps_parameter_identifier (presumably a PARAMETER TYPE)
	//			// Even though we looked up the type and have a AstNode* to it,
	//			// we can't fully resolve it because it may have been just a forward definition.
	|	packageClassScopeE idType
			{ AstRefDType* refp = new AstRefDType($<fl>2, *$2, $1, nullptr);
			  $$ = refp; }
	//
	//			// { generate_block_identifer ... } '.'
	//			// Need to determine if generate_block_identifier can be lex-detected
	;

data_type<dtypep>:		// ==IEEE: data_type
	//			// This expansion also replicated elsewhere, IE data_type__AndID
		data_typeNoRef				{ $$ = $1; }
	//
	//			// REFERENCES
	//
	//			// IEEE: [ class_scope | package_scope ] type_identifier { packed_dimension }
	//			// IEEE: class_type
	//			// IEEE: ps_covergroup_identifier
	//			// Don't distinguish between types and classes so all these combined
	|	packageClassScopeE idType packed_dimensionListE
			{ AstRefDType* refp = new AstRefDType($<fl>2, *$2, $1, nullptr);
			  $$ = GRAMMARP->createArray(refp, $3, true); }
	|	packageClassScopeE idType parameter_value_assignmentClass packed_dimensionListE
			{ AstRefDType* refp = new AstRefDType($<fl>2, *$2, $1, $3);
			  $$ = GRAMMARP->createArray(refp, $4, true); }
	;

data_typeBasic<dtypep>:		// IEEE: part of data_type
		integer_vector_type signingE rangeListE	{ $1->setSignedState($2); $$ = GRAMMARP->addRange($1,$3,true); }
	|	integer_atom_type signingE		{ $1->setSignedState($2); $$ = $1; }
	|	non_integer_type			{ $$ = $1; }
	;

data_typeNoRef<dtypep>:		// ==IEEE: data_type, excluding class_type etc references
		data_typeBasic				{ $$ = $1; }
	|	struct_unionDecl packed_dimensionListE	{ $$ = GRAMMARP->createArray(new AstDefImplicitDType($1->fileline(),"__typeimpsu"+cvtToStr(GRAMMARP->s_modTypeImpNum++),
													     SYMP,VFlagChildDType(),$1),$2,true); }
	|	enumDecl				{ $$ = new AstDefImplicitDType($1->fileline(),"__typeimpenum"+cvtToStr(GRAMMARP->s_modTypeImpNum++),
										       SYMP,VFlagChildDType(),$1); }
	|	ySTRING					{ $$ = new AstBasicDType($1,AstBasicDTypeKwd::STRING); }
	|	yCHANDLE				{ $$ = new AstBasicDType($1,AstBasicDTypeKwd::CHANDLE); }
	|	yEVENT					{ $$ = new AstBasicDType($1,AstBasicDTypeKwd::EVENTVALUE); }
	//			// Rules overlap virtual_interface_declaration
	//			// Parameters here are SV2009
	//			// IEEE has ['.' modport] but that will conflict with port
	//			// declarations which decode '.' modport themselves, so
	//			// instead see data_typeVar
	|	yVIRTUAL__INTERFACE yINTERFACE id/*interface*/	{ $$ = nullptr; BBUNSUP($1, "Unsupported: virtual interface"); }
	|	yVIRTUAL__anyID                id/*interface*/	{ $$ = nullptr; BBUNSUP($1, "Unsupported: virtual data type"); }
	|	type_reference				{ $$ = $1; }
	//			// IEEE: class_scope: see data_type above
	//			// IEEE: class_type: see data_type above
	//			// IEEE: ps_covergroup: see data_type above
	;

data_type_or_void<dtypep>:	// ==IEEE: data_type_or_void
		data_type				{ $$ = $1; }
	//UNSUP	yVOID					{ UNSUP }	// No yTAGGED structures
	;

var_data_type<dtypep>:		// ==IEEE: var_data_type
		data_type				{ $$ = $1; }
	|	yVAR data_type				{ $$ = $2; }
	|	yVAR implicit_typeE			{ $$ = $2; }
	;

type_reference<dtypep>:  	// ==IEEE: type_reference
		yTYPE '(' exprOrDataType ')'
			{ $$ = new AstRefDType($1, AstRefDType::FlagTypeOfExpr(), $3); }
	;

struct_unionDecl<uorstructp>:	// IEEE: part of data_type
	//			// packedSigningE is NOP for unpacked
		ySTRUCT        packedSigningE '{'
	/*mid*/ 	{ $<uorstructp>$ = new AstStructDType($1, $2); SYMP->pushNew($<uorstructp>$); }
	/*cont*/    struct_union_memberList '}'
			{ $$=$<uorstructp>4; $$->addMembersp($5); SYMP->popScope($$); }
	|	yUNION taggedE packedSigningE '{'
	/*mid*/		{ $<uorstructp>$ = new AstUnionDType($1, $3); SYMP->pushNew($<uorstructp>$); }
	/*cont*/    struct_union_memberList '}'
			{ $$=$<uorstructp>5; $$->addMembersp($6); SYMP->popScope($$); }
	;

struct_union_memberList<nodep>:	// IEEE: { struct_union_member }
		struct_union_member				{ $$ = $1; }
	|	struct_union_memberList struct_union_member	{ $$ = $1->addNextNull($2); }
	;

struct_union_member<nodep>:	// ==IEEE: struct_union_member
	//			// UNSUP random_qualifer not propagagted until have randomize support
		random_qualifierE data_type_or_void
	/*mid*/		{ GRAMMARP->m_memDTypep = $2; }  // As a list follows, need to attach this dtype to each member.
	/*cont*/    list_of_member_decl_assignments ';'		{ $$ = $4; GRAMMARP->m_memDTypep = nullptr; }
	|	vlTag					{ $$ = nullptr; }
	;

list_of_member_decl_assignments<nodep>:	// Derived from IEEE: list_of_variable_decl_assignments
		member_decl_assignment		{ $$ = $1; }
	|	list_of_member_decl_assignments ',' member_decl_assignment	{ $$ = $1->addNextNull($3); }
	;

member_decl_assignment<memberp>:	// Derived from IEEE: variable_decl_assignment
	//			// At present we allow only packed structures/unions.  So this is different from variable_decl_assignment
		id variable_dimensionListE
			{ if ($2) $2->v3warn(UNPACKED, "Unsupported: Unpacked array in packed struct/union (struct/union converted to unpacked)");
			  $$ = new AstMemberDType($<fl>1, *$1, VFlagChildDType(),
						  AstNodeDType::cloneTreeNull(GRAMMARP->m_memDTypep, true));
                          PARSEP->tagNodep($$);
                          }
	|	id variable_dimensionListE '=' variable_declExpr
			{ BBUNSUP($4, "Unsupported: Initial values in struct/union members.");
			  // But still need error if packed according to IEEE 7.2.2
			  $$ = nullptr; }
	|	idSVKwd					{ $$ = nullptr; }
	//
	//			// IEEE: "dynamic_array_variable_identifier '[' ']' [ '=' dynamic_array_new ]"
	//			// Matches above with variable_dimensionE = "[]"
	//			// IEEE: "class_variable_identifier [ '=' class_new ]"
	//			// variable_dimensionE must be empty
	//			// Pushed into variable_declExpr:dynamic_array_new
	//
	//			// IEEE: "[ covergroup_variable_identifier ] '=' class_new
	//			// Pushed into variable_declExpr:class_new
	|	'=' class_new				{ nullptr; BBUNSUP($1, "Unsupported: member declaration assignment with new()"); }
	;

list_of_variable_decl_assignments<varp>:	// ==IEEE: list_of_variable_decl_assignments
		variable_decl_assignment		{ $$ = $1; }
	|	list_of_variable_decl_assignments ',' variable_decl_assignment	{ $$ = VN_CAST($1->addNextNull($3), Var); }
	;

variable_decl_assignment<varp>:	// ==IEEE: variable_decl_assignment
		id variable_dimensionListE sigAttrListE
			{ $$ = VARDONEA($<fl>1,*$1,$2,$3); }
	|	id variable_dimensionListE sigAttrListE '=' variable_declExpr
			{ $$ = VARDONEA($<fl>1,*$1,$2,$3); $$->valuep($5); }
	|	idSVKwd					{ $$ = nullptr; }
	//
	//			// IEEE: "dynamic_array_variable_identifier '[' ']' [ '=' dynamic_array_new ]"
	//			// Matches above with variable_dimensionE = "[]"
	//			// IEEE: "class_variable_identifier [ '=' class_new ]"
	//			// variable_dimensionE must be empty
	//			// Pushed into variable_declExpr:dynamic_array_new
	//
	//			// IEEE: "[ covergroup_variable_identifier ] '=' class_new
	//			// Pushed into variable_declExpr:class_new
	|	'=' class_new				{ nullptr; BBUNSUP($1, "Unsupported: declaration assignment with new()"); }
	;

list_of_tf_variable_identifiers<nodep>: // ==IEEE: list_of_tf_variable_identifiers
		tf_variable_identifier			{ $$ = $1; }
	|	list_of_tf_variable_identifiers ',' tf_variable_identifier	{ $$ = $1->addNext($3); }
	;

tf_variable_identifier<varp>:		// IEEE: part of list_of_tf_variable_identifiers
		id variable_dimensionListE sigAttrListE exprEqE
			{ $$ = VARDONEA($<fl>1,*$1, $2, $3);
                          if ($4) $$->addNext(new AstAssign($4->fileline(), new AstVarRef($<fl>1, *$1, VAccess::WRITE), $4)); }
	;

variable_declExpr<nodep>:		// IEEE: part of variable_decl_assignment - rhs of expr
		expr					{ $$ = $1; }
	|	dynamic_array_new			{ $$ = $1; }
	|	class_new				{ $$ = $1; }
	;

variable_dimensionListE<rangep>:	// IEEE: variable_dimension + empty
		/*empty*/				{ $$ = nullptr; }
	|	variable_dimensionList			{ $$ = $1; }
	;

variable_dimensionList<rangep>:	// IEEE: variable_dimension + empty
		variable_dimension			{ $$ = $1; }
	|	variable_dimensionList variable_dimension	{ $$ = VN_CAST($1->addNext($2), NodeRange); }
	;

variable_dimension<rangep>:	// ==IEEE: variable_dimension
	//			// IEEE: unsized_dimension
		'[' ']'					{ $$ = new AstUnsizedRange($1); }
	//			// IEEE: unpacked_dimension
	|	anyrange				{ $$ = $1; }
	//			// IEEE: unpacked_dimension (if const_expr)
	//			// IEEE: associative_dimension (if data_type)
	//			// Can't tell which until see if expr is data type or not
	|	'[' exprOrDataType ']'			{ $$ = new AstBracketRange($1, $2); }
	|	yP_BRASTAR ']'				{ $$ = nullptr; BBUNSUP($1, "Unsupported: [*] wildcard associative arrays"); }
	|	'[' '*' ']'				{ $$ = nullptr; BBUNSUP($2, "Unsupported: [*] wildcard associative arrays"); }
	//			// IEEE: queue_dimension
	//			// '[' '$' ']' -- $ is part of expr, see '[' constExpr ']'
	//			// '[' '$' ':' expr ']' -- anyrange:expr:$
	;

random_qualifierE<qualifiers>:	// IEEE: random_qualifier + empty
		/*empty*/				{ $$ = VMemberQualifiers::none(); }
	|	random_qualifier			{ $$ = $1; }
	;

random_qualifier<qualifiers>:	// ==IEEE: random_qualifier
		yRAND					{ $$ = VMemberQualifiers::none(); $$.m_rand = true; }
	|	yRANDC					{ $$ = VMemberQualifiers::none(); $$.m_randc = true; }
	;

taggedE:
		/*empty*/				{ }
	//UNSUP	yTAGGED					{ UNSUP }
	;

packedSigningE<signstate>:
	//			// VSigning::NOSIGN overloaded to indicate not packed
		/*empty*/				{ $$ = VSigning::NOSIGN; }
	|	yPACKED signingE			{ $$ = $2; if ($$ == VSigning::NOSIGN) $$ = VSigning::UNSIGNED; }
	;

//************************************************
// enum

// IEEE: part of data_type
enumDecl<dtypep>:
		yENUM enum_base_typeE '{' enum_nameList '}' { $$ = new AstEnumDType($1,VFlagChildDType(),$2,$4); }
	;

enum_base_typeE<dtypep>:	// IEEE: enum_base_type
		/* empty */				{ $$ = new AstBasicDType(CRELINE(), AstBasicDTypeKwd::INT); }
	//			// Not in spec, but obviously "enum [1:0]" should work
	//			// implicit_type expanded, without empty
	//			// Note enum base types are always packed data types
	|	signingE rangeList			{ $$ = GRAMMARP->addRange(new AstBasicDType($2->fileline(), LOGIC_IMPLICIT, $1),$2,true); }
	|	signing					{ $$ = new AstBasicDType($<fl>1, LOGIC_IMPLICIT, $1); }
	//
	|	integer_atom_type signingE		{ $1->setSignedState($2); $$ = $1; }
	|	integer_vector_type signingE rangeListE	{ $1->setSignedState($2); $$ = GRAMMARP->addRange($1,$3,true); }
	//			// below can be idAny or yaID__aTYPE
	//			// IEEE requires a type, though no shift conflict if idAny
	//			// IEEE: type_identifier [ packed_dimension ]
	//			// however other simulators allow [ class_scope | package_scope ] type_identifier
	|	idAny rangeListE
			{ $$ = GRAMMARP->createArray(new AstRefDType($<fl>1, *$1), $2, true); }
	|	packageClassScope idAny rangeListE
			{ AstRefDType* refp = new AstRefDType($<fl>2, *$2, $1, nullptr);
			  $$ = GRAMMARP->createArray(refp, $3, true); }
	;

enum_nameList<nodep>:
		enum_name_declaration			{ $$ = $1; }
	|	enum_nameList ',' enum_name_declaration	{ $$ = $1->addNextNull($3); }
	;

enum_name_declaration<nodep>:	// ==IEEE: enum_name_declaration
		idAny/*enum_identifier*/ enumNameRangeE enumNameStartE	{ $$ = new AstEnumItem($<fl>1, *$1, $2, $3); }
	;

enumNameRangeE<nodep>:		// IEEE: second part of enum_name_declaration
		/* empty */				{ $$ = nullptr; }
	|	'[' intnumAsConst ']'			{ $$ = new AstRange($1, new AstConst($1, 0), new AstConst($1, $2->toSInt()-1)); }
	|	'[' intnumAsConst ':' intnumAsConst ']'	{ $$ = new AstRange($1,$2,$4); }
	;

enumNameStartE<nodep>:		// IEEE: third part of enum_name_declaration
		/* empty */				{ $$ = nullptr; }
	|	'=' constExpr				{ $$ = $2; }
	;

intnumAsConst<constp>:
		yaINTNUM				{ $$ = new AstConst($<fl>1,*$1); }
	;

//************************************************
// Typedef

data_declaration<nodep>:	// ==IEEE: data_declaration
	//			// VARRESET can't be called here - conflicts
		data_declarationVar			{ $$ = $1; }
	|	type_declaration			{ $$ = $1; }
	|	package_import_declaration		{ $$ = $1; }
	//			// IEEE: virtual_interface_declaration
	//			// "yVIRTUAL yID yID" looks just like a data_declaration
	//			// Therefore the virtual_interface_declaration term isn't used
	//			// 1800-2009:
	//UNSUP	net_type_declaration			{ $$ = $1; }
	|	vlTag					{ $$ = nullptr; }
	;

class_property<nodep>:		// ==IEEE: class_property, which is {property_qualifier} data_declaration
		memberQualListE data_declarationVarClass		{ $$ = $2; $1.applyToNodes($2); }
	//			// UNSUP: Import needs to apply local/protected from memberQualList, and error on others
	|	memberQualListE type_declaration			{ $$ = $2; }
	//			// UNSUP: Import needs to apply local/protected from memberQualList, and error on others
	|	memberQualListE package_import_declaration		{ $$ = $2; }
	//			// IEEE: virtual_interface_declaration
	//			// "yVIRTUAL yID yID" looks just like a data_declaration
	//			// Therefore the virtual_interface_declaration term isn't used
	;

data_declarationVar<varp>:	// IEEE: part of data_declaration
	//			// The first declaration has complications between assuming what's the type vs ID declaring
		data_declarationVarFront list_of_variable_decl_assignments ';'	{ $$ = $2; }
	;

data_declarationVarClass<varp>: // IEEE: part of data_declaration (for class_property)
	//			// The first declaration has complications between assuming what's the type vs ID declaring
		data_declarationVarFrontClass list_of_variable_decl_assignments ';'	{ $$ = $2; }
	;

data_declarationVarFront:	// IEEE: part of data_declaration
	//			// Non-ANSI; used inside block followed by ';'
	//			// SEE ALSO port_declaration, tf_port_declaration, port
	//
	//			// Expanded: "constE yVAR lifetimeE data_type"
	//			// implicit_type expanded into /*empty*/ or "signingE rangeList"
		yVAR lifetimeE data_type
			{ VARRESET_NONLIST(VAR); VARLIFE($2); VARDTYPE($3); }
	|	yVAR lifetimeE
			{ VARRESET_NONLIST(VAR); VARLIFE($2);
			  VARDTYPE(new AstBasicDType($<fl>1, LOGIC_IMPLICIT)); }
	|	yVAR lifetimeE signingE rangeList
			{ /*VARRESET-in-ddVar*/ VARLIFE($2);
    			  VARDTYPE(GRAMMARP->addRange(new AstBasicDType($<fl>1, LOGIC_IMPLICIT, $3), $4,true)); }
	//
	//			// implicit_type expanded into /*empty*/ or "signingE rangeList"
	|	yCONST__ETC yVAR lifetimeE data_type
			{ VARRESET_NONLIST(VAR); VARLIFE($3);
			  VARDTYPE(new AstConstDType($<fl>2, VFlagChildDType(), $4)); }
	|	yCONST__ETC yVAR lifetimeE
			{ VARRESET_NONLIST(VAR); VARLIFE($3);
			  VARDTYPE(new AstConstDType($<fl>2, VFlagChildDType(), new AstBasicDType($<fl>2, LOGIC_IMPLICIT))); }
	|	yCONST__ETC yVAR lifetimeE signingE rangeList
			{ VARRESET_NONLIST(VAR); VARLIFE($3);
			 VARDTYPE(new AstConstDType($<fl>2, VFlagChildDType(),
				  GRAMMARP->addRange(new AstBasicDType($<fl>2, LOGIC_IMPLICIT, $4), $5,true))); }
	//
	//			// Expanded: "constE lifetimeE data_type"
	|	/**/		      data_type		{ VARRESET_NONLIST(VAR); VARDTYPE($1); }
	|	/**/	    lifetime  data_type		{ VARRESET_NONLIST(VAR); VARLIFE($1); VARDTYPE($2); }
	|	yCONST__ETC lifetimeE data_type
			{ VARRESET_NONLIST(VAR); VARLIFE($2);
			  VARDTYPE(new AstConstDType($<fl>1, VFlagChildDType(), $3)); }
	//			// = class_new is in variable_decl_assignment
	;

data_declarationVarFrontClass:	// IEEE: part of data_declaration (for class_property)
	//			// VARRESET called before this rule
	//			// yCONST is removed, added to memberQual rules
	//			// implicit_type expanded into /*empty*/ or "signingE rangeList"
		yVAR lifetimeE data_type	{ VARRESET_NONLIST(VAR); VARLIFE($2); VARDTYPE($3); }
	|	yVAR lifetimeE			{ VARRESET_NONLIST(VAR); VARLIFE($2); }
	|	yVAR lifetimeE signingE rangeList
			{ /*VARRESET-in-ddVar*/ VARDTYPE(GRAMMARP->addRange(new AstBasicDType($<fl>1, LOGIC_IMPLICIT, $3), $4,true));
			VARLIFE($2); }
	//
	//			// Expanded: "constE lifetimeE data_type"
	|	data_type			{ VARRESET_NONLIST(VAR); VARDTYPE($1); }
	//			// lifetime is removed, added to memberQual rules to avoid conflict
	//			// yCONST is removed, added to memberQual rules to avoid conflict
	//			// = class_new is in variable_decl_assignment
	;

//UNSUPnet_type_declaration:		// IEEE: net_type_declaration
//UNSUP		yNETTYPE data_type idAny/*net_type_identifier*/ ';' { }
//UNSUP	//			// package_scope part of data_type
//UNSUP	|	yNETTYPE data_type idAny yWITH__ETC packageClassScope id/*tf_identifier*/ ';' { }
//UNSUP	|	yNETTYPE packageClassScope id/*net_type_identifier*/ idAny/*net_type_identifier*/ ';' { }
//UNSUP	;

implicit_typeE<dtypep>:		// IEEE: part of *data_type_or_implicit
	//			// Also expanded in data_declaration
		/* empty */				{ $$ = nullptr; }
	|	signingE rangeList			{ $$ = GRAMMARP->addRange(new AstBasicDType($2->fileline(), LOGIC_IMPLICIT, $1),$2,true); }
	|	signing					{ $$ = new AstBasicDType($<fl>1, LOGIC_IMPLICIT, $1); }
	;

//UNSUPassertion_variable_declaration:  // IEEE: assertion_variable_declaration
//UNSUP	//			// IEEE: var_data_type expanded
//UNSUP		var_data_type list_of_variable_decl_assignments ';'	{ }
//UNSUP	;

type_declaration<nodep>:	// ==IEEE: type_declaration
				// Data_type expanded
		yTYPEDEF data_typeNoRef
	/*cont*/    idAny variable_dimensionListE dtypeAttrListE ';'
			{ AstNodeDType* dtp = $2;
			  $$ = GRAMMARP->createTypedef($<fl>3, *$3, $5, dtp, $4); }
	|	yTYPEDEF packageClassScope idType packed_dimensionListE
	/*cont*/    idAny variable_dimensionListE dtypeAttrListE ';'
			{ AstRefDType* refp = new AstRefDType($<fl>3, *$3, $2, nullptr);
			  AstNodeDType* dtp = GRAMMARP->createArray(refp, $4, true);
			  $$ = GRAMMARP->createTypedef($<fl>5, *$5, $7, dtp, $6); }
	|	yTYPEDEF packageClassScope idType parameter_value_assignmentClass packed_dimensionListE
	/*cont*/    idAny variable_dimensionListE dtypeAttrListE ';'
			{ AstRefDType* refp = new AstRefDType($<fl>3, *$3, $2, $4);
			  AstNodeDType* dtp = GRAMMARP->createArray(refp, $5, true);
			  $$ = GRAMMARP->createTypedef($<fl>6, *$6, $8, dtp, $7); }
	|	yTYPEDEF idType packed_dimensionListE
	/*cont*/    idAny variable_dimensionListE dtypeAttrListE ';'
			{ AstRefDType* refp = new AstRefDType($<fl>2, *$2, nullptr, nullptr);
			  AstNodeDType* dtp = GRAMMARP->createArray(refp, $3, true);
			  $$ = GRAMMARP->createTypedef($<fl>4, *$4, $6, dtp, $5); }
	|	yTYPEDEF idType parameter_value_assignmentClass packed_dimensionListE
	/*cont*/    idAny variable_dimensionListE dtypeAttrListE ';'
			{ AstRefDType* refp = new AstRefDType($<fl>2, *$2, nullptr, $3);
			  AstNodeDType* dtp = GRAMMARP->createArray(refp, $4, true);
			  $$ = GRAMMARP->createTypedef($<fl>5, *$5, $7, dtp, $6); }
	//			//
	|	yTYPEDEF id/*interface*/ '.' idAny/*type*/ idAny/*type*/ ';'
			{ $$ = nullptr; BBUNSUP($1, "Unsupported: SystemVerilog 2005 typedef in this context"); }
	//			// Allow redeclaring same typedef again
	//			// Alternative is use of idAny below, but this will cause conflicts with ablve
	|	yTYPEDEF idType ';'			{ $$ = GRAMMARP->createTypedefFwd($<fl>2, *$2); }
	//			// Combines into above "data_type id" rule
	//			// Verilator: Not important what it is in the AST, just need to make sure the yaID__aTYPE gets returned
	|	yTYPEDEF id ';'				{ $$ = GRAMMARP->createTypedefFwd($<fl>2, *$2); }
	|	yTYPEDEF yENUM idAny ';'		{ $$ = GRAMMARP->createTypedefFwd($<fl>3, *$3); }
	|	yTYPEDEF ySTRUCT idAny ';'		{ $$ = GRAMMARP->createTypedefFwd($<fl>3, *$3); }
	|	yTYPEDEF yUNION idAny ';'		{ $$ = GRAMMARP->createTypedefFwd($<fl>3, *$3); }
	|	yTYPEDEF yCLASS idAny ';'		{ $$ = GRAMMARP->createTypedefFwd($<fl>3, *$3); }
	|	yTYPEDEF yINTERFACE yCLASS idAny ';'	{ $$ = GRAMMARP->createTypedefFwd($<fl>4, *$4); }
	;

dtypeAttrListE<nodep>:
		/* empty */				{ $$ = nullptr; }
	|	dtypeAttrList				{ $$ = $1; }
	;

dtypeAttrList<nodep>:
		dtypeAttr				{ $$ = $1; }
	|	dtypeAttrList dtypeAttr			{ $$ = $1->addNextNull($2); }
	;

dtypeAttr<nodep>:
		yVL_PUBLIC				{ $$ = new AstAttrOf($1,AstAttrType::DT_PUBLIC); }
	;

vlTag:				// verilator tag handling
		yVL_TAG					{ if (PARSEP->tagNodep()) PARSEP->tagNodep()->tag(*$1); }
	;

//************************************************
// Module Items

module_itemListE<nodep>:	// IEEE: Part of module_declaration
		/* empty */				{ $$ = nullptr; }
	|	module_itemList				{ $$ = $1; }
	;

module_itemList<nodep>:		// IEEE: Part of module_declaration
		module_item				{ $$ = $1; }
	|	module_itemList module_item		{ $$ = $1->addNextNull($2); }
	;

module_item<nodep>:		// ==IEEE: module_item
		port_declaration ';'			{ $$ = $1; }
	|	non_port_module_item			{ $$ = $1; }
	;

non_port_module_item<nodep>:	// ==IEEE: non_port_module_item
		generate_region				{ $$ = $1; }
	|	module_or_generate_item 		{ $$ = $1; }
	|	specify_block 				{ $$ = $1; }
	|	specparam_declaration			{ $$ = $1; }
	|	program_declaration			{ $$ = nullptr; BBUNSUP(CRELINE(), "Unsupported: program decls within module decls"); }
	|	module_declaration			{ $$ = nullptr; BBUNSUP(CRELINE(), "Unsupported: module decls within module decls"); }
	|	interface_declaration			{ $$ = nullptr; BBUNSUP(CRELINE(), "Unsupported: interface decls within module decls"); }
	|	timeunits_declaration			{ $$ = $1; }
	//			// Verilator specific
	|	yaSCHDR					{ $$ = new AstScHdr($<fl>1,*$1); }
	|	yaSCINT					{ $$ = new AstScInt($<fl>1,*$1); }
	|	yaSCIMP					{ $$ = new AstScImp($<fl>1,*$1); }
	|	yaSCIMPH				{ $$ = new AstScImpHdr($<fl>1,*$1); }
	|	yaSCCTOR				{ $$ = new AstScCtor($<fl>1,*$1); }
	|	yaSCDTOR				{ $$ = new AstScDtor($<fl>1,*$1); }
	|	yVL_HIER_BLOCK				{ $$ = new AstPragma($1,AstPragmaType::HIER_BLOCK); }
	|	yVL_INLINE_MODULE			{ $$ = new AstPragma($1,AstPragmaType::INLINE_MODULE); }
	|	yVL_NO_INLINE_MODULE			{ $$ = new AstPragma($1,AstPragmaType::NO_INLINE_MODULE); }
	|	yVL_PUBLIC_MODULE			{ $$ = new AstPragma($1,AstPragmaType::PUBLIC_MODULE); v3Global.dpi(true); }
	;

module_or_generate_item<nodep>:	// ==IEEE: module_or_generate_item
	//			// IEEE: parameter_override
		yDEFPARAM list_of_defparam_assignments ';'	{ $$ = $2; }
	//			// IEEE: gate_instantiation + udp_instantiation + module_instantiation
	//			// not here, see etcInst in module_common_item
	//			// We joined udp & module definitions, so this goes here
	|	combinational_body			{ $$ = $1; }
	//			// This module_common_item shared with interface_or_generate_item:module_common_item
	|	module_common_item			{ $$ = $1; }
	;

module_common_item<nodep>:	// ==IEEE: module_common_item
		module_or_generate_item_declaration	{ $$ = $1; }
	//			// IEEE: interface_instantiation
	//			// + IEEE: program_instantiation
	//			// + module_instantiation from module_or_generate_item
	|	etcInst 				{ $$ = $1; }
	|	assertion_item				{ $$ = $1; }
	|	bind_directive				{ $$ = $1; }
	|	continuous_assign			{ $$ = $1; }
	//			// IEEE: net_alias
	|	yALIAS variable_lvalue aliasEqList ';'	{ $$ = nullptr; BBUNSUP($1, "Unsupported: alias statements"); }
	|	initial_construct			{ $$ = $1; }
	|	final_construct				{ $$ = $1; }
	//			// IEEE: always_construct
	//			// Verilator only - event_control attached to always
	|	yALWAYS       stmtBlock			{ $$ = new AstAlways($1,VAlwaysKwd::ALWAYS, nullptr, $2); }
	|	yALWAYS_FF    stmtBlock			{ $$ = new AstAlways($1,VAlwaysKwd::ALWAYS_FF, nullptr, $2); }
	|	yALWAYS_LATCH stmtBlock			{ $$ = new AstAlways($1,VAlwaysKwd::ALWAYS_LATCH, nullptr, $2); }
	|	yALWAYS_COMB  stmtBlock			{ $$ = new AstAlways($1,VAlwaysKwd::ALWAYS_COMB, nullptr, $2); }
	//
	|	loop_generate_construct			{ $$ = $1; }
	|	conditional_generate_construct		{ $$ = $1; }
	|	elaboration_system_task			{ $$ = $1; }
	//
	|	error ';'				{ $$ = nullptr; }
	;

continuous_assign<nodep>:	// IEEE: continuous_assign
		yASSIGN strengthSpecE delayE assignList ';'	{ $$ = $4; }
	;

initial_construct<nodep>:	// IEEE: initial_construct
		yINITIAL stmtBlock			{ $$ = new AstInitial($1,$2); }
	;

final_construct<nodep>:		// IEEE: final_construct
		yFINAL stmtBlock			{ $$ = new AstFinal($1,$2); }
	;

module_or_generate_item_declaration<nodep>:	// ==IEEE: module_or_generate_item_declaration
		package_or_generate_item_declaration	{ $$ = $1; }
	| 	genvar_declaration			{ $$ = $1; }
	|	clocking_declaration			{ $$ = $1; }
	|	yDEFAULT yCLOCKING idAny/*new-clocking_identifier*/ ';'	{ $$ = nullptr; BBUNSUP($1, "Unsupported: default clocking identifier"); }
	//UNSUP	yDEFAULT yDISABLE yIFF expr/*expression_or_dist*/ ';'	{ }
	;

aliasEqList:			// IEEE: part of net_alias
		'=' variable_lvalue			{ }
	|	aliasEqList '=' variable_lvalue		{ }
	;

bind_directive<nodep>:		// ==IEEE: bind_directive + bind_target_scope
	//			// ';' - Note IEEE grammar is wrong, includes extra ';' - it's already in module_instantiation
	//			// We merged the rules - id may be a bind_target_instance or module_identifier or interface_identifier
		yBIND bind_target_instance bind_instantiation	{ $$ = new AstBind($<fl>2, *$2, $3); }
	|	yBIND bind_target_instance ':' bind_target_instance_list bind_instantiation
			{ $$ = nullptr; BBUNSUP($1, "Unsupported: Bind with instance list"); }
	;

bind_target_instance_list:	// ==IEEE: bind_target_instance_list
		bind_target_instance			{ }
	|	bind_target_instance_list ',' bind_target_instance	{ }
	;

bind_target_instance<strp>:	// ==IEEE: bind_target_instance
	//UNSUP	hierarchical_identifierBit		{ }
		idAny					{ $$ = $1; }
	;

bind_instantiation<nodep>:	// ==IEEE: bind_instantiation
	//			// IEEE: program_instantiation
	//			// IEEE: + module_instantiation
	//			// IEEE: + interface_instantiation
	//			// Need to get an AstBind instead of AstCell, so have special rules
		instDecl				{ $$ = $1; }
	;

//************************************************
// Generates
//
// Way down in generate_item is speced a difference between module,
// interface and checker generates.  modules and interfaces are almost
// identical (minus DEFPARAMs) so we overlap them.  Checkers are too
// different, so we copy all rules for checkers.

generate_region<nodep>:		// ==IEEE: generate_region
		yGENERATE ~c~genItemList yENDGENERATE	{ $$ = $2; }
	|	yGENERATE yENDGENERATE			{ $$ = nullptr; }
	;

//UNSUPc_generate_region<nodep>:  // IEEE: generate_region (for checkers)
//UNSUP		BISONPRE_COPY(generate_region,{s/~c~/c_/g})	// {copied}
//UNSUP	;

generate_block_or_null<nodep>:	// IEEE: generate_block_or_null (called from gencase/genif/genfor)
	//	';'		// is included in
	//			// IEEE: generate_block
	//			// Must always return a BEGIN node, or nullptr - see GenFor construction
		generate_item				{ $$ = $1 ? (new AstBegin($1->fileline(),"",$1,true,true)) : nullptr; }
	|	genItemBegin				{ $$ = $1; }
	;

genItemBegin<nodep>:		// IEEE: part of generate_block
		yBEGIN ~c~genItemList yEND		{ $$ = new AstBegin($1,"",$2,true,false); }
	|	yBEGIN yEND				{ $$ = nullptr; }
	|	id yP_COLON__BEGIN yBEGIN ~c~genItemList yEND endLabelE
			{ $$ = new AstBegin($<fl>1,*$1,$4,true,false); GRAMMARP->endLabel($<fl>6,*$1,$6); }
	|	id yP_COLON__BEGIN yBEGIN yEND endLabelE
			{ $$ = nullptr; GRAMMARP->endLabel($<fl>5,*$1,$5); }
	|	yBEGIN ':' idAny ~c~genItemList yEND endLabelE
			{ $$ = new AstBegin($<fl>3,*$3,$4,true,false); GRAMMARP->endLabel($<fl>6,*$3,$6); }
	|	yBEGIN ':' idAny yEND endLabelE		{ $$ = nullptr; GRAMMARP->endLabel($<fl>5,*$3,$5); }
	;

//UNSUPc_genItemBegin<nodep>:  // IEEE: part of generate_block (for checkers)
//UNSUP		BISONPRE_COPY(genItemBegin,{s/~c~/c_/g})		// {copied}
//UNSUP	;

genItemOrBegin<nodep>:		// Not in IEEE, but our begin isn't under generate_item
		~c~generate_item			{ $$ = $1; }
	|	~c~genItemBegin				{ $$ = $1; }
	;

//UNSUPc_genItemOrBegin<nodep>:  // (for checkers)
//UNSUP		BISONPRE_COPY(genItemOrBegin,{s/~c~/c_/g})	// {copied}
//UNSUP	;

genItemList<nodep>:
		~c~genItemOrBegin			{ $$ = $1; }
	|	~c~genItemList ~c~genItemOrBegin	{ $$ = $1->addNextNull($2); }
	;

//UNSUPc_genItemList<nodep>:  // (for checkers)
//UNSUP		BISONPRE_COPY(genItemList,{s/~c~/c_/g})		// {copied}
//UNSUP	;

generate_item<nodep>:		// IEEE: module_or_interface_or_generate_item
	//			// Only legal when in a generate under a module (or interface under a module)
		module_or_generate_item			{ $$ = $1; }
	//			// Only legal when in a generate under an interface
	//UNSUP	interface_or_generate_item		{ $$ = $1; }
	//			// IEEE: checker_or_generate_item
	//			// Only legal when in a generate under a checker
	//			// so below in c_generate_item
	;

//UNSUPc_generate_item<nodep>:  // IEEE: generate_item (for checkers)
//UNSUP		checker_or_generate_item		{ $$ = $1; }
//UNSUP	;

conditional_generate_construct<nodep>:	// ==IEEE: conditional_generate_construct
		yCASE  '(' expr ')' ~c~case_generate_itemListE yENDCASE
			{ $$ = new AstGenCase($1, $3, $5); }
	|	yIF '(' expr ')' ~c~generate_block_or_null	%prec prLOWER_THAN_ELSE
			{ $$ = new AstGenIf($1, $3, $5, nullptr); }
	|	yIF '(' expr ')' ~c~generate_block_or_null yELSE ~c~generate_block_or_null
			{ $$ = new AstGenIf($1, $3, $5, $7); }
	;

//UNSUPc_conditional_generate_construct<nodep>:  // IEEE: conditional_generate_construct (for checkers)
//UNSUP		BISONPRE_COPY(conditional_generate_construct,{s/~c~/c_/g})	// {copied}
//UNSUP	;

loop_generate_construct<nodep>:	// ==IEEE: loop_generate_construct
		yFOR '(' genvar_initialization ';' expr ';' genvar_iteration ')' ~c~generate_block_or_null
			{ // Convert BEGIN(...) to BEGIN(GENFOR(...)), as we need the BEGIN to hide the local genvar
			  AstBegin* lowerBegp = VN_CAST($9, Begin);
			  UASSERT_OBJ(!($9 && !lowerBegp), $9, "Child of GENFOR should have been begin");
			  if (!lowerBegp) lowerBegp = new AstBegin($1, "genblk", nullptr, true, true);  // Empty body
			  AstNode* lowerNoBegp = lowerBegp->stmtsp();
			  if (lowerNoBegp) lowerNoBegp->unlinkFrBackWithNext();
			  //
			  AstBegin* blkp = new AstBegin($1, lowerBegp->name(), nullptr, true, true);
			  // V3LinkDot detects BEGIN(GENFOR(...)) as a special case
			  AstNode* initp = $3;  AstNode* varp = $3;
			  if (VN_IS(varp, Var)) {  // Genvar
				initp = varp->nextp();
				initp->unlinkFrBackWithNext();  // Detach 2nd from varp, make 1st init
				blkp->addStmtsp(varp);
			  }
			  // Statements are under 'genforp' as cells under this
			  // for loop won't get an extra layer of hierarchy tacked on
			  blkp->addGenforp(new AstGenFor($1,initp,$5,$7,lowerNoBegp));
			  $$ = blkp;
			  VL_DO_DANGLING(lowerBegp->deleteTree(), lowerBegp);
			}
	;

//UNSUPc_loop_generate_construct<nodep>:  // IEEE: loop_generate_construct (for checkers)
//UNSUP		BISONPRE_COPY(loop_generate_construct,{s/~c~/c_/g})	// {copied}
//UNSUP	;

genvar_initialization<nodep>:	// ==IEEE: genvar_initialization
		varRefBase '=' expr			{ $$ = new AstAssign($2,$1,$3); }
	|	yGENVAR genvar_identifierDecl '=' constExpr
			{ $$ = $2; $2->addNext(new AstAssign($3, new AstVarRef($2->fileline(), $2, VAccess::WRITE), $4)); }
	;

genvar_iteration<nodep>:	// ==IEEE: genvar_iteration
		varRefBase '=' 		expr		{ $$ = new AstAssign($2,$1,$3); }
	|	varRefBase yP_PLUSEQ	expr		{ $$ = new AstAssign($2,$1,new AstAdd    ($2,$1->cloneTree(true),$3)); }
	|	varRefBase yP_MINUSEQ	expr		{ $$ = new AstAssign($2,$1,new AstSub    ($2,$1->cloneTree(true),$3)); }
	|	varRefBase yP_TIMESEQ	expr		{ $$ = new AstAssign($2,$1,new AstMul    ($2,$1->cloneTree(true),$3)); }
	|	varRefBase yP_DIVEQ	expr		{ $$ = new AstAssign($2,$1,new AstDiv    ($2,$1->cloneTree(true),$3)); }
	|	varRefBase yP_MODEQ	expr		{ $$ = new AstAssign($2,$1,new AstModDiv ($2,$1->cloneTree(true),$3)); }
	|	varRefBase yP_ANDEQ	expr		{ $$ = new AstAssign($2,$1,new AstAnd    ($2,$1->cloneTree(true),$3)); }
	|	varRefBase yP_OREQ	expr		{ $$ = new AstAssign($2,$1,new AstOr     ($2,$1->cloneTree(true),$3)); }
	|	varRefBase yP_XOREQ	expr		{ $$ = new AstAssign($2,$1,new AstXor    ($2,$1->cloneTree(true),$3)); }
	|	varRefBase yP_SLEFTEQ	expr		{ $$ = new AstAssign($2,$1,new AstShiftL ($2,$1->cloneTree(true),$3)); }
	|	varRefBase yP_SRIGHTEQ	expr		{ $$ = new AstAssign($2,$1,new AstShiftR ($2,$1->cloneTree(true),$3)); }
	|	varRefBase yP_SSRIGHTEQ	expr		{ $$ = new AstAssign($2,$1,new AstShiftRS($2,$1->cloneTree(true),$3)); }
	//			// inc_or_dec_operator
	// When support ++ as a real AST type, maybe AstWhile::precondsp() becomes generic AstNodeMathStmt?
	|	yP_PLUSPLUS   varRefBase		{ $$ = new AstAssign($1,$2,new AstAdd    ($1,$2->cloneTree(true), new AstConst($1, AstConst::StringToParse(), "'b1"))); }
	|	yP_MINUSMINUS varRefBase		{ $$ = new AstAssign($1,$2,new AstSub    ($1,$2->cloneTree(true), new AstConst($1, AstConst::StringToParse(), "'b1"))); }
	|	varRefBase yP_PLUSPLUS			{ $$ = new AstAssign($2,$1,new AstAdd    ($2,$1->cloneTree(true), new AstConst($2, AstConst::StringToParse(), "'b1"))); }
	|	varRefBase yP_MINUSMINUS		{ $$ = new AstAssign($2,$1,new AstSub    ($2,$1->cloneTree(true), new AstConst($2, AstConst::StringToParse(), "'b1"))); }
	;

case_generate_itemListE<nodep>:	// IEEE: [{ case_generate_itemList }]
		/* empty */				{ $$ = nullptr; }
	|	case_generate_itemList			{ $$ = $1; }
	;

case_generate_itemList<nodep>:	// IEEE: { case_generate_itemList }
		~c~case_generate_item			{ $$=$1; }
	|	~c~case_generate_itemList ~c~case_generate_item	{ $$=$1; $1->addNext($2); }
	;

//UNSUPc_case_generate_itemList<nodep>:  // IEEE: { case_generate_item } (for checkers)
//UNSUP		BISONPRE_COPY(case_generate_itemList,{s/~c~/c_/g})	// {copied}
//UNSUP	;

case_generate_item<nodep>:	// ==IEEE: case_generate_item
		caseCondList colon generate_block_or_null		{ $$ = new AstCaseItem($2,$1,$3); }
	|	yDEFAULT colon generate_block_or_null		{ $$ = new AstCaseItem($1,nullptr,$3); }
	|	yDEFAULT generate_block_or_null			{ $$ = new AstCaseItem($1,nullptr,$2); }
	;

//UNSUPc_case_generate_item<nodep>:  // IEEE: case_generate_item (for checkers)
//UNSUP		BISONPRE_COPY(case_generate_item,{s/~c~/c_/g})	// {copied}
//UNSUP	;

//************************************************
// Assignments and register declarations

assignList<nodep>:
		assignOne				{ $$ = $1; }
	|	assignList ',' assignOne		{ $$ = $1->addNext($3); }
	;

assignOne<nodep>:
		variable_lvalue '=' expr		{ $$ = new AstAssignW($2,$1,$3); }
	;

//UNSUPdelay_or_event_controlE<nodep>:  // IEEE: delay_or_event_control plus empty
//UNSUP		/* empty */				{ $$ = nullptr; }
//UNSUP	|	delay_control				{ $$ = $1; }
//UNSUP	|	event_control				{ $$ = $1; }
//UNSUP	|	yREPEAT '(' expr ')' event_control	{ }
//UNSUP	;

delayE:
		/* empty */				{ }
	|	delay					{ }
	;

delay:
		delay_control
			{ $1->v3warn(ASSIGNDLY, "Unsupported: Ignoring delay on this assignment/primitive.");
			  DEL($1); }
	;

delay_control<nodep>:	//== IEEE: delay_control
		'#' delay_value				{ $$ = $2; }
	|	'#' '(' minTypMax ')'			{ $$ = $3; }
	|	'#' '(' minTypMax ',' minTypMax ')'			{ $$ = $3; DEL($5); }
	|	'#' '(' minTypMax ',' minTypMax ',' minTypMax ')'	{ $$ = $3; DEL($5); DEL($7); }
	;

delay_value<nodep>:		// ==IEEE:delay_value
	//			// IEEE: ps_identifier
		packageClassScopeE varRefBase		{ $$ = AstDot::newIfPkg($<fl>2, $1, $2); }
	|	yaINTNUM 				{ $$ = new AstConst($<fl>1, *$1); }
	|	yaFLOATNUM 				{ $$ = new AstConst($<fl>1, AstConst::RealDouble(), $1); }
	|	timeNumAdjusted				{ $$ = $1; }
	;

delayExpr<nodep>:
		expr					{ $$ = $1; }
	;

minTypMax<nodep>:		// IEEE: mintypmax_expression and constant_mintypmax_expression
		delayExpr				{ $$ = $1; }
	|	delayExpr ':' delayExpr ':' delayExpr	{ $$ = $3; DEL($1); DEL($5); }
	;

netSigList<varp>:		// IEEE: list_of_port_identifiers
		netSig  				{ $$ = $1; }
	|	netSigList ',' netSig		       	{ $$ = $1; $1->addNext($3); }
	;

netSig<varp>:			// IEEE: net_decl_assignment -  one element from list_of_port_identifiers
		netId sigAttrListE			{ $$ = VARDONEA($<fl>1,*$1, nullptr, $2); }
	|	netId sigAttrListE '=' expr		{ $$ = VARDONEA($<fl>1,*$1, nullptr, $2);
							  $$->addNext(new AstAssignW($3, new AstVarRef($<fl>1, *$1, VAccess::WRITE), $4)); }
	|	netId variable_dimensionList sigAttrListE	{ $$ = VARDONEA($<fl>1,*$1, $2, $3); }
	;

netId<strp>:
		id/*new-net*/				{ $$ = $1; $<fl>$=$<fl>1; }
	|	idSVKwd					{ $$ = $1; $<fl>$=$<fl>1; }
	;

sigAttrListE<nodep>:
		/* empty */				{ $$ = nullptr; }
	|	sigAttrList				{ $$ = $1; }
	;

sigAttrList<nodep>:
		sigAttr					{ $$ = $1; }
	|	sigAttrList sigAttr			{ $$ = $1->addNextNull($2); }
	;

sigAttr<nodep>:
		yVL_CLOCKER				{ $$ = new AstAttrOf($1,AstAttrType::VAR_CLOCKER); }
	|	yVL_NO_CLOCKER				{ $$ = new AstAttrOf($1,AstAttrType::VAR_NO_CLOCKER); }
	|	yVL_CLOCK_ENABLE			{ $$ = new AstAttrOf($1,AstAttrType::VAR_CLOCK_ENABLE); }
	|	yVL_PUBLIC				{ $$ = new AstAttrOf($1,AstAttrType::VAR_PUBLIC); v3Global.dpi(true); }
	|	yVL_PUBLIC_FLAT				{ $$ = new AstAttrOf($1,AstAttrType::VAR_PUBLIC_FLAT); v3Global.dpi(true); }
	|	yVL_PUBLIC_FLAT_RD			{ $$ = new AstAttrOf($1,AstAttrType::VAR_PUBLIC_FLAT_RD); v3Global.dpi(true); }
	|	yVL_PUBLIC_FLAT_RW			{ $$ = new AstAttrOf($1,AstAttrType::VAR_PUBLIC_FLAT_RW); v3Global.dpi(true); }
	|	yVL_PUBLIC_FLAT_RW attr_event_control	{ $$ = new AstAttrOf($1,AstAttrType::VAR_PUBLIC_FLAT_RW); v3Global.dpi(true);
							  $$ = $$->addNext(new AstAlwaysPublic($1,$2,nullptr)); }
	|	yVL_ISOLATE_ASSIGNMENTS			{ $$ = new AstAttrOf($1,AstAttrType::VAR_ISOLATE_ASSIGNMENTS); }
	|	yVL_SC_BV				{ $$ = new AstAttrOf($1,AstAttrType::VAR_SC_BV); }
	|	yVL_SFORMAT				{ $$ = new AstAttrOf($1,AstAttrType::VAR_SFORMAT); }
	|	yVL_SPLIT_VAR				{ $$ = new AstAttrOf($1,AstAttrType::VAR_SPLIT_VAR); }
	;

rangeListE<rangep>:		// IEEE: [{packed_dimension}]
		/* empty */    		               	{ $$ = nullptr; }
	|	rangeList 				{ $$ = $1; }
	;

rangeList<rangep>:		// IEEE: {packed_dimension}
		anyrange				{ $$ = $1; }
        |	rangeList anyrange			{ $$ = $1; $1->addNext($2); }
	;

//UNSUPbit_selectE<fl>:  // IEEE: constant_bit_select (IEEE included empty)
//UNSUP		/* empty */				{ $$ = nullptr; }
//UNSUP	|	'[' constExpr ']'			{ $<fl>$=$<fl>1; $$ = "["+$2+"]"; }
//UNSUP	;

// IEEE: select
// Merged into more general idArray

anyrange<rangep>:
		'[' constExpr ':' constExpr ']'		{ $$ = new AstRange($1,$2,$4); }
	;

packed_dimensionListE<rangep>:	// IEEE: [{ packed_dimension }]
		/* empty */				{ $$ = nullptr; }
	|	packed_dimensionList			{ $$ = $1; }
	;

packed_dimensionList<rangep>:	// IEEE: { packed_dimension }
		packed_dimension			{ $$ = $1; }
	|	packed_dimensionList packed_dimension	{ $$ = VN_CAST($1->addNext($2), NodeRange); }
	;

packed_dimension<rangep>:	// ==IEEE: packed_dimension
		anyrange				{ $$ = $1; }
	|	'[' ']'					{ $$ = nullptr; BBUNSUP($<fl>1, "Unsupported: [] dimensions"); }
	;

//************************************************
// Parameters

param_assignment<varp>:		// ==IEEE: param_assignment
	//			// IEEE: constant_param_expression
	//			// constant_param_expression: '$' is in expr
		id/*new-parameter*/ variable_dimensionListE sigAttrListE exprOrDataTypeEqE
			{ // To handle  #(type A=int, B=A) and properly imply B
                          // as a type (for parsing) we need to detect "A" is a type
			  if (AstNodeDType* refp = VN_CAST($4, NodeDType)) {
			    if (VSymEnt* foundp = SYMP->symCurrentp()->findIdFallback(refp->name())) {
				UINFO(9, "declaring type via param assignment" << foundp->nodep() << endl);
				VARDTYPE(new AstParseTypeDType($<fl>1))
				SYMP->reinsert(foundp->nodep()->cloneTree(false), nullptr, *$1); }}
			  $$ = VARDONEA($<fl>1, *$1, $2, $3); if ($4) $$->valuep($4); }
	;

list_of_param_assignments<varp>:	// ==IEEE: list_of_param_assignments
		param_assignment			{ $$ = $1; }
	|	list_of_param_assignments ',' param_assignment	{ $$ = $1; $1->addNext($3); }
	;

type_assignment<varp>:		// ==IEEE: type_assignment
	//			// note exptOrDataType being a data_type is only for yPARAMETER yTYPE
		idAny/*new-parameter*/ sigAttrListE '=' data_type
			{ $$ = VARDONEA($<fl>1, *$1, nullptr, $2); $$->valuep($4); }
	;

list_of_type_assignments<varp>:		// ==IEEE: list_of_type_assignments
		type_assignment				{ $$ = $1; }
	|	list_of_type_assignments ',' type_assignment	{ $$ = $1; $1->addNext($3); }
	;

list_of_defparam_assignments<nodep>:	//== IEEE: list_of_defparam_assignments
		defparam_assignment			{ $$ = $1; }
	|	list_of_defparam_assignments ',' defparam_assignment	{ $$ = $1->addNext($3); }
	;

defparam_assignment<nodep>:	// ==IEEE: defparam_assignment
		idAny '.' idAny '=' expr 		{ $$ = new AstDefParam($4, *$1, *$3, $5); }
	|	idAny '.' idAny '.'
	 		{ $$ = nullptr;
			  BBUNSUP($4, "Unsupported: defparam with more than one dot"); }
	;

//************************************************
// Instances
// We don't know identifier types, so this matches all module,udp,etc instantiation
//   module_id      [#(params)]   name  (pins) [, name ...] ;	// module_instantiation
//   gate (strong0) [#(delay)]   [name] (pins) [, (pins)...] ;	// gate_instantiation
//   program_id     [#(params}]   name ;			// program_instantiation
//   interface_id   [#(params}]   name ;			// interface_instantiation
//   checker_id			  name  (pins) ;		// checker_instantiation

etcInst<nodep>:			// IEEE: module_instantiation + gate_instantiation + udp_instantiation
		instDecl				{ $$ = $1; }
	|	gateDecl 				{ $$ = $1; }
	;

instDecl<nodep>:
	//      		// Currently disambiguated from data_declaration based on
	//			// VARs being type, and cells non-type.
	//			// IEEE requires a '(' to disambiguate, we need TODO force this
		id parameter_value_assignmentE {INSTPREP($<fl>1,*$1,$2);} instnameList ';'
			{ $$ = $4; GRAMMARP->m_impliedDecl=false;
			  if (GRAMMARP->m_instParamp) {
			      VL_DO_CLEAR(GRAMMARP->m_instParamp->deleteTree(),
					  GRAMMARP->m_instParamp = nullptr);
			  } }
	//			// IEEE: interface_identifier' .' modport_identifier list_of_interface_identifiers
	|	id/*interface*/ '.' id/*modport*/
	/*mid*/		{ VARRESET_NONLIST(AstVarType::IFACEREF);
			  VARDTYPE(new AstIfaceRefDType($<fl>1, $<fl>3, "", *$1, *$3)); }
	/*cont*/    mpInstnameList ';'
			{ $$ = VARDONEP($5,nullptr,nullptr); }
	//UNSUP: strengthSpecE for udp_instantiations
	;

mpInstnameList<nodep>:		// Similar to instnameList, but for modport instantiations which have no parenthesis
		mpInstnameParen				{ $$ = $1; }
	|	mpInstnameList ',' mpInstnameParen	{ $$ = $1->addNext($3); }
	;

mpInstnameParen<nodep>:		// Similar to instnameParen, but for modport instantiations which have no parenthesis
		id instRangeListE sigAttrListE		{ $$ = VARDONEA($<fl>1,*$1,$2,$3); }
	;

instnameList<nodep>:
		instnameParen				{ $$ = $1; }
	|	instnameList ',' instnameParen		{ $$ = $1->addNext($3); }
	;

instnameParen<cellp>:
	//			// Must clone m_instParamp as may be comma'ed list of instances
		id instRangeListE '(' cellpinList ')'	{ $$ = new AstCell($<fl>1, GRAMMARP->m_instModuleFl,
									   *$1, GRAMMARP->m_instModule, $4,
									   AstPin::cloneTreeNull(GRAMMARP->m_instParamp, true),
                                                                           GRAMMARP->scrubRange($2));
						          $$->trace(GRAMMARP->allTracingOn($<fl>1)); }
	|	id instRangeListE 			{ $$ = new AstCell($<fl>1, GRAMMARP->m_instModuleFl,
									   *$1, GRAMMARP->m_instModule, nullptr,
									   AstPin::cloneTreeNull(GRAMMARP->m_instParamp, true),
                                                                           GRAMMARP->scrubRange($2));
						          $$->trace(GRAMMARP->allTracingOn($<fl>1)); }
	//UNSUP	instRangeListE '(' cellpinList ')'	{ UNSUP } // UDP
	//			// Adding above and switching to the Verilog-Perl syntax
	//			// causes a shift conflict due to use of idClassSel inside exprScope.
	//			// It also breaks allowing "id foo;" instantiation syntax.
	;

instRangeListE<rangep>:
		/* empty */				{ $$ = nullptr; }
	|	instRangeList				{ $$ = $1; }
	;

instRangeList<rangep>:
		instRange				{ $$ = $1; }
	|	instRangeList instRange			{ $$ = VN_CAST($1->addNextNull($2), Range); }
	;

instRange<rangep>:
		'[' constExpr ']'			{ $$ = new AstRange($1, new AstConst($1, 0), new AstSub($1, $2, new AstConst($1, 1))); }
	|	'[' constExpr ':' constExpr ']'		{ $$ = new AstRange($1,$2,$4); }
	;

cellparamList<pinp>:
		{ GRAMMARP->pinPush(); } cellparamItList	{ $$ = $2; GRAMMARP->pinPop(CRELINE()); }
	;

cellpinList<pinp>:
		{VARRESET_LIST(UNKNOWN);} cellpinItList	{ $$ = $2; VARRESET_NONLIST(UNKNOWN); }
	;

cellparamItList<pinp>:		// IEEE: list_of_parameter_assignmente
		cellparamItemE				{ $$ = $1; }
	|	cellparamItList ',' cellparamItemE	{ $$ = VN_CAST($1->addNextNull($3), Pin); }
	;

cellpinItList<pinp>:		// IEEE: list_of_port_connections
		cellpinItemE				{ $$ = $1; }
	|	cellpinItList ',' cellpinItemE		{ $$ = VN_CAST($1->addNextNull($3), Pin); }
	;

cellparamItemE<pinp>:		// IEEE: named_parameter_assignment + empty
	//			// Note empty can match either () or (,); V3LinkCells cleans up ()
		/* empty: ',,' is legal */		{ $$ = new AstPin(CRELINE(), PINNUMINC(), "", nullptr); }
	|	yP_DOTSTAR				{ $$ = new AstPin($1,PINNUMINC(),".*",nullptr); }
	|	'.' idSVKwd				{ $$ = new AstPin($<fl>2,PINNUMINC(), *$2,
									  new AstParseRef($<fl>2,VParseRefExp::PX_TEXT,*$2,nullptr,nullptr));
									  $$->svImplicit(true);}
	|	'.' idAny				{ $$ = new AstPin($<fl>2,PINNUMINC(), *$2,
									  new AstParseRef($<fl>2,VParseRefExp::PX_TEXT,*$2,nullptr,nullptr));
									  $$->svImplicit(true);}
	|	'.' idAny '(' ')'			{ $$ = new AstPin($<fl>2,PINNUMINC(),*$2,nullptr); }
	//			// mintypmax is expanded here, as it might be a UDP or gate primitive
	//			// data_type for 'parameter type' hookups
	|	'.' idAny '(' exprOrDataType ')'	{ $$ = new AstPin($<fl>2, PINNUMINC(), *$2, $4); }
	//UNSUP	'.' idAny '(' exprOrDataType/*expr*/ ':' expr ')'		{ }
	//UNSUP	'.' idAny '(' exprOrDataType/*expr*/ ':' expr ':' expr ')'	{ }
	//			// data_type for 'parameter type' hookups
	|	exprOrDataType				{ $$ = new AstPin(FILELINE_OR_CRE($1), PINNUMINC(), "", $1); }
	//UNSUP	exprOrDataType/*expr*/ ':' expr		{ }
	//UNSUP	exprOrDataType/*expr*/ ':' expr ':' expr	{ }
	;

cellpinItemE<pinp>:		// IEEE: named_port_connection + empty
	//			// Note empty can match either () or (,); V3LinkCells cleans up ()
		/* empty: ',,' is legal */		{ $$ = new AstPin(CRELINE(), PINNUMINC(), "", nullptr); }
	|	yP_DOTSTAR				{ $$ = new AstPin($1,PINNUMINC(),".*",nullptr); }
	|	'.' idSVKwd				{ $$ = new AstPin($<fl>2,PINNUMINC(),*$2,new AstParseRef($<fl>2,VParseRefExp::PX_TEXT,*$2,nullptr,nullptr)); $$->svImplicit(true);}
	|	'.' idAny				{ $$ = new AstPin($<fl>2,PINNUMINC(),*$2,new AstParseRef($<fl>2,VParseRefExp::PX_TEXT,*$2,nullptr,nullptr)); $$->svImplicit(true);}
	|	'.' idAny '(' ')'			{ $$ = new AstPin($<fl>2,PINNUMINC(),*$2,nullptr); }
	//			// mintypmax is expanded here, as it might be a UDP or gate primitive
	//UNSUP               pev_expr below
	|	'.' idAny '(' expr ')'			{ $$ = new AstPin($<fl>2,PINNUMINC(),*$2,$4); }
	//UNSUP	'.' idAny '(' pev_expr ':' expr ')'	{ }
	//UNSUP	'.' idAny '(' pev_expr ':' expr ':' expr ')' { }
	//
	|	expr					{ $$ = new AstPin(FILELINE_OR_CRE($1),PINNUMINC(),"",$1); }
	//UNSUP	expr ':' expr				{ }
	//UNSUP	expr ':' expr ':' expr			{ }
	;

//************************************************
// EventControl lists

attr_event_controlE<sentreep>:
		/* empty */					{ $$ = nullptr; }
	|	attr_event_control			{ $$ = $1; }
	;

attr_event_control<sentreep>:	// ==IEEE: event_control
		'@' '(' event_expression ')'		{ $$ = new AstSenTree($1,$3); }
	|	'@' '(' '*' ')'				{ $$ = nullptr; }
	|	'@' '*'					{ $$ = nullptr; }
	;

event_control<sentreep>:	// ==IEEE: event_control
		'@' '(' event_expression ')'		{ $$ = new AstSenTree($1,$3); }
	|	'@' '(' '*' ')'				{ $$ = nullptr; }
	|	'@' '*'					{ $$ = nullptr; }
	//			// IEEE: hierarchical_event_identifier
	//			// UNSUP below should be idClassSel
	|	'@' senitemVar				{ $$ = new AstSenTree($1,$2); }	/* For events only */
	//			// IEEE: sequence_instance
	//			// sequence_instance without parens matches idClassSel above.
	//			// Ambiguity: "'@' sequence (-for-sequence" versus expr:delay_or_event_controlE "'@' id (-for-expr
	//			// For now we avoid this, as it's very unlikely someone would mix
	//			// 1995 delay with a sequence with parameters.
	//			// Alternatively split this out of event_control, and delay_or_event_controlE
	//			// and anywhere delay_or_event_controlE is called allow two expressions
	//UNSUP	'@' idClassSel '(' list_of_argumentsE ')'	{ }
	;

event_expression<senitemp>:	// IEEE: event_expression - split over several
	//UNSUP			// Below are all removed
		senitem					{ $$ = $1; }
	|	event_expression yOR senitem		{ $$ = VN_CAST($1->addNextNull($3), SenItem); }
	|	event_expression ',' senitem		{ $$ = VN_CAST($1->addNextNull($3), SenItem); }	/* Verilog 2001 */
	//UNSUP			// Above are all removed, replace with:
	//UNSUP	ev_expr					{ $$ = $1; }
	//UNSUP	event_expression ',' ev_expr %prec yOR	{ $$ = VN_CAST($1->addNextNull($3), SenItem); }
	;

senitem<senitemp>:		// IEEE: part of event_expression, non-'OR' ',' terms
		senitemEdge				{ $$ = $1; }
	|	senitemVar				{ $$ = $1; }
	|	'(' senitem ')'				{ $$ = $2; }
	//UNSUP	expr					{ UNSUP }
	|	'{' event_expression '}'		{ $$ = $2; }
	|	senitem yP_ANDAND senitem		{ $$ = new AstSenItem($2, AstSenItem::Illegal()); }
	//UNSUP	expr yIFF expr				{ UNSUP }
	// Since expr is unsupported we allow and ignore constants (removed in V3Const)
	|	yaINTNUM				{ $$ = nullptr; }
	|	yaFLOATNUM				{ $$ = nullptr; }
	;

senitemVar<senitemp>:
		idClassSel				{ $$ = new AstSenItem($1->fileline(), VEdgeType::ET_ANYEDGE, $1); }
	;

senitemEdge<senitemp>:		// IEEE: part of event_expression
	//UNSUP			// Below are all removed
		yPOSEDGE idClassSel			{ $$ = new AstSenItem($1, VEdgeType::ET_POSEDGE, $2); }
	|	yNEGEDGE idClassSel			{ $$ = new AstSenItem($1, VEdgeType::ET_NEGEDGE, $2); }
	|	yEDGE idClassSel			{ $$ = new AstSenItem($1, VEdgeType::ET_BOTHEDGE, $2); }
	|	yPOSEDGE '(' idClassSel ')'		{ $$ = new AstSenItem($1, VEdgeType::ET_POSEDGE, $3); }
	|	yNEGEDGE '(' idClassSel ')'		{ $$ = new AstSenItem($1, VEdgeType::ET_NEGEDGE, $3); }
	|	yEDGE '(' idClassSel ')'		{ $$ = new AstSenItem($1, VEdgeType::ET_BOTHEDGE, $3); }
	//UNSUP			// Above are all removed, replace with:
	//UNSUP	yPOSEDGE expr				{ UNSUP }
	//UNSUP	yPOSEDGE expr yIFF expr			{ UNSUP }
	//UNSUP	yNEGEDGE expr				{ UNSUP }
	//UNSUP	yNEGEDGE expr yIFF expr			{ UNSUP }
	//UNSUP	yEDGE expr				{ UNSUP }
	//UNSUP	yEDGE expr yIFF expr			{ UNSUP }
	;

//************************************************
// Statements

stmtBlock<nodep>:		// IEEE: statement + seq_block + par_block
		stmt					{ $$ = $1; }
	;

seq_block<nodep>:		// ==IEEE: seq_block
	//			// IEEE doesn't allow declarations in unnamed blocks, but several simulators do.
	//			// So need AstBegin's even if unnamed to scope variables down
		seq_blockFront blockDeclStmtListE yEND endLabelE
			{ $$ = $1; $1->addStmtsp($2);
			  SYMP->popScope($1); GRAMMARP->endLabel($<fl>4, $1, $4); }
	;

seq_blockPreId<nodep>:		// IEEE: seq_block, but called with leading ID
		seq_blockFrontPreId blockDeclStmtListE yEND endLabelE
        		{ $$ = $1; $1->addStmtsp($2);
			  SYMP->popScope($1); GRAMMARP->endLabel($<fl>4, $1, $4); }
	;

par_block<nodep>:		// ==IEEE: par_block
		par_blockFront blockDeclStmtListE yJOIN endLabelE
			{ $$ = $1; $1->addStmtsp($2);
			  $1->joinType(VJoinType::JOIN);
			  SYMP->popScope($1); GRAMMARP->endLabel($<fl>4, $1, $4); }
	|	par_blockFront blockDeclStmtListE yJOIN_ANY endLabelE
			{ $$ = $1; $1->addStmtsp($2);
			  $1->joinType(VJoinType::JOIN_ANY);
			  SYMP->popScope($1); GRAMMARP->endLabel($<fl>4, $1, $4); }
	|	par_blockFront blockDeclStmtListE yJOIN_NONE endLabelE
			{ $$ = $1; $1->addStmtsp($2);
			  $1->joinType(VJoinType::JOIN_NONE);
			  SYMP->popScope($1); GRAMMARP->endLabel($<fl>4, $1, $4); }
	;

par_blockPreId<nodep>:		// ==IEEE: par_block but called with leading ID
		par_blockFrontPreId blockDeclStmtListE yJOIN endLabelE
			{ $$ = $1; $1->addStmtsp($2);
			  $1->joinType(VJoinType::JOIN);
			  SYMP->popScope($1); GRAMMARP->endLabel($<fl>4, $1, $4); }
	|	par_blockFrontPreId blockDeclStmtListE yJOIN_ANY endLabelE
			{ $$ = $1; $1->addStmtsp($2);
			  $1->joinType(VJoinType::JOIN_ANY);
			  SYMP->popScope($1); GRAMMARP->endLabel($<fl>4, $1, $4); }
	|	par_blockFrontPreId blockDeclStmtListE yJOIN_NONE endLabelE
			{ $$ = $1; $1->addStmtsp($2);
			  $1->joinType(VJoinType::JOIN_NONE);
			  SYMP->popScope($1); GRAMMARP->endLabel($<fl>4, $1, $4); }
	;

seq_blockFront<beginp>:		// IEEE: part of seq_block
		yBEGIN					 { $$ = new AstBegin($1,"",nullptr);  SYMP->pushNew($$); }
	|	yBEGIN ':' idAny/*new-block_identifier*/ { $$ = new AstBegin($<fl>3, *$3, nullptr); SYMP->pushNew($$); }
	;

par_blockFront<forkp>:		// IEEE: part of par_block
		yFORK					{ $$ = new AstFork($1, "", nullptr);  SYMP->pushNew($$); }
	|	yFORK ':' idAny/*new-block_identifier*/	{ $$ = new AstFork($<fl>3, *$3, nullptr); SYMP->pushNew($$); }
	;

seq_blockFrontPreId<beginp>:	// IEEE: part of seq_block/stmt with leading id
		id/*block_identifier*/ yP_COLON__BEGIN yBEGIN
	 		{ $$ = new AstBegin($3, *$1, nullptr); SYMP->pushNew($$); }
	;

par_blockFrontPreId<forkp>:	// IEEE: part of par_block/stmt with leading id
		id/*block_identifier*/ yP_COLON__FORK yFORK
	 		{ $$ = new AstFork($3, *$1, nullptr); SYMP->pushNew($$); }
	;


blockDeclStmtList<nodep>:	// IEEE: { block_item_declaration } { statement or null }
	//			// The spec seems to suggest a empty declaration isn't ok, but most simulators take it
		block_item_declarationList		{ $$ = $1; }
	|	block_item_declarationList stmtList	{ $$ = $1->addNextNull($2); }
	|	stmtList				{ $$ = $1; }
	;

blockDeclStmtListE<nodep>:	// IEEE: [ { block_item_declaration } { statement or null } ]
		/*empty*/				{ $$ = nullptr; }
	|	blockDeclStmtList			{ $$ = $1; }
	;

block_item_declarationList<nodep>:	// IEEE: [ block_item_declaration ]
		block_item_declaration			{ $$ = $1; }
	|	block_item_declarationList block_item_declaration	{ $$ = $1->addNextNull($2); }
	;

block_item_declaration<nodep>:	// ==IEEE: block_item_declaration
		data_declaration 			{ $$ = $1; }
	|	parameter_declaration ';' 		{ $$ = $1; }
	//UNSUP	let_declaration 			{ $$ = $1; }
	;

stmtList<nodep>:
		stmtBlock				{ $$ = $1; }
	|	stmtList stmtBlock			{ $$ = ($2==nullptr)?($1):($1->addNext($2)); }
	;

stmt<nodep>:			// IEEE: statement_or_null == function_statement_or_null
		statement_item				{ $$ = $1; }
	//			// S05 block creation rule
	|	id/*block_identifier*/ ':' statement_item	{ $$ = new AstBegin($<fl>1, *$1, $3); }
	//			// from _or_null
	|	';'					{ $$ = nullptr; }
	//			// labeled par_block/seq_block with leading ':'
	|	seq_blockPreId				{ $$ = $1; }
	|	par_blockPreId				{ $$ = $1; }
	;

statement_item<nodep>:		// IEEE: statement_item
	//			// IEEE: operator_assignment
		foperator_assignment ';'		{ $$ = $1; }
	//
	//		 	// IEEE: blocking_assignment
	//			// 1800-2009 restricts LHS of assignment to new to not have a range
	//			// This is ignored to avoid conflicts
	|	fexprLvalue '=' class_new ';'		{ $$ = new AstAssign($2, $1, $3); }
	|	fexprLvalue '=' dynamic_array_new ';'	{ $$ = new AstAssign($2, $1, $3); }
	//
	//			// IEEE: nonblocking_assignment
	|	fexprLvalue yP_LTE delayE expr ';'	{ $$ = new AstAssignDly($2,$1,$4); }
	//UNSUP	fexprLvalue yP_LTE delay_or_event_controlE expr ';'	{ UNSUP }
	//
	//			// IEEE: procedural_continuous_assignment
	|	yASSIGN idClassSel '=' delayE expr ';'	{ $$ = new AstAssign($1,$2,$5); }
	//UNSUP:			delay_or_event_controlE above
	|	yDEASSIGN variable_lvalue ';'		{ $$ = nullptr; BBUNSUP($1, "Unsupported: Verilog 1995 deassign"); }
	|	yFORCE expr '=' expr ';'		{ $$ = nullptr; BBUNSUP($1, "Unsupported: Verilog 1995 force"); }
	|	yRELEASE variable_lvalue ';'		{ $$ = nullptr; BBUNSUP($1, "Unsupported: Verilog 1995 release"); }
	//
	//			// IEEE: case_statement
	|	unique_priorityE caseStart caseAttrE case_itemListE yENDCASE	{ $$ = $2; if ($4) $2->addItemsp($4);
							  if ($1 == uniq_UNIQUE) $2->uniquePragma(true);
							  if ($1 == uniq_UNIQUE0) $2->unique0Pragma(true);
							  if ($1 == uniq_PRIORITY) $2->priorityPragma(true); }
	//UNSUP	caseStart caseAttrE yMATCHES case_patternListE yENDCASE	{ }
	|	unique_priorityE caseStart caseAttrE yINSIDE case_insideListE yENDCASE	{ $$ = $2; if ($5) $2->addItemsp($5);
							  if (!$2->caseSimple()) $2->v3error("Illegal to have inside on a casex/casez");
							  $2->caseInsideSet();
							  if ($1 == uniq_UNIQUE) $2->uniquePragma(true);
							  if ($1 == uniq_UNIQUE0) $2->unique0Pragma(true);
							  if ($1 == uniq_PRIORITY) $2->priorityPragma(true); }
	//
	//			// IEEE: conditional_statement
	|	unique_priorityE yIF '(' expr ')' stmtBlock	%prec prLOWER_THAN_ELSE
							{ AstIf* newp = new AstIf($2,$4,$6,nullptr);
							  $$ = newp;
							  if ($1 == uniq_UNIQUE) newp->uniquePragma(true);
							  if ($1 == uniq_UNIQUE0) newp->unique0Pragma(true);
							  if ($1 == uniq_PRIORITY) newp->priorityPragma(true); }
	|	unique_priorityE yIF '(' expr ')' stmtBlock yELSE stmtBlock
							{ AstIf* newp = new AstIf($2,$4,$6,$8);
							  $$ = newp;
							  if ($1 == uniq_UNIQUE) newp->uniquePragma(true);
							  if ($1 == uniq_UNIQUE0) newp->unique0Pragma(true);
							  if ($1 == uniq_PRIORITY) newp->priorityPragma(true); }
	//
	|	finc_or_dec_expression ';'		{ $$ = $1; }
	//			// IEEE: inc_or_dec_expression
	//			// Below under expr
	//
	//			// IEEE: subroutine_call_statement
	//			// IEEE says we then expect a function call
	//			// (function_subroutine_callNoMethod), but rest of
	//			// the code expects an AstTask when used as a statement,
	//			// so parse as if task
	//			// Alternative would be shim with new AstVoidStmt.
	|	yVOID yP_TICK '(' task_subroutine_callNoMethod ')' ';'
							{ $$ = $4;
							  FileLine* newfl = new FileLine($$->fileline());
							  newfl->warnOff(V3ErrorCode::IGNOREDRETURN, true);
							  $$->fileline(newfl); }
	|	yVOID yP_TICK '(' expr '.' task_subroutine_callNoMethod ')' ';'
							{ $$ = new AstDot($5, false, $4, $6);
							  FileLine* newfl = new FileLine($6->fileline());
							  newfl->warnOff(V3ErrorCode::IGNOREDRETURN, true);
							  $6->fileline(newfl); }
	//			// Expr included here to resolve our not knowing what is a method call
	//			// Expr here must result in a subroutine_call
	|	task_subroutine_callNoMethod ';'	{ $$ = $1; }
	//UNSUP	fexpr '.' array_methodNoRoot ';'	{ UNSUP }
	|	fexpr '.' task_subroutine_callNoMethod ';'	{ $$ = new AstDot($<fl>2, false, $1, $3); }
	//UNSUP	fexprScope ';'				{ UNSUP }
	//			// Not here in IEEE; from class_constructor_declaration
	//			// Because we've joined class_constructor_declaration into generic functions
	//			// Way over-permissive;
	//			// IEEE: [ ySUPER '.' yNEW [ '(' list_of_arguments ')' ] ';' ]
	|	fexpr '.' class_new ';'			{ $$ = new AstDot($<fl>2, false, $1, $3); }
	//
	|	statementVerilatorPragmas		{ $$ = $1; }
	//
	//			// IEEE: disable_statement
	|	yDISABLE idAny/*hierarchical_identifier-task_or_block*/ ';'	{ $$ = new AstDisable($1,*$2); }
	|	yDISABLE yFORK ';'			{ $$ = new AstDisableFork($1); }
	//			// IEEE: event_trigger
	|	yP_MINUSGT idDotted/*hierarchical_identifier-event*/ ';'
			{ // AssignDly because we don't have stratified queue, and need to
			  // read events, clear next event, THEN apply this set
			  $$ = new AstAssignDly($1, $2, new AstConst($1, AstConst::LogicTrue())); }
	//UNSUP	yP_MINUSGTGT delay_or_event_controlE hierarchical_identifier/*event*/ ';'	{ UNSUP }
	//			// IEEE remove below
	|	yP_MINUSGTGT delayE idDotted/*hierarchical_identifier-event*/ ';'
			{ $$ = new AstAssignDly($1, $3, new AstConst($1, AstConst::LogicTrue())); }
	//
	//			// IEEE: loop_statement
	|	yFOREVER stmtBlock			{ $$ = new AstWhile($1,new AstConst($1,AstConst::LogicTrue()),$2); }
	|	yREPEAT '(' expr ')' stmtBlock		{ $$ = new AstRepeat($1,$3,$5);}
	|	yWHILE '(' expr ')' stmtBlock		{ $$ = new AstWhile($1,$3,$5);}
	//			// for's first ';' is in for_initialization
	|	statementFor				{ $$ = $1; }
	|	yDO stmtBlock yWHILE '(' expr ')' ';'	{ if ($2) {
							     $$ = $2->cloneTree(true);
							     $$->addNext(new AstWhile($1,$5,$2));
							  }
							  else $$ = new AstWhile($1,$5,nullptr); }
	//			// IEEE says array_identifier here, but dotted accepted in VMM and 1800-2009
	|	yFOREACH '(' idClassSelForeach ')' stmtBlock	{ $$ = new AstForeach($1, $3, $5); }
	//
	//			// IEEE: jump_statement
	|	yRETURN ';'				{ $$ = new AstReturn($1); }
	|	yRETURN expr ';'			{ $$ = new AstReturn($1,$2); }
	|	yBREAK ';'				{ $$ = new AstBreak($1); }
	|	yCONTINUE ';'				{ $$ = new AstContinue($1); }
	//
	|	par_block				{ $$ = $1; }
	//			// IEEE: procedural_timing_control_statement + procedural_timing_control
	|	delay_control stmtBlock			{ $$ = new AstDelay($1->fileline(), $1); $$->addNextNull($2); }
	|	event_control stmtBlock			{ $$ = new AstTimingControl(FILELINE_OR_CRE($1), $1, $2); }
	//UNSUP	cycle_delay stmtBlock			{ UNSUP }
	//
	|	seq_block				{ $$ = $1; }
	//
	//			// IEEE: wait_statement
	|	yWAIT '(' expr ')' stmtBlock		{ $$ = new AstWait($1, $3, $5); }
	|	yWAIT yFORK ';'				{ $$ = new AstWaitFork($1); }
	//UNSUP	yWAIT_ORDER '(' hierarchical_identifierList ')' action_block	{ UNSUP }
	//
	//			// IEEE: procedural_assertion_statement
	|	procedural_assertion_statement		{ $$ = $1; }
	//
	//			// IEEE: clocking_drive ';'
	//			// Pattern w/o cycle_delay handled by nonblocking_assign above
	//			// clockvar_expression made to fexprLvalue to prevent reduce conflict
	//			// Note LTE in this context is highest precedence, so first on left wins
	//UNSUP	cycle_delay fexprLvalue yP_LTE ';'	{ UNSUP }
	//UNSUP	fexprLvalue yP_LTE cycle_delay expr ';'	{ UNSUP }
	//
	//UNSUP	randsequence_statement			{ $$ = $1; }
	//
	//			// IEEE: randcase_statement
	|	yRANDCASE case_itemList yENDCASE	{ $$ = nullptr; BBUNSUP($1, "Unsupported: SystemVerilog 2005 randcase statements"); }
	//
	//UNSUP	expect_property_statement		{ $$ = $1; }
	//
	|	error ';'				{ $$ = nullptr; }
	;

statementFor<beginp>:		// IEEE: part of statement
		yFOR '(' for_initialization expr ';' for_stepE ')' stmtBlock
							{ $$ = new AstBegin($1, "", $3, false, true);
							  $$->addStmtsp(new AstWhile($1, $4,$8,$6)); }
	|	yFOR '(' for_initialization ';' for_stepE ')' stmtBlock
							{ $$ = new AstBegin($1, "", $3, false, true);
							  $$->addStmtsp(new AstWhile($1, new AstConst($1,AstConst::LogicTrue()),$7,$5)); }
	;

statementVerilatorPragmas<nodep>:
		yVL_COVERAGE_BLOCK_OFF			{ $$ = new AstPragma($1,AstPragmaType::COVERAGE_BLOCK_OFF); }
	;

//UNSUPoperator_assignment<nodep>:  // IEEE: operator_assignment
//UNSUP		~f~exprLvalue '=' delay_or_event_controlE expr { }
//UNSUP	|	~f~exprLvalue yP_PLUSEQ    expr		{ }
//UNSUP	|	~f~exprLvalue yP_MINUSEQ   expr		{ }
//UNSUP	|	~f~exprLvalue yP_TIMESEQ   expr		{ }
//UNSUP	|	~f~exprLvalue yP_DIVEQ     expr		{ }
//UNSUP	|	~f~exprLvalue yP_MODEQ     expr		{ }
//UNSUP	|	~f~exprLvalue yP_ANDEQ     expr		{ }
//UNSUP	|	~f~exprLvalue yP_OREQ      expr		{ }
//UNSUP	|	~f~exprLvalue yP_XOREQ     expr		{ }
//UNSUP	|	~f~exprLvalue yP_SLEFTEQ   expr		{ }
//UNSUP	|	~f~exprLvalue yP_SRIGHTEQ  expr		{ }
//UNSUP	|	~f~exprLvalue yP_SSRIGHTEQ expr		{ }
//UNSUP	;

foperator_assignment<nodep>:	// IEEE: operator_assignment (for first part of expression)
		fexprLvalue '=' delayE expr	{ $$ = new AstAssign($2,$1,$4); }
	|	fexprLvalue '=' yD_FOPEN '(' expr ')'		{ $$ = new AstFOpenMcd($3,$1,$5); }
	|	fexprLvalue '=' yD_FOPEN '(' expr ',' expr ')'	{ $$ = new AstFOpen($3,$1,$5,$7); }
	//
	//UNSUP	~f~exprLvalue '=' delay_or_event_controlE expr { UNSUP }
	//UNSUP	~f~exprLvalue yP_PLUS(etc) expr		{ UNSUP }
	|	fexprLvalue yP_PLUSEQ    expr		{ $$ = new AstAssign($2,$1,new AstAdd    ($2,$1->cloneTree(true),$3)); }
	|	fexprLvalue yP_MINUSEQ   expr		{ $$ = new AstAssign($2,$1,new AstSub    ($2,$1->cloneTree(true),$3)); }
	|	fexprLvalue yP_TIMESEQ   expr		{ $$ = new AstAssign($2,$1,new AstMul    ($2,$1->cloneTree(true),$3)); }
	|	fexprLvalue yP_DIVEQ     expr		{ $$ = new AstAssign($2,$1,new AstDiv    ($2,$1->cloneTree(true),$3)); }
	|	fexprLvalue yP_MODEQ     expr		{ $$ = new AstAssign($2,$1,new AstModDiv ($2,$1->cloneTree(true),$3)); }
	|	fexprLvalue yP_ANDEQ     expr		{ $$ = new AstAssign($2,$1,new AstAnd    ($2,$1->cloneTree(true),$3)); }
	|	fexprLvalue yP_OREQ      expr		{ $$ = new AstAssign($2,$1,new AstOr     ($2,$1->cloneTree(true),$3)); }
	|	fexprLvalue yP_XOREQ     expr		{ $$ = new AstAssign($2,$1,new AstXor    ($2,$1->cloneTree(true),$3)); }
	|	fexprLvalue yP_SLEFTEQ   expr		{ $$ = new AstAssign($2,$1,new AstShiftL ($2,$1->cloneTree(true),$3)); }
	|	fexprLvalue yP_SRIGHTEQ  expr		{ $$ = new AstAssign($2,$1,new AstShiftR ($2,$1->cloneTree(true),$3)); }
	|	fexprLvalue yP_SSRIGHTEQ expr		{ $$ = new AstAssign($2,$1,new AstShiftRS($2,$1->cloneTree(true),$3)); }
	//UNSUP replace above with:
	//UNSUP	BISONPRE_COPY(operator_assignment,{s/~f~/f/g})	// {copied}
	;

inc_or_dec_expression<nodep>:	// ==IEEE: inc_or_dec_expression
	//			// Need fexprScope instead of variable_lvalue to prevent conflict
		~l~exprScope yP_PLUSPLUS		{ $<fl>$=$<fl>1; $$ = new AstPostAdd($2, new AstConst($2, AstConst::StringToParse(), "'b1"), $1, $1->cloneTree(true)); }
	|	~l~exprScope yP_MINUSMINUS		{ $<fl>$=$<fl>1; $$ = new AstPostSub($2, new AstConst($2, AstConst::StringToParse(), "'b1"), $1, $1->cloneTree(true)); }
	//			// Need expr instead of variable_lvalue to prevent conflict
	|	yP_PLUSPLUS	expr			{ $<fl>$=$<fl>1; $$ = new AstPreAdd($1, new AstConst($1, AstConst::StringToParse(), "'b1"), $2, $2->cloneTree(true)); }
	|	yP_MINUSMINUS	expr			{ $<fl>$=$<fl>1; $$ = new AstPreSub($1, new AstConst($1, AstConst::StringToParse(), "'b1"), $2, $2->cloneTree(true)); }
	;

finc_or_dec_expression<nodep>:	// ==IEEE: inc_or_dec_expression
		BISONPRE_COPY(inc_or_dec_expression,{s/~l~/f/g})	// {copied}
	;

//UNSUPsinc_or_dec_expression<nodep>:  // IEEE: inc_or_dec_expression (for sequence_expression)
//UNSUP		BISONPRE_COPY(inc_or_dec_expression,{s/~l~/s/g})	// {copied}
//UNSUP	;

//UNSUPpinc_or_dec_expression<nodep>:  // IEEE: inc_or_dec_expression (for property_expression)
//UNSUP		BISONPRE_COPY(inc_or_dec_expression,{s/~l~/p/g})	// {copied}
//UNSUP	;

//UNSUPev_inc_or_dec_expression<nodep>:  // IEEE: inc_or_dec_expression (for ev_expr)
//UNSUP		BISONPRE_COPY(inc_or_dec_expression,{s/~l~/ev_/g})	// {copied}
//UNSUP	;

//UNSUPpev_inc_or_dec_expression<nodep>:  // IEEE: inc_or_dec_expression (for pev_expr)
//UNSUP		BISONPRE_COPY(inc_or_dec_expression,{s/~l~/pev_/g})	// {copied}
//UNSUP	;

class_new<nodep>:		// ==IEEE: class_new
	//			// Special precence so (...) doesn't match expr
		yNEW__ETC				{ $$ = new AstNew($1,  nullptr); }
	|	yNEW__ETC expr				{ $$ = new AstNewCopy($1, $2); }
	|	yNEW__PAREN '(' list_of_argumentsE ')'	{ $$ = new AstNew($1, $3); }
	;

dynamic_array_new<nodep>:	// ==IEEE: dynamic_array_new
		yNEW__ETC '[' expr ']'			{ $$ = new AstNewDynamic($1, $3, nullptr); }
	|	yNEW__ETC '[' expr ']' '(' expr ')'	{ $$ = new AstNewDynamic($1, $3, $6); }
	;

//************************************************
// Case/If

unique_priorityE<uniqstate>:	// IEEE: unique_priority + empty
		/*empty*/				{ $$ = uniq_NONE; }
	|	yPRIORITY				{ $$ = uniq_PRIORITY; }
	|	yUNIQUE					{ $$ = uniq_UNIQUE; }
	|	yUNIQUE0				{ $$ = uniq_UNIQUE0; }
	;

caseStart<casep>:		// IEEE: part of case_statement
	 	yCASE  '(' expr ')' 			{ $$ = GRAMMARP->m_caseAttrp = new AstCase($1,VCaseType::CT_CASE,$3,nullptr); }
	|	yCASEX '(' expr ')' 			{ $$ = GRAMMARP->m_caseAttrp = new AstCase($1,VCaseType::CT_CASEX,$3,nullptr); }
	|	yCASEZ '(' expr ')'			{ $$ = GRAMMARP->m_caseAttrp = new AstCase($1,VCaseType::CT_CASEZ,$3,nullptr); }
	;

caseAttrE:
	 	/*empty*/				{ }
	|	caseAttrE yVL_FULL_CASE			{ GRAMMARP->m_caseAttrp->fullPragma(true); }
	|	caseAttrE yVL_PARALLEL_CASE		{ GRAMMARP->m_caseAttrp->parallelPragma(true); }
	;

//UNSUPcase_patternListE<nodep>:  // IEEE: case_pattern_item
//UNSUP	//	&&& is part of expr so aliases to case_itemList
//UNSUP		case_itemListE				{ $$ = $1; }
//UNSUP	;

case_itemListE<caseitemp>:	// IEEE: [ { case_item } ]
		/* empty */				{ $$ = nullptr; }
	|	case_itemList				{ $$ = $1; }
	;

case_insideListE<caseitemp>:	// IEEE: [ { case_inside_item } ]
		/* empty */				{ $$ = nullptr; }
	|	case_inside_itemList			{ $$ = $1; }
	;

case_itemList<caseitemp>:	// IEEE: { case_item + ... }
		caseCondList colon stmtBlock		{ $$ = new AstCaseItem($2,$1,$3); }
	|	yDEFAULT colon stmtBlock			{ $$ = new AstCaseItem($1,nullptr,$3); }
	|	yDEFAULT stmtBlock			{ $$ = new AstCaseItem($1,nullptr,$2); }
	|	case_itemList caseCondList colon stmtBlock	{ $$ = $1;$1->addNext(new AstCaseItem($3,$2,$4)); }
	|       case_itemList yDEFAULT stmtBlock		{ $$ = $1;$1->addNext(new AstCaseItem($2,nullptr,$3)); }
	|	case_itemList yDEFAULT colon stmtBlock		{ $$ = $1;$1->addNext(new AstCaseItem($2,nullptr,$4)); }
	;

case_inside_itemList<caseitemp>:	// IEEE: { case_inside_item + open_range_list ... }
		open_range_list colon stmtBlock		{ $$ = new AstCaseItem($2,$1,$3); }
	|	yDEFAULT colon stmtBlock			{ $$ = new AstCaseItem($1,nullptr,$3); }
	|	yDEFAULT stmtBlock			{ $$ = new AstCaseItem($1,nullptr,$2); }
	|	case_inside_itemList open_range_list colon stmtBlock { $$ = $1;$1->addNext(new AstCaseItem($3,$2,$4)); }
	|       case_inside_itemList yDEFAULT stmtBlock		{ $$ = $1;$1->addNext(new AstCaseItem($2,nullptr,$3)); }
	|	case_inside_itemList yDEFAULT colon stmtBlock	{ $$ = $1;$1->addNext(new AstCaseItem($2,nullptr,$4)); }
	;

open_range_list<nodep>:		// ==IEEE: open_range_list + open_value_range
		open_value_range			{ $$ = $1; }
	|	open_range_list ',' open_value_range	{ $$ = $1;$1->addNext($3); }
	;

open_value_range<nodep>:	// ==IEEE: open_value_range
		value_range				{ $$ = $1; }
	;

value_range<nodep>:		// ==IEEE: value_range
		expr					{ $$ = $1; }
	|	'[' expr ':' expr ']'			{ $$ = new AstInsideRange($1, $2, $4); }
	;

//UNSUPcovergroup_value_range<nodep>:  // ==IEEE-2012: covergroup_value_range
//UNSUP		cgexpr					{ $$ = $1; }
//UNSUP	|	'[' cgexpr ':' cgexpr ']'		{ }
//UNSUP	;

caseCondList<nodep>:		// IEEE: part of case_item
		expr 					{ $$ = $1; }
	|	caseCondList ',' expr			{ $$ = $1;$1->addNext($3); }
	;

patternNoExpr<nodep>:		// IEEE: pattern **Excluding Expr*
		'.' id/*variable*/			{ $$ = nullptr; BBUNSUP($1, "Unsupported: '{} tagged patterns"); }
	|	yP_DOTSTAR				{ $$ = nullptr; BBUNSUP($1, "Unsupported: '{} tagged patterns"); }
	//			// IEEE: "expr" excluded; expand in callers
	//			// "yTAGGED id [expr]" Already part of expr
	//UNSUP	yTAGGED id/*member_identifier*/ patternNoExpr		{ $$ = nullptr; BBUNSUP($1, "Unsupported: '{} tagged patterns"); }
	//			// "yP_TICKBRA patternList '}'" part of expr under assignment_pattern
	;

patternList<nodep>:		// IEEE: part of pattern
		patternOne				{ $$ = $1; }
	|	patternList ',' patternOne		{ $$ = $1->addNextNull($3); }
	;

patternOne<nodep>:		// IEEE: part of pattern
		expr					{ if ($1) { $$ = new AstPatMember($1->fileline(),$1,nullptr,nullptr); } else { $$=nullptr; } }
	|	expr '{' argsExprList '}'		{ $$ = new AstPatMember($2,$3,nullptr,$1); }
	|	patternNoExpr				{ $$ = $1; }
	;

patternMemberList<nodep>:	// IEEE: part of pattern and assignment_pattern
		patternMemberOne			{ $$ = $1; }
	|	patternMemberList ',' patternMemberOne	{ $$ = $1->addNextNull($3); }
	;

patternMemberOne<patmemberp>:	// IEEE: part of pattern and assignment_pattern
		patternKey ':' expr			{ $$ = new AstPatMember($1->fileline(),$3,$1,nullptr); }
	|	patternKey ':' patternNoExpr		{ $$ = nullptr; BBUNSUP($2, "Unsupported: '{} .* patterns"); }
	//			// From assignment_pattern_key
	|	yDEFAULT ':' expr			{ $$ = new AstPatMember($1,$3,nullptr,nullptr); $$->isDefault(true); }
	|	yDEFAULT ':' patternNoExpr		{ $$ = nullptr; BBUNSUP($2, "Unsupported: '{} .* patterns"); }
	;

patternKey<nodep>:		// IEEE: merge structure_pattern_key, array_pattern_key, assignment_pattern_key
	//			// IEEE: structure_pattern_key
	//			// id/*member*/ is part of constExpr below
	//UNSUP	constExpr				{ $$ = $1; }
	//			// IEEE: assignment_pattern_key
	//UNSUP	simple_type				{ $1->v3error("Unsupported: '{} with data type as key"); $$=$1; }
	//			// simple_type reference looks like constExpr
	//			// Verilator:
	//			//   The above expressions cause problems because "foo" may be a constant identifier
	//			//   (if array) or a reference to the "foo"member (if structure)
	//			//   So for now we only allow a true constant number, or a identifier which we treat as a structure member name
		yaINTNUM				{ $$ = new AstConst($<fl>1,*$1); }
	|	yaFLOATNUM				{ $$ = new AstConst($<fl>1,AstConst::RealDouble(),$1); }
	|	id					{ $$ = new AstText($<fl>1,*$1); }
	|	strAsInt				{ $$ = $1; }
	;

assignment_pattern<patternp>:	// ==IEEE: assignment_pattern
	// This doesn't match the text of the spec.  I think a : is missing, or example code needed
	// yP_TICKBRA constExpr exprList '}'	{ $$="'{"+$2+" "+$3"}"; }
	//			// "'{ const_expression }" is same as patternList with one entry
	//			// From patternNoExpr
	//			// also IEEE: "''{' expression { ',' expression } '}'"
	//			//      matches since patternList includes expr
		yP_TICKBRA patternList '}'		{ $$ = new AstPattern($1,$2); }
	//			// From patternNoExpr
	//			// also IEEE "''{' structure_pattern_key ':' ...
	//			// also IEEE "''{' array_pattern_key ':' ...
	|	yP_TICKBRA patternMemberList '}'	{ $$ = new AstPattern($1,$2); }
	//			// IEEE: Not in grammar, but in VMM
	|	yP_TICKBRA '}'				{ $$ = new AstPattern($1, nullptr); }
	;

// "datatype id = x {, id = x }"  |  "yaId = x {, id=x}" is legal
for_initialization<nodep>:	// ==IEEE: for_initialization + for_variable_declaration + extra terminating ";"
	//			// IEEE: for_variable_declaration
		for_initializationItemList ';'		{ $$ = $1; }
	//			// IEEE: 1800-2017 empty initialization
	|	';'					{ $$ = nullptr; }
	;

for_initializationItemList<nodep>:	// IEEE: [for_variable_declaration...]
		for_initializationItem			{ $$ = $1; }
	|	for_initializationItemList ',' for_initializationItem	{ $$ = $1; BBUNSUP($2, "Unsupported: for loop initialization after the first comma"); }
	;

for_initializationItem<nodep>:		// IEEE: variable_assignment + for_variable_declaration
	//			// IEEE: for_variable_declaration
		data_type idAny/*new*/ '=' expr
			{ VARRESET_NONLIST(VAR); VARDTYPE($1);
			  $$ = VARDONEA($<fl>2,*$2,nullptr,nullptr);
			  $$->addNext(new AstAssign($3, new AstVarRef($<fl>2, *$2, VAccess::WRITE), $4)); }
	//			// IEEE-2012:
	|	yVAR data_type idAny/*new*/ '=' expr
			{ VARRESET_NONLIST(VAR); VARDTYPE($2);
			  $$ = VARDONEA($<fl>3,*$3,nullptr,nullptr);
			  $$->addNext(new AstAssign($4, new AstVarRef($<fl>3, *$3, VAccess::WRITE), $5)); }
	//			// IEEE: variable_assignment
	//			// UNSUP variable_lvalue below
	|	varRefBase '=' expr			{ $$ = new AstAssign($2, $1, $3); }
	;

for_stepE<nodep>:		// IEEE: for_step + empty
		/* empty */				{ $$ = nullptr; }
	|	for_step				{ $$ = $1; }
	;

for_step<nodep>:		// IEEE: for_step
		for_step_assignment			{ $$ = $1; }
	|	for_step ',' for_step_assignment	{ $$ = AstNode::addNextNull($1, $3); }
	;

for_step_assignment<nodep>:  // ==IEEE: for_step_assignment
	//UNSUP	operator_assignment			{ $$ = $1; }
	//
	//UNSUP	inc_or_dec_expression			{ $$ = $1; }
	//			// IEEE: subroutine_call
	//UNSUP	function_subroutine_callNoMethod	{ $$ = $1; }
	//			// method_call:array_method requires a '.'
	//UNSUP	expr '.' array_methodNoRoot		{ }
	//UNSUP	exprScope				{ $$ = $1; }
	//UNSUP remove below
		genvar_iteration			{ $$ = $1; }
	//UNSUP remove above
	;

loop_variables<nodep>:		// IEEE: loop_variables
		varRefBase				{ $$ = $1; }
	|	loop_variables ',' varRefBase		{ $$ = $1;$1->addNext($3); }
	;

//************************************************
// Functions/tasks

taskRef<nodep>:			// IEEE: part of tf_call
		id		 		{ $$ = new AstTaskRef($<fl>1,*$1,nullptr); }
	|	id '(' list_of_argumentsE ')'	{ $$ = new AstTaskRef($<fl>1,*$1,$3); }
	|	packageClassScope id '(' list_of_argumentsE ')'
			{ $$ = AstDot::newIfPkg($<fl>2, $1, new AstTaskRef($<fl>2, *$2, $4)); }
	;

funcRef<nodep>:			// IEEE: part of tf_call
	//			// package_scope/hierarchical_... is part of expr, so just need ID
	//			//	making-a		id-is-a
	//			//	-----------------	------------------
	//			//      tf_call			tf_identifier		expr (list_of_arguments)
	//			//      method_call(post .)	function_identifier	expr (list_of_arguments)
	//			//	property_instance	property_identifier	property_actual_arg
	//			//	sequence_instance	sequence_identifier	sequence_actual_arg
	//			//      let_expression		let_identifier		let_actual_arg
	//
		id '(' list_of_argumentsE ')'
			{ $$ = new AstFuncRef($<fl>1, *$1, $3); }
	|	packageClassScope id '(' list_of_argumentsE ')'
			{ $$ = AstDot::newIfPkg($<fl>2, $1, new AstFuncRef($<fl>2, *$2, $4)); }
	//UNSUP list_of_argumentE should be pev_list_of_argumentE
	//UNSUP: idDotted is really just id to allow dotted method calls
	;

task_subroutine_callNoMethod<nodep>:	// function_subroutine_callNoMethod (as task)
	//			// IEEE: tf_call
		taskRef					{ $$ = $1; }
	//			// funcref below not task ref to avoid conflict, must later handle either
	|	funcRef yWITH__PAREN '(' expr ')'	{ $$ = new AstWithParse($2, true, $1, $4); }
	//			// can call as method and yWITH without parenthesis
	|	id yWITH__PAREN '(' expr ')'		{ $$ = new AstWithParse($2, true, new AstFuncRef($<fl>1, *$1, nullptr), $4); }
	|	system_t_call				{ $$ = $1; }
	//			// IEEE: method_call requires a "." so is in expr
	//			// IEEE: ['std::'] not needed, as normal std package resolution will find it
	//			// IEEE: randomize_call
	//			// We implement randomize as a normal funcRef, since randomize isn't a keyword
	//			// Note yNULL is already part of expressions, so they come for free
	//UNSUP	funcRef yWITH__CUR constraint_block	{ }
	;

function_subroutine_callNoMethod<nodep>:	// IEEE: function_subroutine_call (as function)
	//			// IEEE: tf_call
		funcRef					{ $$ = $1; }
	|	funcRef yWITH__PAREN '(' expr ')'	{ $$ = new AstWithParse($2, false, $1, $4); }
	//			// can call as method and yWITH without parenthesis
	|	id yWITH__PAREN '(' expr ')'		{ $$ = new AstWithParse($2, false, new AstFuncRef($<fl>1, *$1, nullptr), $4); }
	|	system_f_call				{ $$ = $1; }
	//			// IEEE: method_call requires a "." so is in expr
	//			// IEEE: ['std::'] not needed, as normal std package resolution will find it
	//			// IEEE: randomize_call
	//			// We implement randomize as a normal funcRef, since randomize isn't a keyword
	//			// Note yNULL is already part of expressions, so they come for free
	|	funcRef yWITH__CUR constraint_block	{ $$ = $1; BBUNSUP($2, "Unsupported: randomize() 'with' constraint"); }
	|	funcRef yWITH__CUR '{' '}'		{ $$ = new AstWithParse($2, false, $1, nullptr); }
	;

system_t_call<nodep>:		// IEEE: system_tf_call (as task)
	//
		yaD_PLI systemDpiArgsE			{ $$ = new AstTaskRef($<fl>1, *$1, $2); VN_CAST($$, TaskRef)->pli(true); }
	//
	|	yD_DUMPPORTS '(' idDotted ',' expr ')'	{ $$ = new AstDumpCtl($<fl>1, VDumpCtlType::FILE, $5); DEL($3);
    							  $$->addNext(new AstDumpCtl($<fl>1, VDumpCtlType::VARS,
										     new AstConst($<fl>1, 1))); }
	|	yD_DUMPPORTS '(' ',' expr ')'		{ $$ = new AstDumpCtl($<fl>1, VDumpCtlType::FILE, $4);
    							  $$->addNext(new AstDumpCtl($<fl>1, VDumpCtlType::VARS,
										     new AstConst($<fl>1, 1))); }
	|	yD_DUMPFILE '(' expr ')'		{ $$ = new AstDumpCtl($<fl>1, VDumpCtlType::FILE, $3); }
	|	yD_DUMPVARS parenE			{ $$ = new AstDumpCtl($<fl>1, VDumpCtlType::VARS,
									      new AstConst($<fl>1, 0)); }
	|	yD_DUMPVARS '(' expr ')'		{ $$ = new AstDumpCtl($<fl>1, VDumpCtlType::VARS, $3); }
	|	yD_DUMPVARS '(' expr ',' idDotted ')'	{ $$ = new AstDumpCtl($<fl>1, VDumpCtlType::VARS, $3); DEL($5); }
	|	yD_DUMPALL parenE			{ $$ = new AstDumpCtl($<fl>1, VDumpCtlType::ALL); }
	|	yD_DUMPALL '(' expr ')'			{ $$ = new AstDumpCtl($<fl>1, VDumpCtlType::ALL); DEL($3); }
	|	yD_DUMPFLUSH parenE			{ $$ = new AstDumpCtl($<fl>1, VDumpCtlType::FLUSH); }
	|	yD_DUMPFLUSH '(' expr ')'		{ $$ = new AstDumpCtl($<fl>1, VDumpCtlType::FLUSH); DEL($3); }
	|	yD_DUMPLIMIT '(' expr ')'		{ $$ = new AstDumpCtl($<fl>1, VDumpCtlType::LIMIT, $3); }
	|	yD_DUMPLIMIT '(' expr ',' expr ')'	{ $$ = new AstDumpCtl($<fl>1, VDumpCtlType::LIMIT, $3); DEL($5); }
	|	yD_DUMPOFF parenE			{ $$ = new AstDumpCtl($<fl>1, VDumpCtlType::OFF); }
	|	yD_DUMPOFF '(' expr ')'			{ $$ = new AstDumpCtl($<fl>1, VDumpCtlType::OFF); DEL($3); }
	|	yD_DUMPON parenE			{ $$ = new AstDumpCtl($<fl>1, VDumpCtlType::ON); }
	|	yD_DUMPON '(' expr ')'			{ $$ = new AstDumpCtl($<fl>1, VDumpCtlType::ON); DEL($3); }
	//
	|	yD_C '(' cStrList ')'			{ $$ = (v3Global.opt.ignc() ? nullptr : new AstUCStmt($1,$3)); }
	|	yD_SYSTEM '(' expr ')'			{ $$ = new AstSystemT($1, $3); }
	//
	|	yD_EXIT parenE				{ $$ = new AstFinish($1); }
	//
	|	yD_FCLOSE '(' idClassSel ')'		{ $$ = new AstFClose($1, $3); }
	|	yD_FFLUSH parenE			{ $$ = new AstFFlush($1, nullptr); }
	|	yD_FFLUSH '(' expr ')'			{ $$ = new AstFFlush($1, $3); }
	|	yD_FINISH parenE			{ $$ = new AstFinish($1); }
	|	yD_FINISH '(' expr ')'			{ $$ = new AstFinish($1); DEL($3); }
	|	yD_STOP parenE				{ $$ = new AstStop($1, false); }
	|	yD_STOP '(' expr ')'			{ $$ = new AstStop($1, false); DEL($3); }
	//
	|	yD_SFORMAT '(' expr ',' exprDispList ')'	{ $$ = new AstSFormat($1, $3, $5); }
	|	yD_SWRITE  '(' expr ',' exprDispList ')'	{ $$ = new AstSFormat($1, $3, $5); }
	|	yD_SWRITEB '(' expr ',' exprDispList ')'	{ $$ = new AstSFormat($1, $3, $5, 'b'); }
	|	yD_SWRITEH '(' expr ',' exprDispList ')'	{ $$ = new AstSFormat($1, $3, $5, 'h'); }
	|	yD_SWRITEO '(' expr ',' exprDispList ')'	{ $$ = new AstSFormat($1, $3, $5, 'o'); }
	//
	|	yD_DISPLAY  parenE			{ $$ = new AstDisplay($1,AstDisplayType::DT_DISPLAY, nullptr, nullptr); }
	|	yD_DISPLAY  '(' exprDispList ')'	{ $$ = new AstDisplay($1,AstDisplayType::DT_DISPLAY, nullptr, $3); }
	|	yD_DISPLAYB  parenE			{ $$ = new AstDisplay($1,AstDisplayType::DT_DISPLAY, nullptr, nullptr, 'b'); }
	|	yD_DISPLAYB  '(' exprDispList ')'	{ $$ = new AstDisplay($1,AstDisplayType::DT_DISPLAY, nullptr, $3, 'b'); }
	|	yD_DISPLAYH  parenE			{ $$ = new AstDisplay($1,AstDisplayType::DT_DISPLAY, nullptr, nullptr, 'h'); }
	|	yD_DISPLAYH  '(' exprDispList ')'	{ $$ = new AstDisplay($1,AstDisplayType::DT_DISPLAY, nullptr, $3, 'h'); }
	|	yD_DISPLAYO  parenE			{ $$ = new AstDisplay($1,AstDisplayType::DT_DISPLAY, nullptr, nullptr, 'o'); }
	|	yD_DISPLAYO  '(' exprDispList ')'	{ $$ = new AstDisplay($1,AstDisplayType::DT_DISPLAY, nullptr, $3, 'o'); }
	|	yD_WRITE    parenE			{ $$ = nullptr; }  // NOP
	|	yD_WRITE    '(' exprDispList ')'	{ $$ = new AstDisplay($1,AstDisplayType::DT_WRITE,   nullptr, $3); }
	|	yD_WRITEB   parenE			{ $$ = nullptr; }  // NOP
	|	yD_WRITEB   '(' exprDispList ')'	{ $$ = new AstDisplay($1,AstDisplayType::DT_WRITE,   nullptr, $3, 'b'); }
	|	yD_WRITEH   parenE			{ $$ = nullptr; }  // NOP
	|	yD_WRITEH   '(' exprDispList ')'	{ $$ = new AstDisplay($1,AstDisplayType::DT_WRITE,   nullptr, $3, 'h'); }
	|	yD_WRITEO   parenE			{ $$ = nullptr; }  // NOP
	|	yD_WRITEO   '(' exprDispList ')'	{ $$ = new AstDisplay($1,AstDisplayType::DT_WRITE,   nullptr, $3, 'o'); }
	|	yD_FDISPLAY '(' expr ')'		{ $$ = new AstDisplay($1,AstDisplayType::DT_DISPLAY, $3, nullptr); }
	|	yD_FDISPLAY '(' expr ',' exprDispList ')' 	{ $$ = new AstDisplay($1,AstDisplayType::DT_DISPLAY, $3, $5); }
	|	yD_FDISPLAYB '(' expr ')'			{ $$ = new AstDisplay($1,AstDisplayType::DT_DISPLAY, $3, nullptr, 'b'); }
	|	yD_FDISPLAYB '(' expr ',' exprDispList ')'	{ $$ = new AstDisplay($1,AstDisplayType::DT_DISPLAY, $3, $5, 'b'); }
	|	yD_FDISPLAYH '(' expr ')'			{ $$ = new AstDisplay($1,AstDisplayType::DT_DISPLAY, $3, nullptr, 'h'); }
	|	yD_FDISPLAYH '(' expr ',' exprDispList ')'	{ $$ = new AstDisplay($1,AstDisplayType::DT_DISPLAY, $3, $5, 'h'); }
	|	yD_FDISPLAYO '(' expr ')'			{ $$ = new AstDisplay($1,AstDisplayType::DT_DISPLAY, $3, nullptr, 'o'); }
	|	yD_FDISPLAYO '(' expr ',' exprDispList ')'	{ $$ = new AstDisplay($1,AstDisplayType::DT_DISPLAY, $3, $5, 'o'); }
	|	yD_FWRITE   '(' expr ',' exprDispList ')'	{ $$ = new AstDisplay($1,AstDisplayType::DT_WRITE,   $3, $5); }
	|	yD_FWRITEB  '(' expr ',' exprDispList ')'	{ $$ = new AstDisplay($1,AstDisplayType::DT_WRITE,   $3, $5, 'b'); }
	|	yD_FWRITEO  '(' expr ',' exprDispList ')'	{ $$ = new AstDisplay($1,AstDisplayType::DT_WRITE,   $3, $5, 'h'); }
	|	yD_FWRITEH  '(' expr ',' exprDispList ')'	{ $$ = new AstDisplay($1,AstDisplayType::DT_WRITE,   $3, $5, 'o'); }
	|	yD_INFO	    parenE			{ $$ = new AstDisplay($1,AstDisplayType::DT_INFO,    nullptr, nullptr); }
	|	yD_INFO	    '(' exprDispList ')'	{ $$ = new AstDisplay($1,AstDisplayType::DT_INFO,    nullptr, $3); }
	|	yD_WARNING  parenE			{ $$ = new AstDisplay($1,AstDisplayType::DT_WARNING, nullptr, nullptr); }
	|	yD_WARNING  '(' exprDispList ')'	{ $$ = new AstDisplay($1,AstDisplayType::DT_WARNING, nullptr, $3); }
	|	yD_ERROR    parenE			{ $$ = GRAMMARP->createDisplayError($1); }
	|	yD_ERROR    '(' exprDispList ')'	{ $$ = new AstDisplay($1,AstDisplayType::DT_ERROR,   nullptr, $3);   $$->addNext(new AstStop($1, true)); }
	|	yD_FATAL    parenE			{ $$ = new AstDisplay($1,AstDisplayType::DT_FATAL,   nullptr, nullptr); $$->addNext(new AstStop($1, false)); }
	|	yD_FATAL    '(' expr ')'		{ $$ = new AstDisplay($1,AstDisplayType::DT_FATAL,   nullptr, nullptr); $$->addNext(new AstStop($1, false)); DEL($3); }
	|	yD_FATAL    '(' expr ',' exprDispList ')'	{ $$ = new AstDisplay($1,AstDisplayType::DT_FATAL,   nullptr, $5);   $$->addNext(new AstStop($1, false)); DEL($3); }
	//
	|	yD_PRINTTIMESCALE			{ $$ = new AstPrintTimeScale($1); }
	|	yD_PRINTTIMESCALE '(' ')'		{ $$ = new AstPrintTimeScale($1); }
	|	yD_PRINTTIMESCALE '(' idClassSel ')'	{ $$ = new AstPrintTimeScale($1); DEL($3); }
	|	yD_TIMEFORMAT '(' expr ',' expr ',' expr ',' expr ')'	{ $$ = new AstTimeFormat($1, $3, $5, $7, $9); }
	//
	|	yD_READMEMB '(' expr ',' idClassSel ')'				{ $$ = new AstReadMem($1,false,$3,$5,nullptr,nullptr); }
	|	yD_READMEMB '(' expr ',' idClassSel ',' expr ')'		{ $$ = new AstReadMem($1,false,$3,$5,$7,nullptr); }
	|	yD_READMEMB '(' expr ',' idClassSel ',' expr ',' expr ')'	{ $$ = new AstReadMem($1,false,$3,$5,$7,$9); }
	|	yD_READMEMH '(' expr ',' idClassSel ')'				{ $$ = new AstReadMem($1,true, $3,$5,nullptr,nullptr); }
	|	yD_READMEMH '(' expr ',' idClassSel ',' expr ')'		{ $$ = new AstReadMem($1,true, $3,$5,$7,nullptr); }
	|	yD_READMEMH '(' expr ',' idClassSel ',' expr ',' expr ')'	{ $$ = new AstReadMem($1,true, $3,$5,$7,$9); }
	//
	|	yD_WRITEMEMB '(' expr ',' idClassSel ')'			{ $$ = new AstWriteMem($1, false, $3, $5, nullptr, nullptr); }
	|	yD_WRITEMEMB '(' expr ',' idClassSel ',' expr ')'		{ $$ = new AstWriteMem($1, false, $3, $5, $7, nullptr); }
	|	yD_WRITEMEMB '(' expr ',' idClassSel ',' expr ',' expr ')'	{ $$ = new AstWriteMem($1, false, $3, $5, $7, $9); }
	|	yD_WRITEMEMH '(' expr ',' idClassSel ')'			{ $$ = new AstWriteMem($1, true,  $3, $5, nullptr, nullptr); }
	|	yD_WRITEMEMH '(' expr ',' idClassSel ',' expr ')'		{ $$ = new AstWriteMem($1, true,  $3, $5, $7, nullptr); }
	|	yD_WRITEMEMH '(' expr ',' idClassSel ',' expr ',' expr ')'	{ $$ = new AstWriteMem($1, true,  $3, $5, $7, $9); }
	//
	|	yD_CAST '(' expr ',' expr ')'
			{ $$ = new AstAssert($1, new AstCastDynamic($1, $3, $5), nullptr, nullptr, true); }
	//
	// Any system function as a task
	|	system_f_call_or_t			{ $$ = new AstSysFuncAsTask($<fl>1, $1); }
	;

system_f_call<nodep>:		// IEEE: system_tf_call (as func)
		yaD_PLI systemDpiArgsE			{ $$ = new AstFuncRef($<fl>1, *$1, $2); VN_CAST($$, FuncRef)->pli(true); }
	//
	|	yD_C '(' cStrList ')'			{ $$ = (v3Global.opt.ignc() ? nullptr : new AstUCFunc($1,$3)); }
	|	yD_CAST '(' expr ',' expr ')'		{ $$ = new AstCastDynamic($1, $3, $5); }
	|	yD_SYSTEM  '(' expr ')'			{ $$ = new AstSystemF($1,$3); }
	//
	|	system_f_call_or_t			{ $$ = $1; }
	;

systemDpiArgsE<nodep>:		// IEEE: part of system_if_call for aruments of $dpi call
		parenE					{ $$ = nullptr; }
	|	'(' exprList ')'			{ $$ = GRAMMARP->argWrapList($2); }
	;

system_f_call_or_t<nodep>:	// IEEE: part of system_tf_call (can be task or func)
		yD_ACOS '(' expr ')'			{ $$ = new AstAcosD($1,$3); }
	|	yD_ACOSH '(' expr ')'			{ $$ = new AstAcoshD($1,$3); }
	|	yD_ASIN '(' expr ')'			{ $$ = new AstAsinD($1,$3); }
	|	yD_ASINH '(' expr ')'			{ $$ = new AstAsinhD($1,$3); }
	|	yD_ATAN '(' expr ')'			{ $$ = new AstAtanD($1,$3); }
	|	yD_ATAN2 '(' expr ',' expr ')'  	{ $$ = new AstAtan2D($1,$3,$5); }
	|	yD_ATANH '(' expr ')'			{ $$ = new AstAtanhD($1,$3); }
	|	yD_BITS '(' exprOrDataType ')'		{ $$ = new AstAttrOf($1,AstAttrType::DIM_BITS,$3); }
	|	yD_BITS '(' exprOrDataType ',' expr ')'	{ $$ = new AstAttrOf($1,AstAttrType::DIM_BITS,$3,$5); }
	|	yD_BITSTOREAL '(' expr ')'		{ $$ = new AstBitsToRealD($1,$3); }
	|	yD_BITSTOSHORTREAL '(' expr ')'		{ $$ = new AstBitsToRealD($1,$3); UNSUPREAL($1); }
	|	yD_CEIL '(' expr ')'			{ $$ = new AstCeilD($1,$3); }
	|	yD_CHANGED '(' expr ')'			{ $$ = new AstLogNot($1, new AstStable($1, $3)); }
	|	yD_CHANGED '(' expr ',' expr ')'	{ $$ = $3; BBUNSUP($1, "Unsupported: $changed and clock arguments"); }
	|	yD_CLOG2 '(' expr ')'			{ $$ = new AstCLog2($1,$3); }
	|	yD_COS '(' expr ')'			{ $$ = new AstCosD($1,$3); }
	|	yD_COSH '(' expr ')'			{ $$ = new AstCoshD($1,$3); }
	|	yD_COUNTBITS '(' expr ',' expr ')'		{ $$ = new AstCountBits($1,$3,$5); }
	|	yD_COUNTBITS '(' expr ',' expr ',' expr ')'		{ $$ = new AstCountBits($1,$3,$5,$7); }
	|	yD_COUNTBITS '(' expr ',' expr ',' expr ',' expr ')'	{ $$ = new AstCountBits($1,$3,$5,$7,$9); }
	|	yD_COUNTBITS '(' expr ',' expr ',' expr ',' expr ',' exprList ')'
			{ $$ = new AstCountBits($1, $3, $5, $7, $9);
			  BBUNSUP($11, "Unsupported: $countbits with more than 3 control fields"); }
	|	yD_COUNTONES '(' expr ')'		{ $$ = new AstCountOnes($1,$3); }
	|	yD_DIMENSIONS '(' exprOrDataType ')'	{ $$ = new AstAttrOf($1,AstAttrType::DIM_DIMENSIONS,$3); }
	|	yD_EXP '(' expr ')'			{ $$ = new AstExpD($1,$3); }
	|	yD_FELL '(' expr ')'			{ $$ = new AstFell($1,$3); }
	|	yD_FELL '(' expr ',' expr ')'		{ $$ = $3; BBUNSUP($1, "Unsupported: $fell and clock arguments"); }
	|	yD_FEOF '(' expr ')'			{ $$ = new AstFEof($1,$3); }
	|	yD_FERROR '(' idClassSel ',' idClassSel ')'	{ $$ = new AstFError($1, $3, $5); }
	|	yD_FGETC '(' expr ')'			{ $$ = new AstFGetC($1,$3); }
	|	yD_FGETS '(' idClassSel ',' expr ')'	{ $$ = new AstFGetS($1,$3,$5); }
	|	yD_FREAD '(' idClassSel ',' expr ')'	{ $$ = new AstFRead($1,$3,$5,nullptr,nullptr); }
	|	yD_FREAD '(' idClassSel ',' expr ',' expr ')'	{ $$ = new AstFRead($1,$3,$5,$7,nullptr); }
	|	yD_FREAD '(' idClassSel ',' expr ',' expr ',' expr ')'	{ $$ = new AstFRead($1,$3,$5,$7,$9); }
	|	yD_FREWIND '(' idClassSel ')'		{ $$ = new AstFRewind($1, $3); }
	|	yD_FLOOR '(' expr ')'			{ $$ = new AstFloorD($1,$3); }
	|	yD_FSCANF '(' expr ',' str commaVRDListE ')'	{ $$ = new AstFScanF($1,*$5,$3,$6); }
	|	yD_FSEEK '(' idClassSel ',' expr ',' expr ')'	{ $$ = new AstFSeek($1,$3,$5,$7); }
	|	yD_FTELL '(' idClassSel ')'		{ $$ = new AstFTell($1, $3); }
	|	yD_HIGH '(' exprOrDataType ')'		{ $$ = new AstAttrOf($1,AstAttrType::DIM_HIGH,$3,nullptr); }
	|	yD_HIGH '(' exprOrDataType ',' expr ')'	{ $$ = new AstAttrOf($1,AstAttrType::DIM_HIGH,$3,$5); }
	|	yD_HYPOT '(' expr ',' expr ')'		{ $$ = new AstHypotD($1,$3,$5); }
	|	yD_INCREMENT '(' exprOrDataType ')'	{ $$ = new AstAttrOf($1,AstAttrType::DIM_INCREMENT,$3,nullptr); }
	|	yD_INCREMENT '(' exprOrDataType ',' expr ')'	{ $$ = new AstAttrOf($1,AstAttrType::DIM_INCREMENT,$3,$5); }
	|	yD_ISUNBOUNDED '(' expr ')'		{ $$ = new AstIsUnbounded($1, $3); }
	|	yD_ISUNKNOWN '(' expr ')'		{ $$ = new AstIsUnknown($1, $3); }
	|	yD_ITOR '(' expr ')'			{ $$ = new AstIToRD($1,$3); }
	|	yD_LEFT '(' exprOrDataType ')'		{ $$ = new AstAttrOf($1,AstAttrType::DIM_LEFT,$3,nullptr); }
	|	yD_LEFT '(' exprOrDataType ',' expr ')'	{ $$ = new AstAttrOf($1,AstAttrType::DIM_LEFT,$3,$5); }
	|	yD_LN '(' expr ')'			{ $$ = new AstLogD($1,$3); }
	|	yD_LOG10 '(' expr ')'			{ $$ = new AstLog10D($1,$3); }
	|	yD_LOW '(' exprOrDataType ')'		{ $$ = new AstAttrOf($1,AstAttrType::DIM_LOW,$3,nullptr); }
	|	yD_LOW '(' exprOrDataType ',' expr ')'	{ $$ = new AstAttrOf($1,AstAttrType::DIM_LOW,$3,$5); }
	|	yD_ONEHOT '(' expr ')'			{ $$ = new AstOneHot($1,$3); }
	|	yD_ONEHOT0 '(' expr ')'			{ $$ = new AstOneHot0($1,$3); }
	|	yD_PAST '(' expr ')'			{ $$ = new AstPast($1,$3, nullptr); }
	|	yD_PAST '(' expr ',' expr ')'		{ $$ = new AstPast($1,$3, $5); }
	|	yD_PAST '(' expr ',' expr ',' expr ')'		{ $$ = $3; BBUNSUP($1, "Unsupported: $past expr2 and clock arguments"); }
	|	yD_PAST '(' expr ',' expr ',' expr ',' expr')'	{ $$ = $3; BBUNSUP($1, "Unsupported: $past expr2 and clock arguments"); }
	|	yD_POW '(' expr ',' expr ')'		{ $$ = new AstPowD($1,$3,$5); }
	|	yD_RANDOM '(' expr ')'			{ $$ = new AstRand($1, $3, false); }
	|	yD_RANDOM parenE			{ $$ = new AstRand($1, nullptr, false); }
	|	yD_REALTIME parenE			{ $$ = new AstTimeD($1, VTimescale(VTimescale::NONE)); }
	|	yD_REALTOBITS '(' expr ')'		{ $$ = new AstRealToBits($1,$3); }
	|	yD_REWIND '(' idClassSel ')'		{ $$ = new AstFSeek($1, $3, new AstConst($1, 0), new AstConst($1, 0)); }
	|	yD_RIGHT '(' exprOrDataType ')'		{ $$ = new AstAttrOf($1,AstAttrType::DIM_RIGHT,$3,nullptr); }
	|	yD_RIGHT '(' exprOrDataType ',' expr ')'	{ $$ = new AstAttrOf($1,AstAttrType::DIM_RIGHT,$3,$5); }
	|	yD_ROSE '(' expr ')'			{ $$ = new AstRose($1,$3); }
	|	yD_ROSE '(' expr ',' expr ')'		{ $$ = $3; BBUNSUP($1, "Unsupported: $rose and clock arguments"); }
	|	yD_RTOI '(' expr ')'			{ $$ = new AstRToIS($1,$3); }
	|	yD_SAMPLED '(' expr ')'			{ $$ = new AstSampled($1, $3); }
	|	yD_SFORMATF '(' exprDispList ')'	{ $$ = new AstSFormatF($1, AstSFormatF::NoFormat(), $3, 'd', false); }
	|	yD_SHORTREALTOBITS '(' expr ')'		{ $$ = new AstRealToBits($1,$3); UNSUPREAL($1); }
	|	yD_SIGNED '(' expr ')'			{ $$ = new AstSigned($1,$3); }
	|	yD_SIN '(' expr ')'			{ $$ = new AstSinD($1,$3); }
	|	yD_SINH '(' expr ')'			{ $$ = new AstSinhD($1,$3); }
	|	yD_SIZE '(' exprOrDataType ')'		{ $$ = new AstAttrOf($1,AstAttrType::DIM_SIZE,$3,nullptr); }
	|	yD_SIZE '(' exprOrDataType ',' expr ')'	{ $$ = new AstAttrOf($1,AstAttrType::DIM_SIZE,$3,$5); }
	|	yD_SQRT '(' expr ')'			{ $$ = new AstSqrtD($1,$3); }
	|	yD_SSCANF '(' expr ',' str commaVRDListE ')'	{ $$ = new AstSScanF($1,*$5,$3,$6); }
	|	yD_STIME parenE				{ $$ = new AstSel($1, new AstTime($1, VTimescale(VTimescale::NONE)), 0, 32); }
	|	yD_STABLE '(' expr ')'			{ $$ = new AstStable($1,$3); }
	|	yD_STABLE '(' expr ',' expr ')'		{ $$ = $3; BBUNSUP($1, "Unsupported: $stable and clock arguments"); }
	|	yD_TAN '(' expr ')'			{ $$ = new AstTanD($1,$3); }
	|	yD_TANH '(' expr ')'			{ $$ = new AstTanhD($1,$3); }
	|	yD_TESTPLUSARGS '(' str ')'		{ $$ = new AstTestPlusArgs($1,*$3); }
	|	yD_TIME	parenE				{ $$ = new AstTime($1, VTimescale(VTimescale::NONE)); }
	|	yD_TYPENAME '(' exprOrDataType ')'	{ $$ = new AstAttrOf($1, AstAttrType::TYPENAME, $3); }
	|	yD_UNGETC '(' expr ',' expr ')'		{ $$ = new AstFUngetC($1, $5, $3); }  // Arg swap to file first
	|	yD_UNPACKED_DIMENSIONS '(' exprOrDataType ')'	{ $$ = new AstAttrOf($1,AstAttrType::DIM_UNPK_DIMENSIONS,$3); }
	|	yD_UNSIGNED '(' expr ')'		{ $$ = new AstUnsigned($1, $3); }
	|	yD_URANDOM '(' expr ')'			{ $$ = new AstRand($1, $3, true); }
	|	yD_URANDOM parenE			{ $$ = new AstRand($1, nullptr, true); }
	|	yD_URANDOM_RANGE '(' expr ',' expr ')'	{ $$ = new AstURandomRange($1, $3, $5); }
	|	yD_VALUEPLUSARGS '(' expr ',' expr ')'	{ $$ = new AstValuePlusArgs($1, $3, $5); }
	;

elaboration_system_task<nodep>:	// IEEE: elaboration_system_task (1800-2009)
	//			// TODO: These currently just make initial statements, should instead give runtime error
		elaboration_system_task_guts ';'	{ $$ = new AstInitial($<fl>1, $1); }
	;

elaboration_system_task_guts<nodep>:	// IEEE: part of elaboration_system_task (1800-2009)
	//			// $fatal first argument is exit number, must be constant
		yD_INFO	   parenE			{ $$ = new AstElabDisplay($1, AstDisplayType::DT_INFO, nullptr); }
	|	yD_INFO	   '(' exprList ')'		{ $$ = new AstElabDisplay($1, AstDisplayType::DT_INFO, $3); }
	|	yD_WARNING parenE			{ $$ = new AstElabDisplay($1, AstDisplayType::DT_WARNING, nullptr); }
	|	yD_WARNING '(' exprList ')'		{ $$ = new AstElabDisplay($1, AstDisplayType::DT_WARNING, $3); }
	|	yD_ERROR   parenE			{ $$ = new AstElabDisplay($1, AstDisplayType::DT_ERROR, nullptr); }
	|	yD_ERROR   '(' exprList ')'		{ $$ = new AstElabDisplay($1, AstDisplayType::DT_ERROR, $3); }
	|	yD_FATAL   parenE			{ $$ = new AstElabDisplay($1, AstDisplayType::DT_FATAL, nullptr); }
	|	yD_FATAL   '(' expr ')'			{ $$ = new AstElabDisplay($1, AstDisplayType::DT_FATAL, nullptr); DEL($3); }
	|	yD_FATAL   '(' expr ',' exprListE ')'	{ $$ = new AstElabDisplay($1, AstDisplayType::DT_FATAL, $5); DEL($3); }
	;

//UNSUPproperty_actual_arg<nodep>:  // ==IEEE: property_actual_arg
//UNSUP	//			// IEEE: property_expr
//UNSUP	//			// IEEE: sequence_actual_arg
//UNSUP		pev_expr				{ $$ = $1; }
//UNSUP	//			// IEEE: sequence_expr
//UNSUP	//			// property_expr already includes sequence_expr
//UNSUP	;

exprOrDataType<nodep>:		// expr | data_type: combined to prevent conflicts
		expr					{ $$ = $1; }
	//			// data_type includes id that overlaps expr, so special flavor
	|	data_type				{ $$ = $1; }
	//			// not in spec, but needed for $past(sig,1,,@(posedge clk))
	//UNSUP	event_control				{ }
	;

//UNSUPexprOrDataTypeOrMinTypMax<nodep>:  // exprOrDataType or mintypmax_expression
//UNSUP		expr					{ $$ = $1; }
//UNSUP	|	expr ':' expr ':' expr			{ $$ = $3; }
//UNSUP	//			// data_type includes id that overlaps expr, so special flavor
//UNSUP	|	data_type				{ $$ = $1; }
//UNSUP	//			// not in spec, but needed for $past(sig,1,,@(posedge clk))
//UNSUP	|	event_control				{ $$ = $1; }
//UNSUP	;

//UNSUPexprOrDataTypeList<nodep>:
//UNSUP		exprOrDataType				{ $$ = $1; }
//UNSUP	|	exprOrDataTypeList ',' exprOrDataType	{ $$ = AstNode::addNextNull($1, $3); }
//UNSUP	;

list_of_argumentsE<nodep>:	// IEEE: [list_of_arguments]
		argsDottedList				{ $$ = $1; }
	|	argsExprListE
			{ if (VN_IS($1, Arg) && VN_CAST($1, Arg)->emptyConnectNoNext()) {
			      $1->deleteTree(); $$ = nullptr;  // Mis-created when have 'func()'
			  } else { $$ = $1; } }
	|	argsExprListE ',' argsDottedList	{ $$ = $1->addNextNull($3); }
	;

task_declaration<ftaskp>:	// ==IEEE: task_declaration
		yTASK lifetimeE taskId tfGuts yENDTASK endLabelE
			{ $$ = $3; $$->addStmtsp($4); SYMP->popScope($$);
			  $$->lifetime($2);
			  GRAMMARP->endLabel($<fl>6,$$,$6); }
	;

task_prototype<ftaskp>:		// ==IEEE: task_prototype
		yTASK taskId '(' tf_port_listE ')'	{ $$=$2; $$->addStmtsp($4); $$->prototype(true); SYMP->popScope($$); }
	|	yTASK taskId				{ $$=$2; $$->prototype(true); SYMP->popScope($$); }
	;

function_declaration<ftaskp>:	// IEEE: function_declaration + function_body_declaration
		yFUNCTION lifetimeE funcId funcIsolateE tfGuts yENDFUNCTION endLabelE
			{ $$ = $3; $3->attrIsolateAssign($4); $$->addStmtsp($5);
			  $$->lifetime($2);
			  SYMP->popScope($$);
			  GRAMMARP->endLabel($<fl>7,$$,$7); }
	| 	yFUNCTION lifetimeE funcIdNew funcIsolateE tfGuts yENDFUNCTION endLabelE
			{ $$ = $3; $3->attrIsolateAssign($4); $$->addStmtsp($5);
			  $$->lifetime($2);
			  SYMP->popScope($$);
			  GRAMMARP->endLabel($<fl>7,$$,$7); }
	;

function_prototype<ftaskp>:	// IEEE: function_prototype
		yFUNCTION funcId '(' tf_port_listE ')'	{ $$=$2; $$->addStmtsp($4); $$->prototype(true); SYMP->popScope($$); }
	|	yFUNCTION funcId			{ $$=$2; $$->prototype(true); SYMP->popScope($$); }
	;

class_constructor_prototype<ftaskp>:	// ==IEEE: class_constructor_prototype
		yFUNCTION funcIdNew '(' tf_port_listE ')' ';'	{ $$ = $2; $$->addStmtsp($4); $$->prototype(true); SYMP->popScope($$); }
	|	yFUNCTION funcIdNew ';'				{ $$ = $2; $$->prototype(true); SYMP->popScope($$); }
	;

funcIsolateE<cint>:
		/* empty */		 		{ $$ = 0; }
	|	yVL_ISOLATE_ASSIGNMENTS			{ $$ = 1; }
	;

method_prototype<ftaskp>:
		task_prototype				{ $$ = $1; }
	|	function_prototype			{ $$ = $1; }
	;

lifetimeE<lifetime>:		// IEEE: [lifetime]
		/* empty */		 		{ $$ = VLifetime::NONE; }
	|	lifetime		 		{ $$ = $1; }
	;

lifetime<lifetime>:		// ==IEEE: lifetime
	//			// Note lifetime used by members is instead under memberQual
		ySTATIC__ETC		 		{ $$ = VLifetime::STATIC; }
	|	yAUTOMATIC		 		{ $$ = VLifetime::AUTOMATIC; }
	;

taskId<ftaskp>:
		id
			{ $$ = new AstTask($<fl>$, *$1, nullptr);
			  SYMP->pushNewUnderNodeOrCurrent($$, nullptr); }
	//
	|	id/*interface_identifier*/ '.' id
			{ $$ = new AstTask($<fl>$, *$3, nullptr);
			  BBUNSUP($2, "Unsupported: Out of block function declaration");
			  SYMP->pushNewUnderNodeOrCurrent($$, nullptr); }
	//
	|	packageClassScope id
			{ $$ = new AstTask($<fl>$, *$2, nullptr);
			  $$->classOrPackagep($1);
			  SYMP->pushNewUnderNodeOrCurrent($$, $<scp>1); }
	;

funcId<ftaskp>:			// IEEE: function_data_type_or_implicit + part of function_body_declaration
	//			// IEEE: function_data_type_or_implicit must be expanded here to prevent conflict
	//			// function_data_type expanded here to prevent conflicts with implicit_type:empty vs data_type:ID
		/**/ fIdScoped
			{ $$ = $1;
			  $$->addFvarp(new AstBasicDType($<fl>1, LOGIC_IMPLICIT));
			  SYMP->pushNewUnderNodeOrCurrent($$, $<scp>1); }
	|	signingE rangeList fIdScoped
			{ $$ = $3;
			  $$->addFvarp(GRAMMARP->addRange(new AstBasicDType($<fl>3, LOGIC_IMPLICIT, $1), $2,true));
			  SYMP->pushNewUnderNodeOrCurrent($$, $<scp>3); }
	|	signing	fIdScoped
			{ $$ = $2;
			  $$->addFvarp(new AstBasicDType($<fl>2, LOGIC_IMPLICIT, $1));
			  SYMP->pushNewUnderNodeOrCurrent($$, $<scp>2); }
	|	data_type fIdScoped
			{ $$ = $2;
			  $$->addFvarp($1);
			  SYMP->pushNewUnderNodeOrCurrent($$, $<scp>2); }
	//			// To verilator tasks are the same as void functions (we separately detect time passing)
	|	yVOID taskId
			{ $$ = $2; }
	;

funcIdNew<ftaskp>:		// IEEE: from class_constructor_declaration
		yNEW__ETC
			{ $$ = new AstFunc($<fl>1, "new", nullptr, nullptr);
			  $$->isConstructor(true);
			  SYMP->pushNewUnder($$, nullptr); }
	| 	yNEW__PAREN
			{ $$ = new AstFunc($<fl>1, "new", nullptr, nullptr);
			  $$->isConstructor(true);
			  SYMP->pushNewUnder($$, nullptr); }
	|	packageClassScopeNoId yNEW__PAREN
			{ $$ = new AstFunc($<fl>2, "new", nullptr, nullptr);
			  $$->classOrPackagep($1);
			  $$->isConstructor(true);
			  SYMP->pushNewUnderNodeOrCurrent($$, $<scp>1); }
	;

fIdScoped<funcp>:		// IEEE: part of function_body_declaration/task_body_declaration
 	//			// IEEE: [ interface_identifier '.' | class_scope ] function_identifier
		id
			{ $<fl>$ = $<fl>1;
			  $<scp>$ = nullptr;
                          $$ = new AstFunc($<fl>$, *$1, nullptr, nullptr); }
	//
	|	id/*interface_identifier*/ '.' id
			{ $<fl>$ = $<fl>1;
			  $<scp>$ = nullptr;
                          $$ = new AstFunc($<fl>$, *$1, nullptr, nullptr);
			  BBUNSUP($2, "Unsupported: Out of block function declaration"); }
	//
	|	packageClassScope id
			{ $<fl>$ = $<fl>1;
			  $<scp>$ = $<scp>1;
			  $$ = new AstFunc($<fl>$, *$2, nullptr, nullptr);
			  $$->classOrPackagep($1); }
	;

tfGuts<nodep>:
		'(' tf_port_listE ')' ';' tfBodyE	{ $$ = $2->addNextNull($5); }
	|	';' tfBodyE				{ $$ = $2; }
	;

tfBodyE<nodep>:			// IEEE: part of function_body_declaration/task_body_declaration
		/* empty */				{ $$ = nullptr; }
	|	tf_item_declarationList			{ $$ = $1; }
	|	tf_item_declarationList stmtList	{ $$ = $1->addNextNull($2); }
	|	stmtList				{ $$ = $1; }
	;

tf_item_declarationList<nodep>:
		tf_item_declaration			{ $$ = $1; }
	|	tf_item_declarationList tf_item_declaration	{ $$ = $1->addNextNull($2); }
	;

tf_item_declaration<nodep>:	// ==IEEE: tf_item_declaration
		block_item_declaration			{ $$ = $1; }
	|	tf_port_declaration			{ $$ = $1; }
	|	tf_item_declarationVerilator		{ $$ = $1; }
	;

tf_item_declarationVerilator<nodep>:	// Verilator extensions
		yVL_PUBLIC				{ $$ = new AstPragma($1,AstPragmaType::PUBLIC_TASK); v3Global.dpi(true); }
	|	yVL_NO_INLINE_TASK			{ $$ = new AstPragma($1,AstPragmaType::NO_INLINE_TASK); }
	;

tf_port_listE<nodep>:		// IEEE: tf_port_list + empty
	//			// Empty covered by tf_port_item
		/*empty*/
	/*mid*/		{ VARRESET_LIST(UNKNOWN); VARIO(INPUT); }
	/*cont*/    tf_port_listList			{ $$ = $2; VARRESET_NONLIST(UNKNOWN); }
	;

tf_port_listList<nodep>:	// IEEE: part of tf_port_list
		tf_port_item				{ $$ = $1; }
	|	tf_port_listList ',' tf_port_item	{ $$ = $1->addNextNull($3); }
	;

tf_port_item<nodep>:		// ==IEEE: tf_port_item
	//			// We split tf_port_item into the type and assignment as don't know what follows a comma
		/* empty */				{ $$ = nullptr; PINNUMINC(); }	// For example a ",," port
	|	tf_port_itemFront tf_port_itemAssignment { $$ = $2; }
	|	tf_port_itemAssignment 			{ $$ = $1; }
	;

tf_port_itemFront:		// IEEE: part of tf_port_item, which has the data type
		data_type				{ VARDTYPE($1); }
	|	signingE rangeList			{ VARDTYPE(GRAMMARP->addRange(new AstBasicDType($2->fileline(), LOGIC_IMPLICIT, $1), $2, true)); }
	|	signing					{ VARDTYPE(new AstBasicDType($<fl>1, LOGIC_IMPLICIT, $1)); }
	|	yVAR data_type				{ VARDTYPE($2); }
	|	yVAR implicit_typeE			{ VARDTYPE($2); }
	//
	|	tf_port_itemDir /*implicit*/		{ VARDTYPE(nullptr); /*default_nettype-see spec*/ }
	|	tf_port_itemDir data_type		{ VARDTYPE($2); }
	|	tf_port_itemDir signingE rangeList	{ VARDTYPE(GRAMMARP->addRange(new AstBasicDType($3->fileline(), LOGIC_IMPLICIT, $2),$3,true)); }
	|	tf_port_itemDir signing			{ VARDTYPE(new AstBasicDType($<fl>2, LOGIC_IMPLICIT, $2)); }
	|	tf_port_itemDir yVAR data_type		{ VARDTYPE($3); }
	|	tf_port_itemDir yVAR implicit_typeE	{ VARDTYPE($3); }
	;

tf_port_itemDir:		// IEEE: part of tf_port_item, direction
		port_direction				{ }  // port_direction sets VARIO
	;

tf_port_itemAssignment<varp>:	// IEEE: part of tf_port_item, which has assignment
		id variable_dimensionListE sigAttrListE exprEqE
			{ $$ = VARDONEA($<fl>1, *$1, $2, $3); if ($4) $$->valuep($4); }
	;

parenE:
		/* empty */				{ }
	|	'(' ')'					{ }
	;

//	method_call:		// ==IEEE: method_call + method_call_body
//				// IEEE: method_call_root '.' method_identifier [ '(' list_of_arguments ')' ]
//				//   "method_call_root '.' method_identifier" looks just like "expr '.' id"
//				//   "method_call_root '.' method_identifier (...)" looks just like "expr '.' tf_call"
//				// IEEE: built_in_method_call
//				//   method_call_root not needed, part of expr resolution
//				// What's left is below array_methodNoRoot
array_methodNoRoot<ftaskrefp>:
		yOR					{ $$ = new AstFuncRef($1, "or", nullptr); }
	|	yAND					{ $$ = new AstFuncRef($1, "and", nullptr); }
	|	yXOR					{ $$ = new AstFuncRef($1, "xor", nullptr); }
	|	yUNIQUE					{ $$ = new AstFuncRef($1, "unique", nullptr); }
	;

array_methodWith<nodep>:
		array_methodNoRoot			{ $$ = $1; }
	|	array_methodNoRoot parenE yWITH__PAREN '(' expr ')'
			{ $$ = new AstWithParse($3, false, $1, $5); }
	|	array_methodNoRoot '(' expr ')' yWITH__PAREN '(' expr ')'
			{ $$ = new AstWithParse($5, false, $1, $7); $1->addPinsp(new AstArg($<fl>3, "", $3)); }
	;

dpi_import_export<nodep>:	// ==IEEE: dpi_import_export
		yIMPORT yaSTRING dpi_tf_import_propertyE dpi_importLabelE function_prototype ';'
			{ $$ = $5; if (*$4 != "") $5->cname(*$4);
			  $5->dpiContext($3==iprop_CONTEXT); $5->pure($3==iprop_PURE);
			  $5->dpiImport(true); GRAMMARP->checkDpiVer($1,*$2); v3Global.dpi(true);
			  if ($$->prettyName()[0]=='$') SYMP->reinsert($$,nullptr,$$->prettyName());  // For $SysTF overriding
			  SYMP->reinsert($$); }
	|	yIMPORT yaSTRING dpi_tf_import_propertyE dpi_importLabelE task_prototype ';'
			{ $$ = $5; if (*$4 != "") $5->cname(*$4);
			  $5->dpiContext($3==iprop_CONTEXT); $5->pure($3==iprop_PURE);
			  $5->dpiImport(true); $5->dpiTask(true); GRAMMARP->checkDpiVer($1,*$2); v3Global.dpi(true);
			  if ($$->prettyName()[0]=='$') SYMP->reinsert($$,nullptr,$$->prettyName());  // For $SysTF overriding
			  SYMP->reinsert($$); }
	|	yEXPORT yaSTRING dpi_importLabelE yFUNCTION idAny ';'
			{ $$ = new AstDpiExport($<fl>5, *$5, *$3);
			  GRAMMARP->checkDpiVer($1, *$2); v3Global.dpi(true); }
	|	yEXPORT yaSTRING dpi_importLabelE yTASK     idAny ';'
			{ $$ = new AstDpiExport($<fl>5, *$5, *$3);
			  GRAMMARP->checkDpiVer($1, *$2); v3Global.dpi(true); }
	;

dpi_importLabelE<strp>:		// IEEE: part of dpi_import_export
		/* empty */				{ static string s; $$ = &s; }
	|	idAny/*c_identifier*/ '='		{ $$ = $1; $<fl>$=$<fl>1; }
	;

dpi_tf_import_propertyE<iprop>:	// IEEE: [ dpi_function_import_property + dpi_task_import_property ]
		/* empty */				{ $$ = iprop_NONE; }
	|	yCONTEXT				{ $$ = iprop_CONTEXT; }
	|	yPURE					{ $$ = iprop_PURE; }
	;

//************************************************
// Expressions
//
// ~l~ means this is the (l)eft hand side of any operator
//     it will get replaced by "", "f" or "s"equence
// ~r~ means this is a (r)ight hand later expansion in the same statement,
//     not under parenthesis for <= disambiguation
//     it will get replaced by "", or "f"
// ~p~ means this is a (p)arenthetized expression
//     it will get replaced by "", or "s"equence

exprEqE<nodep>:			// IEEE: optional '=' expression (part of param_assignment)
	//			// constant_param_expression: '$' is in expr
		/*empty*/				{ $$ = nullptr; }
	|	'=' expr				{ $$ = $2; }
	;

exprOrDataTypeEqE<nodep>:	// IEEE: optional '=' expression (part of param_assignment)
	//			// constant_param_expression: '$' is in expr
		/*empty*/				{ $$ = nullptr; }
	|	'=' exprOrDataType			{ $$ = $2; }
	;

constExpr<nodep>:
		expr					{ $$ = $1; }
	;

expr<nodep>:			// IEEE: part of expression/constant_expression/primary
	// *SEE BELOW*		// IEEE: primary/constant_primary
	//
	//			// IEEE: unary_operator primary
		'+' ~r~expr	%prec prUNARYARITH	{ $$ = $2; }
	|	'-' ~r~expr	%prec prUNARYARITH	{ $$ = new AstNegate	($1,$2); }
	|	'!' ~r~expr	%prec prNEGATION	{ $$ = new AstLogNot	($1,$2); }
	|	'&' ~r~expr	%prec prREDUCTION	{ $$ = new AstRedAnd	($1,$2); }
	|	'~' ~r~expr	%prec prNEGATION	{ $$ = new AstNot	($1,$2); }
	|	'|' ~r~expr	%prec prREDUCTION	{ $$ = new AstRedOr	($1,$2); }
	|	'^' ~r~expr	%prec prREDUCTION	{ $$ = new AstRedXor	($1,$2); }
	|	yP_NAND ~r~expr	%prec prREDUCTION	{ $$ = new AstLogNot($1, new AstRedAnd($1, $2)); }
	|	yP_NOR  ~r~expr	%prec prREDUCTION	{ $$ = new AstLogNot($1, new AstRedOr($1, $2)); }
	|	yP_XNOR ~r~expr	%prec prREDUCTION	{ $$ = new AstRedXnor	($1,$2); }
	//
	//			// IEEE: inc_or_dec_expression
	|	~l~inc_or_dec_expression		{ $<fl>$=$<fl>1; $$ = $1; }
	//
	//			// IEEE: '(' operator_assignment ')'
	//			// Need exprScope of variable_lvalue to prevent conflict
	//UNSUP	'(' ~p~exprScope '=' 	      expr ')'	{ UNSUP }
	//UNSUP	'(' ~p~exprScope yP_PLUSEQ    expr ')'	{ UNSUP }
	//UNSUP	'(' ~p~exprScope yP_MINUSEQ   expr ')'	{ UNSUP }
	//UNSUP	'(' ~p~exprScope yP_TIMESEQ   expr ')'	{ UNSUP }
	//UNSUP	'(' ~p~exprScope yP_DIVEQ     expr ')'	{ UNSUP }
	//UNSUP	'(' ~p~exprScope yP_MODEQ     expr ')'	{ UNSUP }
	//UNSUP	'(' ~p~exprScope yP_ANDEQ     expr ')'	{ UNSUP }
	//UNSUP	'(' ~p~exprScope yP_OREQ      expr ')'	{ UNSUP }
	//UNSUP	'(' ~p~exprScope yP_XOREQ     expr ')'	{ UNSUP }
	//UNSUP	'(' ~p~exprScope yP_SLEFTEQ   expr ')'	{ UNSUP }
	//UNSUP	'(' ~p~exprScope yP_SRIGHTEQ  expr ')'	{ UNSUP }
	//UNSUP	'(' ~p~exprScope yP_SSRIGHTEQ expr ')'	{ UNSUP }
	//
	//			// IEEE: expression binary_operator expression
	|	~l~expr '+' ~r~expr			{ $$ = new AstAdd	($2,$1,$3); }
	|	~l~expr '-' ~r~expr			{ $$ = new AstSub	($2,$1,$3); }
	|	~l~expr '*' ~r~expr			{ $$ = new AstMul	($2,$1,$3); }
	|	~l~expr '/' ~r~expr			{ $$ = new AstDiv	($2,$1,$3); }
	|	~l~expr '%' ~r~expr			{ $$ = new AstModDiv	($2,$1,$3); }
	|	~l~expr yP_EQUAL ~r~expr		{ $$ = new AstEq	($2,$1,$3); }
	|	~l~expr yP_NOTEQUAL ~r~expr		{ $$ = new AstNeq	($2,$1,$3); }
	|	~l~expr yP_CASEEQUAL ~r~expr		{ $$ = new AstEqCase	($2,$1,$3); }
	|	~l~expr yP_CASENOTEQUAL ~r~expr		{ $$ = new AstNeqCase	($2,$1,$3); }
	|	~l~expr yP_WILDEQUAL ~r~expr		{ $$ = new AstEqWild	($2,$1,$3); }
	|	~l~expr yP_WILDNOTEQUAL ~r~expr		{ $$ = new AstNeqWild	($2,$1,$3); }
	|	~l~expr yP_ANDAND ~r~expr		{ $$ = new AstLogAnd	($2,$1,$3); }
	|	~l~expr yP_OROR ~r~expr			{ $$ = new AstLogOr	($2,$1,$3); }
	|	~l~expr yP_POW ~r~expr			{ $$ = new AstPow	($2,$1,$3); }
	|	~l~expr '<' ~r~expr			{ $$ = new AstLt	($2,$1,$3); }
	|	~l~expr '>' ~r~expr			{ $$ = new AstGt	($2,$1,$3); }
	|	~l~expr yP_GTE ~r~expr			{ $$ = new AstGte	($2,$1,$3); }
	|	~l~expr '&' ~r~expr			{ $$ = new AstAnd	($2,$1,$3); }
	|	~l~expr '|' ~r~expr			{ $$ = new AstOr	($2,$1,$3); }
	|	~l~expr '^' ~r~expr			{ $$ = new AstXor	($2,$1,$3); }
	|	~l~expr yP_XNOR ~r~expr			{ $$ = new AstXnor	($2,$1,$3); }
	|	~l~expr yP_NOR ~r~expr			{ $$ = new AstNot($2,new AstOr	($2,$1,$3)); }
	|	~l~expr yP_NAND ~r~expr			{ $$ = new AstNot($2,new AstAnd	($2,$1,$3)); }
	|	~l~expr yP_SLEFT ~r~expr		{ $$ = new AstShiftL	($2,$1,$3); }
	|	~l~expr yP_SRIGHT ~r~expr		{ $$ = new AstShiftR	($2,$1,$3); }
	|	~l~expr yP_SSRIGHT ~r~expr		{ $$ = new AstShiftRS	($2,$1,$3); }
	|	~l~expr yP_LTMINUSGT ~r~expr		{ $$ = new AstLogEq     ($2,$1,$3); }
	//
	//			// IEEE: expr yP_MINUSGT expr  (1800-2009)
	//			// Conflicts with constraint_expression:"expr yP_MINUSGT constraint_set"
	//			// To duplicating expr for constraints, just allow the more general form
	//			// Later Ast processing must ignore constraint terms where inappropriate
	//UNSUP	~l~expr yP_MINUSGT constraint_set		{ $<fl>$=$<fl>1; $$ = $1+$2+$3; }
	//UNSUP remove line below
	|	~l~expr yP_MINUSGT ~r~expr		{ $$ = new AstLogIf($2, $1, $3); }
	//
	//			// <= is special, as we need to disambiguate it with <= assignment
	//			// We copy all of expr to fexpr and rename this token to a fake one.
	|	~l~expr yP_LTE~f__IGNORE~ ~r~expr	{ $$ = new AstLte($2, $1, $3); }
	//
	//			// IEEE: conditional_expression
	|	~l~expr '?' ~r~expr ':' ~r~expr		{ $$ = new AstCond($2,$1,$3,$5); }
	//
	//			// IEEE: inside_expression
	|	~l~expr yINSIDE '{' open_range_list '}'	{ $$ = new AstInside($2,$1,$4); }
	//
	//			// IEEE: tagged_union_expression
	//UNSUP	yTAGGED id/*member*/ %prec prTAGGED		{ UNSUP }
	//UNSUP	yTAGGED id/*member*/ %prec prTAGGED expr	{ UNSUP }
	//
	//======================// IEEE: primary/constant_primary
	//
	//			// IEEE: primary_literal (minus string, which is handled specially)
	|	yaINTNUM				{ $$ = new AstConst($<fl>1,*$1); }
	|	yaFLOATNUM				{ $$ = new AstConst($<fl>1,AstConst::RealDouble(),$1); }
	|	timeNumAdjusted				{ $$ = $1; }
	|	strAsInt~noStr__IGNORE~			{ $$ = $1; }
	//
	//			// IEEE: "... hierarchical_identifier select"  see below
	//
	//			// IEEE: empty_queue (IEEE 1800-2017 empty_unpacked_array_concatenation)
	|	'{' '}'					{ $$ = new AstConst($1, AstConst::LogicFalse());
							  BBUNSUP($<fl>1, "Unsupported: empty queues (\"{ }\")"); }
	//
	//			// IEEE: concatenation/constant_concatenation
	//			// Part of exprOkLvalue below
	//
	//			// IEEE: multiple_concatenation/constant_multiple_concatenation
	|	'{' constExpr '{' cateList '}' '}'	{ $$ = new AstReplicate($3, $4, $2); }
	//			// UNSUP some other rules above
	//
	|	function_subroutine_callNoMethod	{ $$ = $1; }
	//			// method_call
	|	~l~expr '.' function_subroutine_callNoMethod	{ $$ = new AstDot($2, false, $1, $3); }
	//			// method_call:array_method requires a '.'
	|	~l~expr '.' array_methodWith		{ $$ = new AstDot($2, false, $1, $3); }
	//
	//			// IEEE: let_expression
	//			// see funcRef
	//
	//			// IEEE: '(' mintypmax_expression ')'
	|	~noPar__IGNORE~'(' expr ')'		{ $$ = $2; }
	|	~noPar__IGNORE~'(' expr ':' expr ':' expr ')'	{ $$ = $2; BBUNSUP($1, "Unsupported: min typ max expressions"); }
	//			// PSL rule
	|	'_' '(' expr ')'			{ $$ = $3; }	// Arbitrary Verilog inside PSL
	//
	//			// IEEE: cast/constant_cast
	//			// expanded from casting_type
	|	simple_type yP_TICK '(' expr ')'	{ $$ = new AstCast($1->fileline(), $4, $1); }
	|	ySIGNED yP_TICK '(' expr ')'		{ $$ = new AstSigned($1, $4); }
	|	yUNSIGNED yP_TICK '(' expr ')'		{ $$ = new AstUnsigned($1, $4); }
	|	ySTRING yP_TICK '(' expr ')'		{ $$ = new AstCvtPackString($1, $4); }
	|	yCONST__ETC yP_TICK '(' expr ')'	{ $$ = $4; }  // Not linting const presently
	//			// Spec only allows primary with addition of a type reference
	//			// We'll be more general, and later assert LHS was a type.
	|	~l~expr yP_TICK '(' expr ')'		{ $$ = new AstCastParse($2,$4,$1); }
	//
	//			// IEEE: assignment_pattern_expression
	//			// IEEE: streaming_concatenation
	//			// See exprOkLvalue
	//
	//			// IEEE: sequence_method_call
	//			// Indistinguishable from function_subroutine_call:method_call
	//
	|	'$'					{ $$ = new AstUnbounded($<fl>1); }
	|	yNULL					{ $$ = new AstConst($1, AstConst::StringToParse(), "'0"); }
	//			// IEEE: yTHIS
	//			// See exprScope
	//
	//----------------------
	//
	//			// Part of expr that may also be used as lvalue
	|	~l~exprOkLvalue				{ $$ = $1; }
	//
	//----------------------
	//
	//			// IEEE: cond_predicate - here to avoid reduce problems
	//			// Note expr includes cond_pattern
	|	~l~expr yP_ANDANDAND ~r~expr		{ $$ = new AstConst($2, AstConst::LogicFalse());
							  BBUNSUP($<fl>2, "Unsupported: &&& expression"); }
	//
	//			// IEEE: cond_pattern - here to avoid reduce problems
	//			// "expr yMATCHES pattern"
	//			// IEEE: pattern - expanded here to avoid conflicts
	//UNSUP	~l~expr yMATCHES patternNoExpr		{ UNSUP }
	//UNSUP	~l~expr yMATCHES ~r~expr		{ UNSUP }
	//
	//			// IEEE: expression_or_dist - here to avoid reduce problems
	//			// "expr yDIST '{' dist_list '}'"
	|	~l~expr yDIST '{' dist_list '}'		{ $$ = $1; BBUNSUP($2, "Unsupported: dist"); }
	;

fexpr<nodep>:			// For use as first part of statement (disambiguates <=)
		BISONPRE_COPY(expr,{s/~l~/f/g; s/~r~/f/g; s/~f__IGNORE~/__IGNORE/g;})	// {copied}
	;

//UNSUPev_expr<nodep>:  // IEEE: event_expression
//UNSUP	//			// for yOR/, see event_expression
//UNSUP	//
//UNSUP	//			// IEEE: [ edge_identifier ] expression [ yIFF expression ]
//UNSUP	//			// expr alone see below
//UNSUP		senitemEdge				{ $$ = $1; }
//UNSUP	|	ev_expr yIFF expr			{ }
//UNSUP	//
//UNSUP	//			// IEEE: sequence_instance [ yIFF expression ]
//UNSUP	//			// seq_inst is in expr, so matches senitem rule above
//UNSUP	//
//UNSUP	//			// IEEE: event_expression yOR event_expression
//UNSUP	|	ev_expr yOR ev_expr			{ }
//UNSUP	//			// IEEE: event_expression ',' event_expression
//UNSUP	//			// See real event_expression rule
//UNSUP	//
//UNSUP	//---------------------
//UNSUP	//			// IEEE: expr
//UNSUP	|	BISONPRE_COPY(expr,{s/~l~/ev_/g; s/~r~/ev_/g; s/~p~/ev_/g; s/~noPar__IGNORE~/yP_PAR__IGNORE /g;})	// {copied}
//UNSUP	//
//UNSUP	//			// IEEE: '(' event_expression ')'
//UNSUP	//			// expr:'(' x ')' conflicts with event_expression:'(' event_expression ')'
//UNSUP	//			// so we use a special expression class
//UNSUP	|	'(' event_expression ')'		{ $<fl>$=$<fl>1; $$ = "(...)"; }
//UNSUP	//			// IEEE: From normal expr: '(' expr ':' expr ':' expr ')'
//UNSUP	//			// But must avoid conflict
//UNSUP	|	'(' event_expression ':' expr ':' expr ')'	{ $<fl>$=$<fl>1; $$ = "(...)"; }
//UNSUP	;

exprNoStr<nodep>:		// expression with string removed
		BISONPRE_COPY(expr,{s/~noStr__IGNORE~/Ignore/g;})	// {copied}
	;

exprOkLvalue<nodep>:		// expression that's also OK to use as a variable_lvalue
		~l~exprScope				{ $$ = $1; }
	//			// IEEE: concatenation/constant_concatenation
	//			// Replicate(1) required as otherwise "{a}" would not be self-determined
	|	'{' cateList '}'			{ $$ = new AstReplicate($1,$2,1); }
	|	'{' cateList '}' '[' expr ']'		{ $$ = new AstSelBit($4, new AstReplicate($1,$2,1), $5); }
	|	'{' cateList '}' '[' constExpr ':' constExpr ']'
							{ $$ = new AstSelExtract($4, new AstReplicate($1,$2,1), $5, $7); }
	|	'{' cateList '}' '[' expr yP_PLUSCOLON constExpr ']'
							{ $$ = new AstSelPlus($4, new AstReplicate($1,$2,1), $5, $7); }
	|	'{' cateList '}' '[' expr yP_MINUSCOLON constExpr ']'
							{ $$ = new AstSelMinus($4, new AstReplicate($1,$2,1), $5, $7); }
	//			// IEEE: assignment_pattern_expression
	//			// IEEE: [ assignment_pattern_expression_type ] == [ ps_type_id /ps_paremeter_id/data_type]
	//			// We allow more here than the spec requires
	//UNSUP	~l~exprScope assignment_pattern		{ UNSUP }
	|	data_type assignment_pattern		{ $$ = $2; if ($2) $2->childDTypep($1); }
	|	assignment_pattern			{ $$ = $1; }
	//
	|	streaming_concatenation			{ $$ = $1; }
	;

fexprOkLvalue<nodep>:		// exprOkLValue, For use as first part of statement (disambiguates <=)
		BISONPRE_COPY(exprOkLvalue,{s/~l~/f/g})	// {copied}
	;

//UNSUPsexprOkLvalue<nodep>:  // exprOkLValue, For use by sequence_expr
//UNSUP		BISONPRE_COPY(exprOkLvalue,{s/~l~/s/g})	// {copied}
//UNSUP	;

//UNSUPpexprOkLvalue<nodep>:  // exprOkLValue, For use by property_expr
//UNSUP		BISONPRE_COPY(exprOkLvalue,{s/~l~/p/g})	// {copied}
//UNSUP	;

//UNSUPev_exprOkLvalue<nodep>:  // exprOkLValue, For use by ev_expr
//UNSUP		BISONPRE_COPY(exprOkLvalue,{s/~l~/ev_/g})	// {copied}
//UNSUP	;

//UNSUPpev_exprOkLvalue<nodep>:  // exprOkLValue, For use by ev_expr
//UNSUP		BISONPRE_COPY(exprOkLvalue,{s/~l~/pev_/g})	// {copied}
//UNSUP	;

fexprLvalue<nodep>:		// For use as first part of statement (disambiguates <=)
		fexprOkLvalue				{ $<fl>$=$<fl>1; $$ = $1; }
	;

exprScope<nodep>:		// scope and variable for use to inside an expression
	// 			// Here we've split method_call_root | implicit_class_handle | class_scope | package_scope
	//			// from the object being called and let expr's "." deal with resolving it.
	//			// (note method_call_root was simplified to require a primary in 1800-2009)
	//
	//			// IEEE: [ implicit_class_handle . | class_scope | package_scope ] hierarchical_identifier select
	//			// Or method_call_body without parenthesis
	//			// See also varRefClassBit, which is the non-expr version of most of this
		yTHIS					{ $$ = new AstParseRef($<fl>1, VParseRefExp::PX_ROOT, "this"); }
	|	yD_ROOT					{ $$ = new AstParseRef($<fl>1, VParseRefExp::PX_ROOT, "$root"); }
	|	idArrayed				{ $$ = $1; }
	|	packageClassScope idArrayed		{ $$ = AstDot::newIfPkg($2->fileline(), $1, $2); }
	|	~l~expr '.' idArrayed			{ $$ = new AstDot($<fl>2, false, $1, $3); }
	//			// expr below must be a "yTHIS"
	|	~l~expr '.' ySUPER			{ $$ = $1; BBUNSUP($3, "Unsupported: super"); }
	//			// Part of implicit_class_handle
	|	ySUPER					{ $$ = new AstParseRef($<fl>1, VParseRefExp::PX_ROOT, "super"); }
	;

fexprScope<nodep>:		// exprScope, For use as first part of statement (disambiguates <=)
		BISONPRE_COPY(exprScope,{s/~l~/f/g})	// {copied}
	;

//UNSUPsexprScope<nodep>:  // exprScope, For use by sequence_expr
//UNSUP		BISONPRE_COPY(exprScope,{s/~l~/s/g})	// {copied}
//UNSUP	;

//UNSUPpexprScope<nodep>:  // exprScope, For use by property_expr
//UNSUP		BISONPRE_COPY(exprScope,{s/~l~/p/g})	// {copied}
//UNSUP	;

//UNSUPev_exprScope<nodep>:  // exprScope, For use by ev_expr
//UNSUP		BISONPRE_COPY(exprScope,{s/~l~/ev_/g})	// {copied}
//UNSUP	;

//UNSUPpev_exprScope<nodep>:  // exprScope, For use by ev_expr
//UNSUP		BISONPRE_COPY(exprScope,{s/~l~/pev_/g})	// {copied}
//UNSUP	;

// PLI calls exclude "" as integers, they're strings
// For $c("foo","bar") we want "bar" as a string, not a Verilog integer.
exprStrText<nodep>:
		exprNoStr				{ $$ = $1; }
	|	strAsText				{ $$ = $1; }
	;

cStrList<nodep>:
		exprStrText				{ $$ = $1; }
	|	exprStrText ',' cStrList		{ $$ = $1;$1->addNext($3); }
	;

cateList<nodep>:
	//			// Not just 'expr' to prevent conflict via stream_concOrExprOrType
		stream_expression			{ $$ = $1; }
	|	cateList ',' stream_expression		{ $$ = new AstConcat($2,$1,$3); }
	;

exprListE<nodep>:
		/* empty */				{ $$ = nullptr; }
	|	exprList				{ $$ = $1; }
	;

exprList<nodep>:
		expr					{ $$ = $1; }
	|	exprList ',' expr			{ $$ = $1;$1->addNext($3); }
	;

exprDispList<nodep>:		// exprList for within $display
		expr					{ $$ = $1; }
	|	exprDispList ',' expr			{ $$ = $1; $1->addNext($3); }
	//			// ,, creates a space in $display
	|	exprDispList ',' /*empty*/
			{ $$ = $1; $1->addNext(new AstConst($<fl>2, AstConst::VerilogStringLiteral(), " ")); }
	;

vrdList<nodep>:
		idClassSel				{ $$ = $1; }
	|	vrdList ',' idClassSel			{ $$ = $1;$1->addNext($3); }
	;

commaVRDListE<nodep>:
		/* empty */				{ $$ = nullptr; }
	|	',' vrdList				{ $$ = $2; }
	;

argsExprList<nodep>:		// IEEE: part of list_of_arguments (used where ,, isn't legal)
		expr					{ $$ = $1; }
	|	argsExprList ',' expr			{ $$ = $1->addNext($3); }
	;

argsExprListE<nodep>:		// IEEE: part of list_of_arguments
		argsExprOneE				{ $$ = $1; }
	|	argsExprListE ',' argsExprOneE		{ $$ = $1->addNext($3); }
	;

//UNSUPpev_argsExprListE<nodep>:  // IEEE: part of list_of_arguments - pev_expr at bottom
//UNSUP		pev_argsExprOneE			{ $$ = $1; }
//UNSUP	|	pev_argsExprListE ',' pev_argsExprOneE	{ $$ = AstNode::addNextNull($1, $3); }
//UNSUP	;

argsExprOneE<nodep>:		// IEEE: part of list_of_arguments
		/*empty*/				{ $$ = new AstArg(CRELINE(), "", nullptr); }
	|	expr					{ $$ = new AstArg($1->fileline(), "", $1); }
	;

//UNSUPpev_argsExprOneE<nodep>:  // IEEE: part of list_of_arguments - pev_expr at bottom
//UNSUP		/*empty*/				{ $$ = nullptr; }	// ,, is legal in list_of_arguments
//UNSUP	|	pev_expr				{ $$ = $1; }
//UNSUP	;

argsDottedList<nodep>:		// IEEE: part of list_of_arguments
		argsDotted				{ $$ = $1; }
	|	argsDottedList ',' argsDotted		{ $$ = $1->addNextNull($3); }
	;

//UNSUPpev_argsDottedList<nodep>:  // IEEE: part of list_of_arguments - pev_expr at bottom
//UNSUP		pev_argsDotted				{ $$ = $1; }
//UNSUP	|	pev_argsDottedList ',' pev_argsDotted	{ $$ = AstNode::addNextNull($1, $3); }
//UNSUP	;

argsDotted<nodep>:		// IEEE: part of list_of_arguments
		'.' idAny '(' ')'			{ $$ = new AstArg($<fl>2, *$2, nullptr); }
	|	'.' idAny '(' expr ')'			{ $$ = new AstArg($<fl>2, *$2, $4); }
	;

//UNSUPpev_argsDotted<nodep>:  // IEEE: part of list_of_arguments - pev_expr at bottom
//UNSUP		'.' idAny '(' ')'			{ $$ = new AstArg($<fl>2, *$2, nullptr); }
//UNSUP	|	'.' idAny '(' pev_expr ')'		{ $$ = new AstArg($<fl>2, *$2, $4); }
//UNSUP	;

streaming_concatenation<nodep>:	// ==IEEE: streaming_concatenation
	//	 		// Need to disambiguate {<< expr-{ ... expr-} stream_concat }
	//			// From                 {<< stream-{ ... stream-} }
	//			// Likewise simple_type's idScoped from constExpr's idScope
	//			// Thus we allow always any two operations.  Sorry
	//			// IEEE: "'{' yP_SL/R             stream_concatenation '}'"
	//			// IEEE: "'{' yP_SL/R simple_type stream_concatenation '}'"
	//			// IEEE: "'{' yP_SL/R constExpr	  stream_concatenation '}'"
		'{' yP_SLEFT  stream_concatenation '}'
			{ $$ = new AstStreamL($2, $3, new AstConst($2, 1)); }
	|	'{' yP_SRIGHT stream_concatenation '}'
			{ $$ = new AstStreamR($2, $3, new AstConst($2, 1)); }
	|	'{' yP_SLEFT  stream_expressionOrDataType stream_concatenation '}'
			{ $$ = new AstStreamL($2, $4, $3); }
	|	'{' yP_SRIGHT stream_expressionOrDataType stream_concatenation '}'
			{ $$ = new AstStreamR($2, $4, $3); }
	;

stream_concatenation<nodep>:	// ==IEEE: stream_concatenation
	//			// '{' { stream_expression } '}'
		'{' cateList '}'			{ $$ = $2; }
	;

stream_expression<nodep>:	// ==IEEE: stream_expression
	//			// IEEE: array_range_expression expanded below
		expr					{ $$ = $1; }
	//UNSUP	expr yWITH__BRA '[' expr ']'		{ UNSUP }
	//UNSUP	expr yWITH__BRA '[' expr ':' expr ']'	{ UNSUP }
	//UNSUP	expr yWITH__BRA '[' expr yP_PLUSCOLON  expr ']'	{ UNSUP }
	//UNSUP	expr yWITH__BRA '[' expr yP_MINUSCOLON expr ']'	{ UNSUP }
	;

stream_expressionOrDataType<nodep>:	// IEEE: from streaming_concatenation
		exprOrDataType				{ $$ = $1; }
	//UNSUP	expr yWITH__BRA '[' expr ']'		{ UNSUP }
	//UNSUP	expr yWITH__BRA '[' expr ':' expr ']'	{ UNSUP }
	//UNSUP	expr yWITH__BRA '[' expr yP_PLUSCOLON  expr ']'	{ UNSUP }
	//UNSUP	expr yWITH__BRA '[' expr yP_MINUSCOLON expr ']'	{ UNSUP }
	;

//************************************************
// Gate declarations

gateDecl<nodep>:
		yBUF    delayE gateBufList ';'		{ $$ = $3; }
	|	yBUFIF0 delayE gateBufif0List ';'	{ $$ = $3; }
	|	yBUFIF1 delayE gateBufif1List ';'	{ $$ = $3; }
	|	yNOT    delayE gateNotList ';'		{ $$ = $3; }
	|	yNOTIF0 delayE gateNotif0List ';'	{ $$ = $3; }
	|	yNOTIF1 delayE gateNotif1List ';'	{ $$ = $3; }
	|	yAND  delayE gateAndList ';'		{ $$ = $3; }
	|	yNAND delayE gateNandList ';'		{ $$ = $3; }
	|	yOR   delayE gateOrList ';'		{ $$ = $3; }
	|	yNOR  delayE gateNorList ';'		{ $$ = $3; }
	|	yXOR  delayE gateXorList ';'		{ $$ = $3; }
	|	yXNOR delayE gateXnorList ';'		{ $$ = $3; }
	|	yPULLUP delayE gatePullupList ';'	{ $$ = $3; }
	|	yPULLDOWN delayE gatePulldownList ';'	{ $$ = $3; }
	|	yNMOS delayE gateBufif1List ';'		{ $$ = $3; }  // ~=bufif1, as don't have strengths yet
	|	yPMOS delayE gateBufif0List ';'		{ $$ = $3; }  // ~=bufif0, as don't have strengths yet
	//
	|	yTRAN delayE gateUnsupList ';'		{ $$ = $3; GATEUNSUP($3,"tran"); } // Unsupported
	|	yRCMOS delayE gateUnsupList ';'		{ $$ = $3; GATEUNSUP($3,"rcmos"); } // Unsupported
	|	yCMOS delayE gateUnsupList ';'		{ $$ = $3; GATEUNSUP($3,"cmos"); } // Unsupported
	|	yRNMOS delayE gateUnsupList ';'		{ $$ = $3; GATEUNSUP($3,"rmos"); } // Unsupported
	|	yRPMOS delayE gateUnsupList ';'		{ $$ = $3; GATEUNSUP($3,"pmos"); } // Unsupported
	|	yRTRAN delayE gateUnsupList ';'		{ $$ = $3; GATEUNSUP($3,"rtran"); } // Unsupported
	|	yRTRANIF0 delayE gateUnsupList ';'	{ $$ = $3; GATEUNSUP($3,"rtranif0"); } // Unsupported
	|	yRTRANIF1 delayE gateUnsupList ';'	{ $$ = $3; GATEUNSUP($3,"rtranif1"); } // Unsupported
	|	yTRANIF0 delayE gateUnsupList ';'	{ $$ = $3; GATEUNSUP($3,"tranif0"); } // Unsupported
	|	yTRANIF1 delayE gateUnsupList ';'	{ $$ = $3; GATEUNSUP($3,"tranif1"); } // Unsupported
	;

gateBufList<nodep>:
		gateBuf 				{ $$ = $1; }
	|	gateBufList ',' gateBuf			{ $$ = $1->addNext($3); }
	;
gateBufif0List<nodep>:
		gateBufif0 				{ $$ = $1; }
	|	gateBufif0List ',' gateBufif0		{ $$ = $1->addNext($3); }
	;
gateBufif1List<nodep>:
		gateBufif1 				{ $$ = $1; }
	|	gateBufif1List ',' gateBufif1		{ $$ = $1->addNext($3); }
	;
gateNotList<nodep>:
		gateNot 				{ $$ = $1; }
	|	gateNotList ',' gateNot			{ $$ = $1->addNext($3); }
	;
gateNotif0List<nodep>:
		gateNotif0 				{ $$ = $1; }
	|	gateNotif0List ',' gateNotif0		{ $$ = $1->addNext($3); }
	;
gateNotif1List<nodep>:
		gateNotif1 				{ $$ = $1; }
	|	gateNotif1List ',' gateNotif1		{ $$ = $1->addNext($3); }
	;
gateAndList<nodep>:
		gateAnd 				{ $$ = $1; }
	|	gateAndList ',' gateAnd			{ $$ = $1->addNext($3); }
	;
gateNandList<nodep>:
		gateNand 				{ $$ = $1; }
	|	gateNandList ',' gateNand		{ $$ = $1->addNext($3); }
	;
gateOrList<nodep>:
		gateOr 					{ $$ = $1; }
	|	gateOrList ',' gateOr			{ $$ = $1->addNext($3); }
	;
gateNorList<nodep>:
		gateNor 				{ $$ = $1; }
	|	gateNorList ',' gateNor			{ $$ = $1->addNext($3); }
	;
gateXorList<nodep>:
		gateXor 				{ $$ = $1; }
	|	gateXorList ',' gateXor			{ $$ = $1->addNext($3); }
	;
gateXnorList<nodep>:
		gateXnor 				{ $$ = $1; }
	|	gateXnorList ',' gateXnor		{ $$ = $1->addNext($3); }
	;
gatePullupList<nodep>:
		gatePullup 				{ $$ = $1; }
	|	gatePullupList ',' gatePullup		{ $$ = $1->addNext($3); }
	;
gatePulldownList<nodep>:
		gatePulldown 				{ $$ = $1; }
	|	gatePulldownList ',' gatePulldown	{ $$ = $1->addNext($3); }
	;
gateUnsupList<nodep>:
		gateUnsup 				{ $$ = $1; }
	|	gateUnsupList ',' gateUnsup		{ $$ = $1->addNext($3); }
	;

gateRangeE<nodep>:
		instRangeListE 				{ $$ = $1; GATERANGE(GRAMMARP->scrubRange($1)); }
	;

gateBuf<nodep>:
		gateFront variable_lvalue ',' gatePinExpr ')'
			{ $$ = new AstAssignW($<fl>1, $2, $4); DEL($1); }
	// UNSUP			// IEEE: Multiple output variable_lvalues
	// UNSUP			// Causes conflict - need to take in variable_lvalue or a gatePinExpr
	;
gateBufif0<nodep>:
		gateFront variable_lvalue ',' gatePinExpr ',' gatePinExpr ')'
			{ $$ = new AstAssignW($<fl>1, $2, new AstBufIf1($<fl>1, new AstNot($<fl>1, $6), $4)); DEL($1); }
	;
gateBufif1<nodep>:
		gateFront variable_lvalue ',' gatePinExpr ',' gatePinExpr ')'
			{ $$ = new AstAssignW($<fl>1, $2, new AstBufIf1($<fl>1, $6, $4)); DEL($1); }
	;
gateNot<nodep>:
		gateFront variable_lvalue ',' gatePinExpr ')'
			{ $$ = new AstAssignW($<fl>1, $2, new AstNot($<fl>1, $4)); DEL($1); }
	// UNSUP			// IEEE: Multiple output variable_lvalues
	// UNSUP			// Causes conflict - need to take in variable_lvalue or a gatePinExpr
	;
gateNotif0<nodep>:
		gateFront variable_lvalue ',' gatePinExpr ',' gatePinExpr ')'
			{ $$ = new AstAssignW($<fl>1, $2, new AstBufIf1($<fl>1, new AstNot($<fl>1, $6),
									new AstNot($<fl>1, $4))); DEL($1); }
	;
gateNotif1<nodep>:
		gateFront variable_lvalue ',' gatePinExpr ',' gatePinExpr ')'
			{ $$ = new AstAssignW($<fl>1, $2, new AstBufIf1($<fl>1, $6, new AstNot($<fl>1, $4))); DEL($1); }
	;
gateAnd<nodep>:
		gateFront variable_lvalue ',' gateAndPinList ')'
			{ $$ = new AstAssignW($<fl>1, $2, $4); DEL($1); }
	;
gateNand<nodep>:
		gateFront variable_lvalue ',' gateAndPinList ')'
			{ $$ = new AstAssignW($<fl>1, $2, new AstNot($<fl>1, $4)); DEL($1); }
	;
gateOr<nodep>:
		gateFront variable_lvalue ',' gateOrPinList ')'
			{ $$ = new AstAssignW($<fl>1, $2, $4); DEL($1); }
	;
gateNor<nodep>:
		gateFront variable_lvalue ',' gateOrPinList ')'
			{ $$ = new AstAssignW($<fl>1, $2, new AstNot($<fl>1, $4)); DEL($1); }
	;
gateXor<nodep>:
		gateFront variable_lvalue ',' gateXorPinList ')'
			{ $$ = new AstAssignW($<fl>1, $2, $4); DEL($1); }
	;
gateXnor<nodep>:
		gateFront variable_lvalue ',' gateXorPinList ')'
			{ $$ = new AstAssignW($<fl>1, $2, new AstNot($<fl>1, $4)); DEL($1); }
	;
gatePullup<nodep>:
		gateFront variable_lvalue ')'		{ $$ = new AstPull($<fl>1, $2, true); DEL($1); }
	;
gatePulldown<nodep>:
		gateFront variable_lvalue ')'		{ $$ = new AstPull($<fl>1, $2, false); DEL($1); }
	;
gateUnsup<nodep>:
		gateFront gateUnsupPinList ')'		{ $$ = new AstImplicit($<fl>1, $2); DEL($1); }
	;

gateFront<nodep>:
		id/*gate*/ gateRangeE '('		{ $$ = $2; $<fl>$ = $<fl>1; }
	|	gateRangeE '('				{ $$ = $1; $<fl>$ = $<fl>2; }
	;

gateAndPinList<nodep>:
		gatePinExpr 				{ $$ = $1; }
	|	gateAndPinList ',' gatePinExpr		{ $$ = new AstAnd($2,$1,$3); }
	;
gateOrPinList<nodep>:
		gatePinExpr 				{ $$ = $1; }
	|	gateOrPinList ',' gatePinExpr		{ $$ = new AstOr($2,$1,$3); }
	;
gateXorPinList<nodep>:
		gatePinExpr 				{ $$ = $1; }
	|	gateXorPinList ',' gatePinExpr		{ $$ = new AstXor($2,$1,$3); }
	;
gateUnsupPinList<nodep>:
		gatePinExpr 				{ $$ = $1; }
	|	gateUnsupPinList ',' gatePinExpr	{ $$ = $1->addNext($3); }
	;

gatePinExpr<nodep>:
		expr					{ $$ = GRAMMARP ->createGatePin($1); }
	;

// This list is also hardcoded in VParseLex.l
strength:			// IEEE: strength0+strength1 - plus HIGHZ/SMALL/MEDIUM/LARGE
		ygenSTRENGTH				{ BBUNSUP($1, "Unsupported: Verilog 1995 strength specifiers"); }
	|	ySUPPLY0				{ BBUNSUP($1, "Unsupported: Verilog 1995 strength specifiers"); }
	|	ySUPPLY1				{ BBUNSUP($1, "Unsupported: Verilog 1995 strength specifiers"); }
	;

strengthSpecE:			// IEEE: drive_strength + pullup_strength + pulldown_strength + charge_strength - plus empty
		/* empty */				{ }
	|	strengthSpec				{ }
	;

strengthSpec:			// IEEE: drive_strength + pullup_strength + pulldown_strength + charge_strength - plus empty
		yP_PAR__STRENGTH strength ')'			{ }
	|	yP_PAR__STRENGTH strength ',' strength ')'	{ }
	;

//************************************************
// Tables

combinational_body<nodep>:	// IEEE: combinational_body + sequential_body
		yTABLE tableEntryList yENDTABLE		{ $$ = new AstUdpTable($1,$2); }
	;

tableEntryList<nodep>:	// IEEE: { combinational_entry | sequential_entry }
		tableEntry 				{ $$ = $1; }
	|	tableEntryList tableEntry		{ $$ = $1->addNextNull($2); }
	;

tableEntry<nodep>:	// IEEE: combinational_entry + sequential_entry
		yaTABLELINE				{ $$ = new AstUdpTableLine($<fl>1,*$1); }
	|	error					{ $$ = nullptr; }
	;

//************************************************
// Specify

specify_block<nodep>:		// ==IEEE: specify_block
		ySPECIFY specifyJunkList yENDSPECIFY	{ $$ = nullptr; }
	|	ySPECIFY yENDSPECIFY			{ $$ = nullptr; }
	;

specifyJunkList:
		specifyJunk 				{ } /* ignored */
	|	specifyJunkList specifyJunk		{ } /* ignored */
	;

specifyJunk:
		BISONPRE_NOT(ySPECIFY,yENDSPECIFY)	{ }
	|	ySPECIFY specifyJunk yENDSPECIFY	{ }
	|	error {}
	;

specparam_declaration<nodep>:		// ==IEEE: specparam_declaration
		ySPECPARAM junkToSemiList ';'		{ $$ = nullptr; }
	;

junkToSemiList:
		junkToSemi 				{ } /* ignored */
	|	junkToSemiList junkToSemi		{ } /* ignored */
	;

junkToSemi:
		BISONPRE_NOT(';',yENDSPECIFY,yENDMODULE)	{ }
	|	error {}
	;

//************************************************
// IDs

id<strp>:
		yaID__ETC				{ $$ = $1; $<fl>$=$<fl>1; }
	|	idRandomize				{ $$ = $1; $<fl>$=$<fl>1; }
	;

idAny<strp>:			// Any kind of identifier
		yaID__ETC				{ $$ = $1; $<fl>$=$<fl>1; }
	|	yaID__aTYPE				{ $$ = $1; $<fl>$=$<fl>1; }
	|	idRandomize				{ $$ = $1; $<fl>$=$<fl>1; }
	;

idType<strp>:			// IEEE: class_identifier or other type identifier
	//			// Used where reference is needed
		yaID__aTYPE				{ $$ = $1; $<fl>$=$<fl>1; }
	;

idCC<strp>:			// IEEE: class/package then ::
				// lexer matches this:  yaID_LEX [ '#' '(' ... ')' ] yP_COLONCOLON
		yaID__CC				{ $$ = $1; $<fl>$=$<fl>1; }
	;

idRandomize<strp>:		// Keyword as an identifier
		yRANDOMIZE				{ static string s = "randomize"; $$ = &s; $<fl>$ = $<fl>1; }
	;

idSVKwd<strp>:			// Warn about non-forward compatible Verilog 2001 code
	//			// yBIT, yBYTE won't work here as causes conflicts
		yDO					{ static string s = "do"   ; $$ = &s; ERRSVKWD($1,*$$); $<fl>$=$<fl>1; }
	|	yFINAL					{ static string s = "final"; $$ = &s; ERRSVKWD($1,*$$); $<fl>$=$<fl>1; }
	;

variable_lvalue<nodep>:		// IEEE: variable_lvalue or net_lvalue
	//			// Note many variable_lvalue's must use exprOkLvalue when arbitrary expressions may also exist
		idClassSel				{ $$ = $1; }
	|	'{' variable_lvalueConcList '}'		{ $$ = $2; }
	//			// IEEE: [ assignment_pattern_expression_type ] assignment_pattern_variable_lvalue
	//			// We allow more assignment_pattern_expression_types then strictly required
	//UNSUP	data_type  yP_TICKBRA variable_lvalueList '}'	{ UNSUP }
	//UNSUP	idClassSel yP_TICKBRA variable_lvalueList '}'	{ UNSUP }
	//UNSUP	/**/       yP_TICKBRA variable_lvalueList '}'	{ UNSUP }
	|	streaming_concatenation			{ $$ = $1; }
	;

variable_lvalueConcList<nodep>:	// IEEE: part of variable_lvalue: '{' variable_lvalue { ',' variable_lvalue } '}'
		variable_lvalue					{ $$ = $1; }
	|	variable_lvalueConcList ',' variable_lvalue	{ $$ = new AstConcat($2,$1,$3); }
	;

//UNSUPvariable_lvalueList<nodep>:  // IEEE: part of variable_lvalue: variable_lvalue { ',' variable_lvalue }
//UNSUP		variable_lvalue				{ $$ = $1; }
//UNSUP	|	variable_lvalueList ',' variable_lvalue	{ $$ = AstNode::addNextNull($1, $3); }
//UNSUP	;

// VarRef to dotted, and/or arrayed, and/or bit-ranged variable
idClassSel<nodep>:			// Misc Ref to dotted, and/or arrayed, and/or bit-ranged variable
		idDotted				{ $$ = $1; }
	//			// IEEE: [ implicit_class_handle . | package_scope ] hierarchical_variable_identifier select
	|	yTHIS '.' idDotted
			{ $$ = new AstDot($2, false, new AstParseRef($<fl>1, VParseRefExp::PX_ROOT, "this"), $3); }
	|	ySUPER '.' idDotted
			{ $$ = new AstDot($2, false, new AstParseRef($<fl>1, VParseRefExp::PX_ROOT, "super"), $3); }
	|	yTHIS '.' ySUPER '.' idDotted		{ $$ = $5; BBUNSUP($1, "Unsupported: this.super"); }
	//			// Expanded: package_scope idDotted
	|	packageClassScope idDotted		{ $$ = new AstDot($<fl>2, true, $1, $2); }
	;

idClassSelForeach<nodep>:
		idDottedForeach				{ $$ = $1; }
	//			// IEEE: [ implicit_class_handle . | package_scope ] hierarchical_variable_identifier select
	|	yTHIS '.' idDottedForeach
			{ $$ = new AstDot($2, false, new AstParseRef($<fl>1, VParseRefExp::PX_ROOT, "this"), $3); }
	|	ySUPER '.' idDottedForeach
			{ $$ = new AstDot($2, false, new AstParseRef($<fl>1, VParseRefExp::PX_ROOT, "super"), $3); }
	|	yTHIS '.' ySUPER '.' idDottedForeach	{ $$ = $5; BBUNSUP($1, "Unsupported: this.super"); }
	//			// Expanded: package_scope idForeach
	|	packageClassScope idDottedForeach	{ $$ = new AstDot($<fl>2, true, $1, $2); }
	;

idDotted<nodep>:
		yD_ROOT '.' idDottedMore
			{ $$ = new AstDot($2, false, new AstParseRef($<fl>1, VParseRefExp::PX_ROOT, "$root"), $3); }
	|	idDottedMore		 		{ $$ = $1; }
	;

idDottedForeach<nodep>:
		yD_ROOT '.' idDottedMoreForeach
			{ $$ = new AstDot($2, false, new AstParseRef($<fl>1, VParseRefExp::PX_ROOT, "$root"), $3); }
	|	idDottedMoreForeach	 		{ $$ = $1; }
	;

idDottedMore<nodep>:
		idArrayed 				{ $$ = $1; }
	|	idDottedMore '.' idArrayed	 	{ $$ = new AstDot($2, false, $1, $3); }
	;

idDottedMoreForeach<nodep>:
		idArrayedForeach 			{ $$ = $1; }
	|	idDottedMoreForeach '.' idArrayedForeach	{ $$ = new AstDot($2, false, $1, $3); }
	;

// Single component of dotted path, maybe [#].
// Due to lookahead constraints, we can't know if [:] or [+:] are valid (last dotted part),
// we'll assume so and cleanup later.
// id below includes:
//	 enum_identifier
idArrayed<nodep>:		// IEEE: id + select
		id
			{ $$ = new AstParseRef($<fl>1, VParseRefExp::PX_TEXT, *$1, nullptr, nullptr); }
	//			// IEEE: id + part_select_range/constant_part_select_range
	|	idArrayed '[' expr ']'				{ $$ = new AstSelBit($2, $1, $3); }  // Or AstArraySel, don't know yet.
	|	idArrayed '[' constExpr ':' constExpr ']'	{ $$ = new AstSelExtract($2, $1, $3, $5); }
	//			// IEEE: id + indexed_range/constant_indexed_range
	|	idArrayed '[' expr yP_PLUSCOLON  constExpr ']'	{ $$ = new AstSelPlus($2, $1, $3, $5); }
	|	idArrayed '[' expr yP_MINUSCOLON constExpr ']'	{ $$ = new AstSelMinus($2, $1, $3, $5); }
	;

idArrayedForeach<nodep>:	// IEEE: id + select (under foreach expression)
		id
			{ $$ = new AstParseRef($<fl>1, VParseRefExp::PX_TEXT, *$1, nullptr, nullptr); }
	//			// IEEE: id + part_select_range/constant_part_select_range
	|	idArrayed '[' expr ']'				{ $$ = new AstSelBit($2, $1, $3); }  // Or AstArraySel, don't know yet.
	|	idArrayed '[' constExpr ':' constExpr ']'	{ $$ = new AstSelExtract($2, $1, $3, $5); }
	//			// IEEE: id + indexed_range/constant_indexed_range
	|	idArrayed '[' expr yP_PLUSCOLON  constExpr ']'	{ $$ = new AstSelPlus($2, $1, $3, $5); }
	|	idArrayed '[' expr yP_MINUSCOLON constExpr ']'	{ $$ = new AstSelMinus($2, $1, $3, $5); }
	//			// IEEE: loop_variables (under foreach expression)
	//			// To avoid conflicts we allow expr as first element, must post-check
	|	idArrayed '[' expr ',' loop_variables ']'
			{ $3 = AstNode::addNextNull($3, $5); $$ = new AstSelLoopVars($2, $1, $3); }
	;

// VarRef without any dots or vectorizaion
varRefBase<varrefp>:
		id					{ $$ = new AstVarRef($<fl>1, *$1, VAccess::READ); }
	;

// yaSTRING shouldn't be used directly, instead via an abstraction below
str<strp>:			// yaSTRING but with \{escapes} need decoded
		yaSTRING				{ $$ = PARSEP->newString(GRAMMARP->deQuote($<fl>1,*$1)); }
	;

strAsInt<nodep>:
		yaSTRING				{ $$ = new AstConst($<fl>1, AstConst::VerilogStringLiteral(), GRAMMARP->deQuote($<fl>1, *$1));}
	;

strAsIntIgnore<nodep>:		// strAsInt, but never matches for when expr shouldn't parse strings
		yaSTRING__IGNORE			{ $$ = nullptr; yyerror("Impossible token"); }
	;

strAsText<nodep>:
		yaSTRING				{ $$ = GRAMMARP->createTextQuoted($<fl>1,*$1);}
	;

endLabelE<strp>:
		/* empty */				{ $$ = nullptr; $<fl>$=nullptr; }
	|	':' idAny				{ $$ = $2; $<fl>$=$<fl>2; }
	|	':' yNEW__ETC				{ static string n = "new"; $$ = &n; $<fl>$=$<fl>2; }
	;

//************************************************
// Clocking

clocking_declaration<nodep>:		// IEEE: clocking_declaration  (INCOMPLETE)
	//UNSUP: vvv remove this -- vastly simplified grammar:
		yDEFAULT yCLOCKING '@' '(' senitemEdge ')' ';' yENDCLOCKING
			{ $$ = new AstClocking($2, $5, nullptr); }
	//UNSUP: ^^^ remove this -- vastly simplified grammar:
	//UNSUP	clockingFront clocking_event ';'
	//UNSUP	 clocking_itemListE yENDCLOCKING endLabelE { SYMP->popScope($$); }
	;

//UNSUPclockingFront:  // IEEE: part of class_declaration
//UNSUP		yCLOCKING				{ PARSEP->symPushNewAnon(VAstType::CLOCKING); }
//UNSUP	|	yCLOCKING idAny/*clocking_identifier*/	{ SYMP->pushNew($$); }
//UNSUP	|	yDEFAULT yCLOCKING			{ PARSEP->symPushNewAnon(VAstType::CLOCKING); }
//UNSUP	|	yDEFAULT yCLOCKING idAny/*clocking_identifier*/	{ SYMP->pushNew($$); }
//UNSUP	|	yGLOBAL__CLOCKING yCLOCKING			{ PARSEP->symPushNewAnon(VAstType::CLOCKING); }
//UNSUP	|	yGLOBAL__CLOCKING yCLOCKING idAny/*clocking_identifier*/	{ SYMP->pushNew($$); }
//UNSUP	;

//UNSUPclocking_event:  // ==IEEE: clocking_event
//UNSUP		'@' id					{ }
//UNSUP	|	'@' '(' event_expression ')'		{ }
//UNSUP	;

//UNSUPclocking_itemListE:
//UNSUP		/* empty */				{ $$ = nullptr; }
//UNSUP	|	clocking_itemList			{ $$ = $1; }
//UNSUP	;

//UNSUPclocking_itemList:  // IEEE: [ clocking_item ]
//UNSUP		clocking_item				{ $$ = $1; }
//UNSUP	|	clocking_itemList clocking_item		{ $$ = AstNode::addNextNull($1, $2); }
//UNSUP	;

//UNSUPclocking_item:  // ==IEEE: clocking_item
//UNSUP		yDEFAULT default_skew ';'		{ }
//UNSUP	|	clocking_direction list_of_clocking_decl_assign ';'	{ }
//UNSUP	|	assertion_item_declaration		{ }
//UNSUP	;

//UNSUPdefault_skew:  // ==IEEE: default_skew
//UNSUP		yINPUT clocking_skew			{ }
//UNSUP	|	yOUTPUT clocking_skew			{ }
//UNSUP	|	yINPUT clocking_skew yOUTPUT clocking_skew	{ }
//UNSUP	;

//UNSUPclocking_direction:  // ==IEEE: clocking_direction
//UNSUP		yINPUT clocking_skewE			{ }
//UNSUP	|	yOUTPUT clocking_skewE			{ }
//UNSUP	|	yINPUT clocking_skewE yOUTPUT clocking_skewE	{ }
//UNSUP	|	yINOUT					{ }
//UNSUP	;

//UNSUPlist_of_clocking_decl_assign:  // ==IEEE: list_of_clocking_decl_assign
//UNSUP		clocking_decl_assign			{ $$ = $1; }
//UNSUP	|	list_of_clocking_decl_assign ',' clocking_decl_assign	{ }
//UNSUP	;

//UNSUPclocking_decl_assign:  // ==IEEE: clocking_decl_assign
//UNSUP		idAny/*new-signal_identifier*/ exprEqE	{ $$ = $1; }
//UNSUP	;

//UNSUPclocking_skewE:  // IEEE: [clocking_skew]
//UNSUP		/* empty */				{ $$ = nullptr;}
//UNSUP	|	clocking_skew				{ $$ = $1; }
//UNSUP	;

//UNSUPclocking_skew:  // ==IEEE: clocking_skew
//UNSUP		yPOSEDGE				{ }
//UNSUP	|	yPOSEDGE delay_control			{ }
//UNSUP	|	yNEGEDGE				{ }
//UNSUP	|	yNEGEDGE delay_control			{ }
//UNSUP	|	yEDGE					{ NEED_S09($<fl>1,"edge"); }
//UNSUP	|	yEDGE delay_control			{ NEED_S09($<fl>1,"edge"); }
//UNSUP	|	delay_control				{ $$ = $1; }
//UNSUP	;

//UNSUPcycle_delay:  // ==IEEE: cycle_delay
//UNSUP		yP_POUNDPOUND yaINTNUM			{ }
//UNSUP	|	yP_POUNDPOUND id			{ }
//UNSUP	|	yP_POUNDPOUND '(' expr ')'		{ }
//UNSUP	;

//************************************************
// Asserts

//UNSUPassertion_item_declaration:  // ==IEEE: assertion_item_declaration
//UNSUP		property_declaration			{ $$ = $1; }
//UNSUP	|	sequence_declaration			{ $$ = $1; }
//UNSUP	|	let_declaration				{ $$ = $1; }
//UNSUP	;

assertion_item<nodep>:		// ==IEEE: assertion_item
		concurrent_assertion_item		{ $$ = $1; }
	|	deferred_immediate_assertion_item
			{ $$ = $1 ? new AstAlways($1->fileline(), VAlwaysKwd::ALWAYS_COMB, nullptr, $1) : nullptr; }
	;

deferred_immediate_assertion_item<nodep>:	// ==IEEE: deferred_immediate_assertion_item
		deferred_immediate_assertion_statement	{ $$ = $1; }
	|	id/*block_identifier*/ ':' deferred_immediate_assertion_statement
			{ $$ = new AstBegin($<fl>1, *$1, $3, false, true); }
	;

procedural_assertion_statement<nodep>:	// ==IEEE: procedural_assertion_statement
		concurrent_assertion_statement		{ $$ = $1; }
	|	immediate_assertion_statement		{ $$ = $1; }
	//			// IEEE: checker_instantiation
	//			// Unlike modules, checkers are the only "id id (...)" form in statements.
	//UNSUP	checker_instantiation			{ $$ = $1; }
	;

immediate_assertion_statement<nodep>:	// ==IEEE: immediate_assertion_statement
		simple_immediate_assertion_statement	{ $$ = $1; }
	|	deferred_immediate_assertion_statement	{ $$ = $1; }
	;

simple_immediate_assertion_statement<nodep>:	// ==IEEE: simple_immediate_assertion_statement
	//				// action_block expanded here, for compatibility with AstAssert
		yASSERT '(' expr ')' stmtBlock %prec prLOWER_THAN_ELSE	{ $$ = new AstAssert($1, $3, $5, nullptr, true); }
	|	yASSERT '(' expr ')'           yELSE stmtBlock		{ $$ = new AstAssert($1, $3, nullptr, $6, true); }
	|	yASSERT '(' expr ')' stmtBlock yELSE stmtBlock		{ $$ = new AstAssert($1, $3, $5, $7, true); }
	//				// action_block expanded here, for compatibility with AstAssert
	|	yASSUME '(' expr ')' stmtBlock %prec prLOWER_THAN_ELSE	{ $$ = new AstAssert($1, $3, $5, nullptr, true); }
	|	yASSUME '(' expr ')'           yELSE stmtBlock		{ $$ = new AstAssert($1, $3, nullptr, $6, true); }
	|	yASSUME '(' expr ')' stmtBlock yELSE stmtBlock		{ $$ = new AstAssert($1, $3, $5, $7, true);   }
	//			// IEEE: simple_immediate_cover_statement
	|	yCOVER '(' expr ')' stmt 		{ $$ = new AstCover($1, $3, $5, true); }
	;

final_zero:			// IEEE: part of deferred_immediate_assertion_statement
		'#' yaINTNUM
			{ if ($2->isNeqZero()) { $<fl>2->v3error("Deferred assertions must use '#0' (IEEE 1800-2017 16.4)"); } }
	//			// 1800-2012:
	|	yFINAL							{ }
	;

deferred_immediate_assertion_statement<nodep>:	// ==IEEE: deferred_immediate_assertion_statement
	//			// IEEE: deferred_immediate_assert_statement
		yASSERT final_zero '(' expr ')' stmtBlock %prec prLOWER_THAN_ELSE	{ $$ = new AstAssert($1, $4, $6, nullptr, true); }
	|	yASSERT final_zero '(' expr ')'           yELSE stmtBlock		{ $$ = new AstAssert($1, $4, nullptr, $7, true); }
	|	yASSERT final_zero '(' expr ')' stmtBlock yELSE stmtBlock		{ $$ = new AstAssert($1, $4, $6, $8, true);   }
	//			// IEEE: deferred_immediate_assume_statement
	|	yASSUME final_zero '(' expr ')' stmtBlock %prec prLOWER_THAN_ELSE	{ $$ = new AstAssert($1, $4, $6, nullptr, true); }
	|	yASSUME final_zero '(' expr ')'           yELSE stmtBlock		{ $$ = new AstAssert($1, $4, nullptr, $7, true); }
	|	yASSUME final_zero '(' expr ')' stmtBlock yELSE stmtBlock		{ $$ = new AstAssert($1, $4, $6, $8, true); }
	//			// IEEE: deferred_immediate_cover_statement
	|	yCOVER final_zero '(' expr ')' stmt	{ $$ = new AstCover($1, $4, $6, true); }
	;

//UNSUPexpect_property_statement<nodep>:  // ==IEEE: expect_property_statement
//UNSUP		yEXPECT '(' property_spec ')' action_block	{ }
//UNSUP	;

concurrent_assertion_item<nodep>:	// IEEE: concurrent_assertion_item
		concurrent_assertion_statement		{ $$ = $1; }
	|	id/*block_identifier*/ ':' concurrent_assertion_statement
			{ $$ = new AstBegin($<fl>1, *$1, $3, false, true); }
	//			// IEEE: checker_instantiation
	//			// identical to module_instantiation; see etcInst
	;

concurrent_assertion_statement<nodep>:	// ==IEEE: concurrent_assertion_statement
	//			// IEEE: assert_property_statement
	//UNSUP remove below:
		yASSERT yPROPERTY '(' property_spec ')' elseStmtBlock	{ $$ = new AstAssert($1, $4, nullptr, $6, false); }
	//UNSUP	yASSERT yPROPERTY '(' property_spec ')' action_block	{ }
	//			// IEEE: assume_property_statement
	|	yASSUME yPROPERTY '(' property_spec ')' elseStmtBlock	{ $$ = new AstAssert($1, $4, nullptr, $6, false); }
	//UNSUP	yASSUME yPROPERTY '(' property_spec ')' action_block	{ }
	//			// IEEE: cover_property_statement
	|	yCOVER yPROPERTY '(' property_spec ')' stmtBlock	{ $$ = new AstCover($1, $4, $6, false); }
	//			// IEEE: cover_sequence_statement
	//UNSUP	yCOVER ySEQUENCE '(' sexpr ')' stmt			{ }
	//			// IEEE: yCOVER ySEQUENCE '(' clocking_event sexpr ')' stmt
	//			// sexpr already includes "clocking_event sexpr"
	//UNSUP	yCOVER ySEQUENCE '(' clocking_event yDISABLE yIFF '(' expr/*expression_or_dist*/ ')' sexpr ')' stmt	{ }
	//UNSUP	yCOVER ySEQUENCE '(' yDISABLE yIFF '(' expr/*expression_or_dist*/ ')' sexpr ')' stmt	{ }
	//			// IEEE: restrict_property_statement
	|	yRESTRICT yPROPERTY '(' property_spec ')' ';'		{ $$ = new AstRestrict($1, $4); }
	;

elseStmtBlock<nodep>:	// Part of concurrent_assertion_statement
		';'					{ $$ = nullptr; }
	|	yELSE stmtBlock				{ $$ = $2; }
	;

//UNSUPproperty_declaration<nodep>:  // ==IEEE: property_declaration
//UNSUP		property_declarationFront property_port_listE ';' property_declarationBody
//UNSUP			yENDPROPERTY endLabelE
//UNSUP			{ SYMP->popScope($$); }
//UNSUP	;

//UNSUPproperty_declarationFront<nodep>:  // IEEE: part of property_declaration
//UNSUP		yPROPERTY idAny/*property_identifier*/
//UNSUP			{ SYMP->pushNew($$); }
//UNSUP	;

//UNSUPproperty_port_listE<nodep>:  // IEEE: [ ( [ property_port_list ] ) ]
//UNSUP		/* empty */				{ $$ = nullptr; }
//UNSUP	|	'(' {VARRESET_LIST(""); VARIO("input"); } property_port_list ')'
//UNSUP			{ VARRESET_NONLIST(""); }
//UNSUP	;

//UNSUPproperty_port_list<nodep>:  // ==IEEE: property_port_list
//UNSUP		property_port_item			{ $$ = $1; }
//UNSUP	|	property_port_list ',' property_port_item	{ }
//UNSUP	;

//UNSUPproperty_port_item<nodep>:  // IEEE: property_port_item/sequence_port_item
//UNSUP	//			// Merged in sequence_port_item
//UNSUP	//			// IEEE: property_lvar_port_direction ::= yINPUT
//UNSUP	//			// prop IEEE: [ yLOCAL [ yINPUT ] ] property_formal_type
//UNSUP	//			//	     id {variable_dimension} [ '=' property_actual_arg ]
//UNSUP	//			// seq IEEE: [ yLOCAL [ sequence_lvar_port_direction ] ] sequence_formal_type
//UNSUP	//			//           id {variable_dimension} [ '=' sequence_actual_arg ]
//UNSUP		property_port_itemFront property_port_itemAssignment { }
//UNSUP	;

//UNSUPproperty_port_itemFront:	// IEEE: part of property_port_item/sequence_port_item
//UNSUP		property_port_itemDirE property_formal_typeNoDt		{ VARDTYPE($2); }
//UNSUP	//			// data_type_or_implicit
//UNSUP	|	property_port_itemDirE data_type           	{ VARDTYPE($2); }
//UNSUP	|	property_port_itemDirE yVAR data_type      	{ VARDTYPE($3); }
//UNSUP	|	property_port_itemDirE yVAR implicit_typeE 	{ VARDTYPE($3); }
//UNSUP	|	property_port_itemDirE signingE rangeList  	{ VARDTYPE(SPACED($2,$3)); }
//UNSUP	|	property_port_itemDirE /*implicit*/        	{ /*VARDTYPE-same*/ }
//UNSUP	;

//UNSUPproperty_port_itemAssignment<nodep>:  // IEEE: part of property_port_item/sequence_port_item/checker_port_direction
//UNSUP		portSig variable_dimensionListE		{ VARDONE($<fl>1, $1, $2, ""); PINNUMINC(); }
//UNSUP	|	portSig variable_dimensionListE '=' property_actual_arg
//UNSUP			{ VARDONE($<fl>1, $1, $2, $4); PINNUMINC(); }
//UNSUP	;

//UNSUPproperty_port_itemDirE:
//UNSUP		/* empty */				{ $$ = nullptr; }
//UNSUP	|	yLOCAL__ETC				{ }
//UNSUP	|	yLOCAL__ETC port_direction		{ }
//UNSUP	;

//UNSUPproperty_declarationBody<nodep>:  // IEEE: part of property_declaration
//UNSUP		assertion_variable_declarationList property_statement_spec	{ }
//UNSUP	//			// IEEE-2012: Incorectly hasyCOVER ySEQUENCE then property_spec here.
//UNSUP	//			// Fixed in IEEE 1800-2017
//UNSUP	|	property_statement_spec			{ $$ = $1; }
//UNSUP	;

//UNSUPassertion_variable_declarationList: // IEEE: part of assertion_variable_declaration
//UNSUP		assertion_variable_declaration		{ $$ = $1; }
//UNSUP	|	assertion_variable_declarationList assertion_variable_declaration	{ }
//UNSUP	;

//UNSUPsequence_declaration<nodep>:  // ==IEEE: sequence_declaration
//UNSUP		sequence_declarationFront sequence_port_listE ';' sequence_declarationBody
//UNSUP			yENDSEQUENCE endLabelE
//UNSUP			{ SYMP->popScope($$); }
//UNSUP	;

//UNSUPsequence_declarationFront<nodep>:  // IEEE: part of sequence_declaration
//UNSUP		ySEQUENCE idAny/*new_sequence*/
//UNSUP			{ SYMP->pushNew($$); }
//UNSUP	;

//UNSUPsequence_port_listE<nodep>:  // IEEE: [ ( [ sequence_port_list ] ) ]
//UNSUP	//			// IEEE: sequence_lvar_port_direction ::= yINPUT | yINOUT | yOUTPUT
//UNSUP	//			// IEEE: [ yLOCAL [ sequence_lvar_port_direction ] ] sequence_formal_type
//UNSUP	//			//           id {variable_dimension} [ '=' sequence_actual_arg ]
//UNSUP	//			// All this is almost identically the same as a property.
//UNSUP	//			// Difference is only yINOUT/yOUTPUT (which might be added to 1800-2012)
//UNSUP	//			// and yPROPERTY.  So save some work.
//UNSUP		property_port_listE			{ $$ = $1; }
//UNSUP	;

//UNSUPproperty_formal_typeNoDt<nodep>:  // IEEE: property_formal_type (w/o implicit)
//UNSUP		sequence_formal_typeNoDt		{ $$ = $1; }
//UNSUP	|	yPROPERTY				{ }
//UNSUP	;

//UNSUPsequence_formal_typeNoDt<nodep>:  // ==IEEE: sequence_formal_type (w/o data_type_or_implicit)
//UNSUP	//			// IEEE: data_type_or_implicit
//UNSUP	//			// implicit expanded where used
//UNSUP		ySEQUENCE				{ }
//UNSUP	//			// IEEE-2009: yEVENT
//UNSUP	//			// already part of data_type.  Removed in 1800-2012.
//UNSUP	|	yUNTYPED				{ }
//UNSUP	;

//UNSUPsequence_declarationBody<nodep>:  // IEEE: part of sequence_declaration
//UNSUP	//			// 1800-2012 makes ';' optional
//UNSUP		assertion_variable_declarationList sexpr	{ }
//UNSUP	|	assertion_variable_declarationList sexpr ';'	{ }
//UNSUP	|	sexpr					{ $$ = $1; }
//UNSUP	|	sexpr ';'				{ $$ = $1; }
//UNSUP	;

property_spec<nodep>:			// IEEE: property_spec
	//UNSUP: This rule has been super-specialized to what is supported now
	//UNSUP remove below
		'@' '(' senitemEdge ')' yDISABLE yIFF '(' expr ')' pexpr
			{ $$ = new AstPropClocked($1, $3, $8, $10); }
	|	'@' '(' senitemEdge ')' pexpr	 	{ $$ = new AstPropClocked($1, $3, nullptr, $5); }
	//UNSUP remove above
	|	yDISABLE yIFF '(' expr ')' pexpr 	{ $$ = new AstPropClocked($4->fileline(), nullptr, $4, $6); }
	|	pexpr	 				{ $$ = new AstPropClocked($1->fileline(), nullptr, nullptr, $1); }
	;

//UNSUPproperty_statement_spec<nodep>:  // ==IEEE: property_statement_spec
//UNSUP	//			// IEEE: [ clocking_event ] [ yDISABLE yIFF '(' expression_or_dist ')' ] property_statement
//UNSUP		property_statement			{ $$ = $1; }
//UNSUP	|	yDISABLE yIFF '(' expr/*expression_or_dist*/ ')' property_statement	{ }
//UNSUP	//			// IEEE: clocking_event property_statement
//UNSUP	//			// IEEE: clocking_event yDISABLE yIFF '(' expr/*expression_or_dist*/ ')' property_statement
//UNSUP	//			// Both overlap pexpr:"clocking_event pexpr"  the difference is
//UNSUP	//			// property_statement:property_statementCaseIf so replicate it
//UNSUP	|	clocking_event property_statementCaseIf	{ }
//UNSUP	|	clocking_event yDISABLE yIFF '(' expr/*expression_or_dist*/ ')' property_statementCaseIf	{ }
//UNSUP	;

//UNSUPproperty_statement<nodep>:  // ==IEEE: property_statement
//UNSUP	//			// Doesn't make sense to have "pexpr ;" in pexpr rule itself, so we split out case/if
//UNSUP		pexpr ';'				{ $$ = $1; }
//UNSUP	//			// Note this term replicated in property_statement_spec
//UNSUP	//			// If committee adds terms, they may need to be there too.
//UNSUP	|	property_statementCaseIf		{ $$ = $1; }
//UNSUP	;

//UNSUPproperty_statementCaseIf<nodep>:  // IEEE: property_statement - minus pexpr
//UNSUP		yCASE '(' expr/*expression_or_dist*/ ')' property_case_itemList yENDCASE	{ }
//UNSUP	|	yCASE '(' expr/*expression_or_dist*/ ')' yENDCASE		{ }
//UNSUP	|	yIF '(' expr/*expression_or_dist*/ ')' pexpr  %prec prLOWER_THAN_ELSE	{ }
//UNSUP	|	yIF '(' expr/*expression_or_dist*/ ')' pexpr yELSE pexpr	{ }
//UNSUP	;

//UNSUPproperty_case_itemList<nodep>:  // IEEE: {property_case_item}
//UNSUP		property_case_item			{ $$ = $1; }
//UNSUP	|	property_case_itemList ',' property_case_item	{ $$ = AstNode::addNextNull($1, $3); }
//UNSUP	;

//UNSUPproperty_case_item<nodep>:  // ==IEEE: property_case_item
//UNSUP	//			// IEEE: expression_or_dist { ',' expression_or_dist } ':' property_statement
//UNSUP	//			// IEEE 1800-2012 changed from property_statement to property_expr
//UNSUP	//			// IEEE 1800-2017 changed to require the semicolon
//UNSUP		caseCondList ':' pexpr			{ }
//UNSUP	|	caseCondList ':' pexpr ';'		{ }
//UNSUP	|	yDEFAULT pexpr				{ }
//UNSUP	|	yDEFAULT ':' pexpr ';'			{ }
//UNSUP	;

//UNSUPpev_expr<nodep>:  // IEEE: property_actual_arg | expr
//UNSUP	//			//       which expands to pexpr | event_expression
//UNSUP	//			// Used in port and function calls, when we can't know yet if something
//UNSUP	//			// is a function/sequence/property or instance/checker pin.
//UNSUP	//
//UNSUP	//			// '(' pev_expr ')'
//UNSUP	//			// Already in pexpr
//UNSUP	//			// IEEE: event_expression ',' event_expression
//UNSUP	//			// ','s are legal in event_expressions, but parens required to avoid conflict with port-sep-,
//UNSUP	//			// IEEE: event_expression yOR event_expression
//UNSUP	//			// Already in pexpr - needs removal there
//UNSUP	//			// IEEE: event_expression yIFF expr
//UNSUP	//			// Already in pexpr - needs removal there
//UNSUP	//
//UNSUP		senitemEdge				{ $$ = $1; }
//UNSUP	//
//UNSUP	//============= pexpr rules copied for pev_expr
//UNSUP	|	BISONPRE_COPY_ONCE(pexpr,{s/~o~p/pev_/g; })	// {copied}
//UNSUP	//
//UNSUP	//============= sexpr rules copied for pev_expr
//UNSUP	|	BISONPRE_COPY_ONCE(sexpr,{s/~p~s/pev_/g; })	// {copied}
//UNSUP	//
//UNSUP	//============= expr rules copied for pev_expr
//UNSUP	|	BISONPRE_COPY_ONCE(expr,{s/~l~/pev_/g; s/~p~/pev_/g; s/~noPar__IGNORE~/yP_PAR__IGNORE /g; })	// {copied}
//UNSUP	;

pexpr<nodep>:  // IEEE: property_expr  (The name pexpr is important as regexps just add an "p" to expr.)
	//UNSUP: This rule has been super-specialized to what is supported now
	//UNSUP remove below
		expr yP_ORMINUSGT pexpr			{ $$ = new AstLogOr($2, new AstLogNot($2, $1), $3); }
	|	expr yP_OREQGT pexpr			{ $$ = new AstImplication($2, $1, $3); }
	|	expr					{ $$ = $1; }
	//UNSUP remove above, use below:
	//
	//			// IEEE: sequence_expr
	//			// Expanded below
	//
	//			// IEEE: '(' pexpr ')'
	//			// Expanded below
	//
	//UNSUP	yNOT pexpr %prec prNEGATION		{ }
	//UNSUP	ySTRONG '(' sexpr ')'			{ }
	//UNSUP	yWEAK '(' sexpr ')'			{ }
	//			// IEEE: pexpr yOR pexpr
	//			// IEEE: pexpr yAND pexpr
	//			// Under ~p~sexpr and/or ~p~sexpr
	//
	//			// IEEE: "sequence_expr yP_ORMINUSGT pexpr"
	//			// Instead we use pexpr to prevent conflicts
	//UNSUP	~o~pexpr yP_ORMINUSGT pexpr		{ }
	//UNSUP	~o~pexpr yP_OREQGT pexpr		{ }
	//
	//			// IEEE-2009: property_statement
	//			// IEEE-2012: yIF and yCASE
	//UNSUP	property_statementCaseIf		{ }
	//
	//UNSUP	~o~pexpr/*sexpr*/ yP_POUNDMINUSPD pexpr	{ }
	//UNSUP	~o~pexpr/*sexpr*/ yP_POUNDEQPD pexpr	{ }
	//UNSUP	yNEXTTIME pexpr				{ }
	//UNSUP	yS_NEXTTIME pexpr			{ }
	//UNSUP	yNEXTTIME '[' expr/*const*/ ']' pexpr %prec yNEXTTIME		{ }
	//UNSUP	yS_NEXTTIME '[' expr/*const*/ ']' pexpr	%prec yS_NEXTTIME	{ }
	//UNSUP	yALWAYS pexpr				{ }
	//UNSUP	yALWAYS '[' cycle_delay_const_range_expression ']' pexpr  %prec yALWAYS	{ }
	//UNSUP	yS_ALWAYS '[' constant_range ']' pexpr  %prec yS_ALWAYS		{ }
	//UNSUP	yS_EVENTUALLY pexpr			{ }
	//UNSUP	yEVENTUALLY '[' constant_range ']' pexpr  %prec yEVENTUALLY	{ }
	//UNSUP	yS_EVENTUALLY '[' cycle_delay_const_range_expression ']' pexpr  %prec yS_EVENTUALLY	{ }
	//UNSUP	~o~pexpr yUNTIL pexpr			{ }
	//UNSUP	~o~pexpr yS_UNTIL pexpr			{ }
	//UNSUP	~o~pexpr yUNTIL_WITH pexpr		{ }
	//UNSUP	~o~pexpr yS_UNTIL_WITH pexpr		{ }
	//UNSUP	~o~pexpr yIMPLIES pexpr			{ }
	//			// yIFF also used by event_expression
	//UNSUP	~o~pexpr yIFF ~o~pexpr			{ }
	//UNSUP	yACCEPT_ON '(' expr/*expression_or_dist*/ ')' pexpr  %prec yACCEPT_ON	{ }
	//UNSUP	yREJECT_ON '(' expr/*expression_or_dist*/ ')' pexpr  %prec yREJECT_ON	{ }
	//UNSUP	ySYNC_ACCEPT_ON '(' expr/*expression_or_dist*/ ')' pexpr %prec ySYNC_ACCEPT_ON	{ }
	//UNSUP	ySYNC_REJECT_ON '(' expr/*expression_or_dist*/ ')' pexpr %prec ySYNC_REJECT_ON	{ }
	//
	//			// IEEE: "property_instance"
	//			// Looks just like a function/method call
	//
	//			// Note "clocking_event pexpr" overlaps property_statement_spec: clocking_event property_statement
	//
	//			// Include property_specDisable to match property_spec rule
	//UNSUP	clocking_event yDISABLE yIFF '(' expr ')' pexpr	%prec prSEQ_CLOCKING	{ }
	//
	//============= sexpr rules copied for property_expr
	//UNSUP	BISONPRE_COPY_ONCE(sexpr,{s/~p~s/p/g; })	// {copied}
	//
	//============= expr rules copied for property_expr
	//UNSUP	BISONPRE_COPY_ONCE(expr,{s/~l~/p/g; s/~p~/p/g; s/~noPar__IGNORE~/yP_PAR__IGNORE /g; })	// {copied}
	;

//UNSUPsexpr<nodep>:  // ==IEEE: sequence_expr  (The name sexpr is important as regexps just add an "s" to expr.)
//UNSUP	//			// ********* RULES COPIED IN sequence_exprProp
//UNSUP	//			// For precedence, see IEEE 17.7.1
//UNSUP	//
//UNSUP	// 			// IEEE: "cycle_delay_range sequence_expr { cycle_delay_range sequence_expr }"
//UNSUP	//			// IEEE: "sequence_expr cycle_delay_range sequence_expr { cycle_delay_range sequence_expr }"
//UNSUP	//			// Both rules basically mean we can repeat sequences, so make it simpler:
//UNSUP		cycle_delay_range sexpr	 %prec yP_POUNDPOUND	{ }
//UNSUP	|	~p~sexpr cycle_delay_range sexpr %prec prPOUNDPOUND_MULTI	{ }
//UNSUP	//
//UNSUP	//			// IEEE: expression_or_dist [ boolean_abbrev ]
//UNSUP	//			// Note expression_or_dist includes "expr"!
//UNSUP	//			// sexpr/*sexpression_or_dist*/	 --- Hardcoded below
//UNSUP	|	~p~sexpr/*sexpression_or_dist*/ boolean_abbrev	{ }
//UNSUP	//
//UNSUP	//			// IEEE: "sequence_instance [ sequence_abbrev ]"
//UNSUP	//			// version without sequence_abbrev looks just like normal function call
//UNSUP	//			// version w/sequence_abbrev matches above; expression_or_dist:expr:func boolean_abbrev:sequence_abbrev
//UNSUP	//
//UNSUP	//			// IEEE: '(' expression_or_dist {',' sequence_match_item } ')' [ boolean_abbrev ]
//UNSUP	//			// IEEE: '(' sexpr {',' sequence_match_item } ')' [ sequence_abbrev ]
//UNSUP	//			// As sequence_expr includes expression_or_dist, and boolean_abbrev includes sequence_abbrev:
//UNSUP	//			// '(' sequence_expr {',' sequence_match_item } ')' [ boolean_abbrev ]
//UNSUP	//			// "'(' sexpr ')' boolean_abbrev" matches "[sexpr:'(' expr ')'] boolean_abbrev" so we can simply drop it
//UNSUP	|	'(' ~p~sexpr ')'			{ $<fl>$=$<fl>1; $$=$1+$2+$3; }
//UNSUP	|	'(' ~p~sexpr ',' sequence_match_itemList ')'	{ }
//UNSUP	//
//UNSUP	//			// AND/OR are between pexprs OR sexprs
//UNSUP	|	~p~sexpr yAND ~p~sexpr			{ $<fl>$=$<fl>1; $$=$1+$2+$3; }
//UNSUP	|	~p~sexpr yOR ~p~sexpr			{ $<fl>$=$<fl>1; $$=$1+$2+$3; }
//UNSUP	//			// Intersect always has an sexpr rhs
//UNSUP	|	~p~sexpr yINTERSECT sexpr		{ $<fl>$=$<fl>1; $$=$1+$2+$3; }
//UNSUP	//
//UNSUP	|	yFIRST_MATCH '(' sexpr ')'		{ }
//UNSUP	|	yFIRST_MATCH '(' sexpr ',' sequence_match_itemList ')'	{ }
//UNSUP	|	~p~sexpr/*sexpression_or_dist*/ yTHROUGHOUT sexpr		{ }
//UNSUP	//			// Below pexpr's are really sequence_expr, but avoid conflict
//UNSUP	//			// IEEE: sexpr yWITHIN sexpr
//UNSUP	|	~p~sexpr yWITHIN sexpr			{ $<fl>$=$<fl>1; $$=$1+$2+$3; }
//UNSUP	//			// Note concurrent_assertion had duplicate rule for below
//UNSUP	|	clocking_event ~p~sexpr %prec prSEQ_CLOCKING	{ }
//UNSUP	//
//UNSUP	//============= expr rules copied for sequence_expr
//UNSUP	|	BISONPRE_COPY_ONCE(expr,{s/~l~/s/g; s/~p~/s/g; s/~noPar__IGNORE~/yP_PAR__IGNORE /g; })	// {copied}
//UNSUP	;

//UNSUPcycle_delay_range<nodep>:  // IEEE: ==cycle_delay_range
//UNSUP	//			// These three terms in 1800-2005 ONLY
//UNSUP		yP_POUNDPOUND yaINTNUM			{ }
//UNSUP	|	yP_POUNDPOUND id			{ }
//UNSUP	|	yP_POUNDPOUND '(' constExpr ')'		{ }
//UNSUP	//			// In 1800-2009 ONLY:
//UNSUP	//			// IEEE: yP_POUNDPOUND constant_primary
//UNSUP	//			// UNSUP: This causes a big grammer ambiguity
//UNSUP	//			// as ()'s mismatch between primary and the following statement
//UNSUP	//			// the sv-ac committee has been asked to clarify  (Mantis 1901)
//UNSUP	|	yP_POUNDPOUND '[' cycle_delay_const_range_expression ']'	{ }
//UNSUP	|	yP_POUNDPOUND yP_BRASTAR ']'		{ }
//UNSUP	|	yP_POUNDPOUND yP_BRAPLUSKET		{ }
//UNSUP	;

//UNSUPsequence_match_itemList<nodep>:  // IEEE: [sequence_match_item] part of sequence_expr
//UNSUP		sequence_match_item			{ $$ = $1; }
//UNSUP	|	sequence_match_itemList ',' sequence_match_item	{ }
//UNSUP	;

//UNSUPsequence_match_item<nodep>:  // ==IEEE: sequence_match_item
//UNSUP	//			// IEEE says: operator_assignment
//UNSUP	//			// IEEE says: inc_or_dec_expression
//UNSUP	//			// IEEE says: subroutine_call
//UNSUP	//			// This is the same list as...
//UNSUP		for_step_assignment			{ $$ = $1; }
//UNSUP	;

//UNSUPboolean_abbrev<nodep>:  // ==IEEE: boolean_abbrev
//UNSUP	//			// IEEE: consecutive_repetition
//UNSUP		yP_BRASTAR const_or_range_expression ']'	{ }
//UNSUP	|	yP_BRASTAR ']'				{ }
//UNSUP	|	yP_BRAPLUSKET				{ $$ = $1; }
//UNSUP	//			// IEEE: non_consecutive_repetition
//UNSUP	|	yP_BRAEQ const_or_range_expression ']'		{ }
//UNSUP	//			// IEEE: goto_repetition
//UNSUP	|	yP_BRAMINUSGT const_or_range_expression ']'	{ }
//UNSUP	;

//UNSUPconst_or_range_expression<nodep>:  // ==IEEE: const_or_range_expression
//UNSUP		constExpr				{ $$ = $1; }
//UNSUP	|	cycle_delay_const_range_expression	{ }
//UNSUP	;

//UNSUPconstant_range<nodep>:  // ==IEEE: constant_range
//UNSUP		constExpr ':' constExpr			{ }
//UNSUP	;

//UNSUPcycle_delay_const_range_expression<nodep>:  // ==IEEE: cycle_delay_const_range_expression
//UNSUP	//				// Note '$' is part of constExpr
//UNSUP		constExpr ':' constExpr			{ }
//UNSUP	;

//************************************************
// Let

//************************************************
// Covergroup

//UNSUPcovergroup_declaration<nodep>:  // ==IEEE: covergroup_declaration
//UNSUP		covergroup_declarationFront coverage_eventE ';' coverage_spec_or_optionListE
//UNSUP			yENDGROUP endLabelE
//UNSUP			{ PARSEP->endgroupCb($<fl>5,$5);
//UNSUP			  SYMP->popScope($$); }
//UNSUP	|	covergroup_declarationFront '(' tf_port_listE ')' coverage_eventE ';' coverage_spec_or_optionListE
//UNSUP			yENDGROUP endLabelE
//UNSUP			{ PARSEP->endgroupCb($<fl>8,$8);
//UNSUP			  SYMP->popScope($$); }
//UNSUP	;

//UNSUPcovergroup_declarationFront:  // IEEE: part of covergroup_declaration
//UNSUP		yCOVERGROUP idAny
//UNSUP 			{ SYMP->pushNew($$);
//UNSUP			  PARSEP->covergroupCb($<fl>1,$1,$2); }
//UNSUP	;

//UNSUPcgexpr<nodep>:  // IEEE-2012: covergroup_expression, before that just expression
//UNSUP		expr					{ $$ = $1; }
//UNSUP	;

//UNSUPcoverage_spec_or_optionListE<nodep>:  // IEEE: [{coverage_spec_or_option}]
//UNSUP		/* empty */				{ $$ = nullptr; }
//UNSUP	|	coverage_spec_or_optionList		{ $$ = $1; }
//UNSUP	;

//UNSUPcoverage_spec_or_optionList<nodep>:  // IEEE: {coverage_spec_or_option}
//UNSUP		coverage_spec_or_option			{ $$ = $1; }
//UNSUP	|	coverage_spec_or_optionList coverage_spec_or_option	{ $$ = AstNode::addNextNull($1, $2); }
//UNSUP	;

//UNSUPcoverage_spec_or_option<nodep>:  // ==IEEE: coverage_spec_or_option
//UNSUP	//			// IEEE: coverage_spec
//UNSUP		cover_point				{ $$ = $1; }
//UNSUP	|	cover_cross				{ $$ = $1; }
//UNSUP	|	coverage_option ';'			{ $$ = $1; }
//UNSUP	|	error					{ $$ = nullptr; }
//UNSUP	;

//UNSUPcoverage_option:  // ==IEEE: coverage_option
//UNSUP	//			// option/type_option aren't really keywords
//UNSUP		id/*yOPTION | yTYPE_OPTION*/ '.' idAny/*member_identifier*/ '=' expr	{ }
//UNSUP	;

//UNSUPcover_point:  // ==IEEE: cover_point
//UNSUP		/**/               yCOVERPOINT expr iffE bins_or_empty	{ }
//UNSUP	//			// IEEE-2012: class_scope before an ID
//UNSUP	|	/**/           /**/ /**/    id ':' yCOVERPOINT expr iffE bins_or_empty	{ }
//UNSUP	|	class_scope_id ':' yCOVERPOINT expr iffE bins_or_empty	{ }
//UNSUP	|	class_scope_id id data_type id ':' yCOVERPOINT expr iffE bins_or_empty	{ }
//UNSUP	|	class_scope_id id /**/      id ':' yCOVERPOINT expr iffE bins_or_empty	{ }
//UNSUP	|	/**/           id /**/      id ':' yCOVERPOINT expr iffE bins_or_empty	{ }
//UNSUP	//			// IEEE-2012:
//UNSUP	|	bins_or_empty				{ $$ = $1; }
//UNSUP	;

//UNSUPiffE<nodep>:  // IEEE: part of cover_point, others
//UNSUP		/* empty */				{ $$ = nullptr; }
//UNSUP	|	yIFF '(' expr ')'			{ }
//UNSUP	;

//UNSUPbins_or_empty<nodep>:  // ==IEEE: bins_or_empty
//UNSUP		'{' bins_or_optionsList '}'		{ $$ = $2; }
//UNSUP	|	'{' '}'					{ $$ = nullptr; }
//UNSUP	|	';'					{ $$ = nullptr; }
//UNSUP	;

//UNSUPbins_or_optionsList<nodep>:  // IEEE: { bins_or_options ';' }
//UNSUP		bins_or_options ';'			{ $$ = $1; }
//UNSUP	|	bins_or_optionsList bins_or_options ';'	{ $$ = AstNode::addNextNull($1, $2); }
//UNSUP	;

//UNSUPbins_or_options<nodep>:  // ==IEEE: bins_or_options
//UNSUP	//			// Superset of IEEE - we allow []'s in more places
//UNSUP		coverage_option				{ $$ = $1; }
//UNSUP	//			// Can't use wildcardE as results in conflicts
//UNSUP	|	/**/      bins_keyword id/*bin_identifier*/ bins_orBraE '=' '{' open_range_list '}' iffE	{ }
//UNSUP	|	yWILDCARD bins_keyword id/*bin_identifier*/ bins_orBraE '=' '{' open_range_list '}' iffE	{ }
//UNSUP	|	/**/      bins_keyword id/*bin_identifier*/ bins_orBraE '=' '{' open_range_list '}' yWITH__CUR '{' cgexpr ')' iffE	{ }
//UNSUP	|	yWILDCARD bins_keyword id/*bin_identifier*/ bins_orBraE '=' '{' open_range_list '}' yWITH__CUR '{' cgexpr ')' iffE	{ }
//UNSUP	//
//UNSUP	//			// cgexpr part of trans_list
//UNSUP	//
//UNSUP	|	/**/      bins_keyword id/*bin_identifier*/ bins_orBraE '=' trans_list iffE	{ }
//UNSUP	|	yWILDCARD bins_keyword id/*bin_identifier*/ bins_orBraE '=' trans_list iffE	{ }
//UNSUP	//
//UNSUP	|	bins_keyword id/*bin_identifier*/ bins_orBraE '=' yDEFAULT iffE	{ }
//UNSUP	//
//UNSUP	|	bins_keyword id/*bin_identifier*/ bins_orBraE '=' yDEFAULT ySEQUENCE iffE { }
//UNSUP	;

//UNSUPbins_orBraE<nodep>:  // IEEE: part of bins_or_options:
//UNSUP		/* empty */				{ $$ = nullptr; }
//UNSUP	|	'[' ']'					{ }
//UNSUP	|	'[' cgexpr ']'				{ }
//UNSUP	;

//UNSUPbins_keyword:  // ==IEEE: bins_keyword
//UNSUP		yBINS					{ }
//UNSUP	|	yILLEGAL_BINS				{ }
//UNSUP	|	yIGNORE_BINS				{ }
//UNSUP	;

//UNSUPcovergroup_range_list:  // ==IEEE: covergroup_range_list
//UNSUP	 	covergroup_value_range			{ $$ = $1; }
//UNSUP	|	covergroup_range_list ',' covergroup_value_range	{ $$ = AstNode::addNextNull($1, $3); }
//UNSUP	;

//UNSUPtrans_list:  // ==IEEE: trans_list
//UNSUP		'(' trans_set ')'			{ $$ = $2; }
//UNSUP	|	trans_list ',' '(' trans_set ')'	{ }
//UNSUP	;

//UNSUPtrans_set:  // ==IEEE: trans_set
//UNSUP		trans_range_list			{ $$ = $1; }
//UNSUP	//			// Note the { => } in the grammer, this is really a list
//UNSUP	|	trans_set yP_EQGT trans_range_list	{ }
//UNSUP	;

//UNSUPtrans_range_list:  // ==IEEE: trans_range_list
//UNSUP		trans_item				{ $$ = $1; }
//UNSUP	|	trans_item yP_BRASTAR repeat_range ']'	{ }
//UNSUP	|	trans_item yP_BRAMINUSGT repeat_range ']' { }
//UNSUP	|	trans_item yP_BRAEQ repeat_range ']'	{ }
//UNSUP	;

//UNSUPtrans_item:  // ==IEEE: range_list
//UNSUP		covergroup_range_list			{ $$ = $1; }
//UNSUP	;

//UNSUPrepeat_range:  // ==IEEE: repeat_range
//UNSUP		cgexpr					{ $$ = $1; }
//UNSUP	|	cgexpr ':' cgexpr			{ $$ = AstNode::addNextNull($1, $3); }
//UNSUP	;

//UNSUPcover_cross:  // ==IEEE: cover_cross
//UNSUP	 	id/*cover_point_identifier*/ ':' yCROSS list_of_cross_items iffE cross_body	{ }
//UNSUP	|	/**/				 yCROSS list_of_cross_items iffE cross_body	{ }
//UNSUP	;

//UNSUPlist_of_cross_items<nodep>:  // ==IEEE: list_of_cross_items
//UNSUP		cross_item ',' cross_item		{ $$ = AstNode::addNextNull($1, $3); }
//UNSUP	|	cross_item ',' cross_item ',' cross_itemList	{ }
//UNSUP	;

//UNSUPcross_itemList<nodep>:  // IEEE: part of list_of_cross_items
//UNSUP		cross_item				{ $$ = nullptr; }
//UNSUP	|	cross_itemList ',' cross_item		{ $$ = AstNode::addNextNull($1, $3); }
//UNSUP	;

//UNSUPcross_item<nodep>:  // ==IEEE: cross_item
//UNSUP		idAny/*cover_point_identifier or variable_identifier*/		{ $$ = $1; }
//UNSUP	;

//UNSUPcross_body:  // ==IEEE: cross_body
//UNSUP		'{' '}'					{ $$ = nullptr; }
//UNSUP	//			// IEEE-2012: No semicolon here, mistake in spec
//UNSUP	|	'{' cross_body_itemSemiList '}'		{ $$ = $1; }
//UNSUP	|	';'					{ $$ = nullptr; }
//UNSUP	;

//UNSUPcross_body_itemSemiList:  // IEEE: part of cross_body
//UNSUP		cross_body_item ';'			{ $$ = $1; }
//UNSUP	|	cross_body_itemSemiList cross_body_item ';' { $$ = AstNode::addNextNull($1, $2); }
//UNSUP	;

//UNSUPcross_body_item<nodep>:  // ==IEEE: cross_body_item
//UNSUP	//			// IEEE: our semicolon is in the list
//UNSUP		bins_selection_or_option		{ $$ = $1; }
//UNSUP	|	function_declaration			{ $$ = $1; }
//UNSUP	;

//UNSUPbins_selection_or_option<nodep>:  // ==IEEE: bins_selection_or_option
//UNSUP		coverage_option				{ $$ = $1; }
//UNSUP	|	bins_selection				{ $$ = $1; }
//UNSUP	;

//UNSUPbins_selection:  // ==IEEE: bins_selection
//UNSUP		bins_keyword idAny/*new-bin_identifier*/ '=' select_expression iffE	{ }
//UNSUP	;

//UNSUPselect_expression:  // ==IEEE: select_expression
//UNSUP	//			// IEEE: select_condition expanded here
//UNSUP		yBINSOF '(' bins_expression ')'		{ }
//UNSUP	|	yBINSOF '(' bins_expression ')' yINTERSECT '{' covergroup_range_list '}'	{ }
//UNSUP	|	yWITH__PAREN '(' cgexpr ')'		{ }
//UNSUP	//			// IEEE-2012: Need clarification as to precedence
//UNSUP	//UNSUP	yWITH__PAREN '(' cgexpr ')' yMATCHES cgexpr	{ }
//UNSUP	|	'!' yBINSOF '(' bins_expression ')'		{ }
//UNSUP	|	'!' yBINSOF '(' bins_expression ')' yINTERSECT '{' covergroup_range_list '}'	{ }
//UNSUP	|	'!' yWITH__PAREN '(' cgexpr ')'		{ }
//UNSUP	//			// IEEE-2012: Need clarification as to precedence
//UNSUP	//UNSUP	'!' yWITH__PAREN '(' cgexpr ')' yMATCHES cgexpr	{ }
//UNSUP	|	select_expression yP_ANDAND select_expression	{ }
//UNSUP	|	select_expression yP_OROR   select_expression	{ }
//UNSUP	|	'(' select_expression ')'			{ $$ = $2; }
//UNSUP	//			// IEEE-2012: cross_identifier
//UNSUP	//			// Part of covergroup_expression - generic identifier
//UNSUP	//			// IEEE-2012: Need clarification as to precedence
//UNSUP	//UNSUP	covergroup_expression [ yMATCHES covergroup_expression ]
//UNSUP	;

//UNSUPbins_expression:  // ==IEEE: bins_expression
//UNSUP	//			// "cover_point_identifier" and "variable_identifier" look identical
//UNSUP		id/*variable_identifier or cover_point_identifier*/	{ $$ = $1; }
//UNSUP	|	id/*cover_point_identifier*/ '.' idAny/*bins_identifier*/	{ }
//UNSUP	;

//UNSUPcoverage_eventE:  // IEEE: [ coverage_event ]
//UNSUP		/* empty */				{ $$ = nullptr; }
//UNSUP	|	clocking_event				{ $$ = $1; }
//UNSUP	|	yWITH__ETC function idAny/*"sample"*/ '(' tf_port_listE ')'	{ }
//UNSUP	|	yP_ATAT '(' block_event_expression ')'	{ }
//UNSUP	;

//UNSUPblock_event_expression:  // ==IEEE: block_event_expression
//UNSUP		block_event_expressionTerm		{ $$ = $1; }
//UNSUP	|	block_event_expression yOR block_event_expressionTerm	{ }
//UNSUP	;

//UNSUPblock_event_expressionTerm:  // IEEE: part of block_event_expression
//UNSUP		yBEGIN hierarchical_btf_identifier	{ }
//UNSUP	|	yEND   hierarchical_btf_identifier	{ }
//UNSUP	;

//UNSUPhierarchical_btf_identifier:  // ==IEEE: hierarchical_btf_identifier
//UNSUP	//			// hierarchical_tf_identifier + hierarchical_block_identifier
//UNSUP		hierarchical_identifier/*tf_or_block*/	{ $$ = $1; }
//UNSUP	//			// method_identifier
//UNSUP	|	hierarchical_identifier class_scope_id	{ }
//UNSUP	|	hierarchical_identifier id		{ }
//UNSUP	;

//**********************************************************************
// Randsequence

//UNSUPrandsequence_statement<nodep>:  // ==IEEE: randsequence_statement
//UNSUP		yRANDSEQUENCE '('    ')' productionList yENDSEQUENCE	{ }
//UNSUP	|	yRANDSEQUENCE '(' id/*production_identifier*/ ')' productionList yENDSEQUENCE	{ }
//UNSUP	;

//UNSUPproductionList<nodep>:  // IEEE: production+
//UNSUP		production				{ $$ = $1; }
//UNSUP	|	productionList production		{ $$ = AstNode::addNextNull($1, $2); }
//UNSUP	;

//UNSUPproduction<nodep>:  // ==IEEE: production
//UNSUP		productionFront ':' rs_ruleList ';'	{ }
//UNSUP	;

//UNSUPproductionFront<nodep>:  // IEEE: part of production
//UNSUP		function_data_type id/*production_identifier*/	{ }
//UNSUP	|	/**/		   id/*production_identifier*/	{ $$ = $1; }
//UNSUP	|	function_data_type id/*production_identifier*/ '(' tf_port_listE ')'	{ }
//UNSUP	|	/**/		   id/*production_identifier*/ '(' tf_port_listE ')'	{ }
//UNSUP	;

//UNSUPrs_ruleList<nodep>:  // IEEE: rs_rule+ part of production
//UNSUP		rs_rule					{ $$ = $1; }
//UNSUP	|	rs_ruleList '|' rs_rule			{ $$ = AstNode::addNextNull($1, $3); }
//UNSUP	;

//UNSUPrs_rule<nodep>:  // ==IEEE: rs_rule
//UNSUP		rs_production_list			{ $$ = $1; }
//UNSUP	|	rs_production_list yP_COLONEQ weight_specification	{ }
//UNSUP	|	rs_production_list yP_COLONEQ weight_specification rs_code_block	{ }
//UNSUP	;

//UNSUPrs_production_list<nodep>:  // ==IEEE: rs_production_list
//UNSUP		rs_prodList				{ $$ = $1; }
//UNSUP	|	yRAND yJOIN /**/         production_item production_itemList	{ }
//UNSUP	|	yRAND yJOIN '(' expr ')' production_item production_itemList	{ }
//UNSUP	;

//UNSUPweight_specification<nodep>:  // ==IEEE: weight_specification
//UNSUP		yaINTNUM				{ $$ = $1; }
//UNSUP	|	idClassSel/*ps_identifier*/		{ $$ = $1; }
//UNSUP	|	'(' expr ')'				{ $$ = $2; }
//UNSUP	;

//UNSUPrs_code_block<nodep>:  // ==IEEE: rs_code_block
//UNSUP		'{' '}'					{ $$ = nullptr; }
//UNSUP	|	'{' rs_code_blockItemList '}'		{ $$ = $2; }
//UNSUP	;

//UNSUPrs_code_blockItemList<nodep>:  // IEEE: part of rs_code_block
//UNSUP		rs_code_blockItem			{ $$ = $1; }
//UNSUP	|	rs_code_blockItemList rs_code_blockItem		{ $$ = AstNode::addNextNull($1, $2); }
//UNSUP	;

//UNSUPrs_code_blockItem<nodep>:  // IEEE: part of rs_code_block
//UNSUP		data_declaration			{ $$ = $1; }
//UNSUP	|	stmt					{ $$ = $1; }
//UNSUP	;

//UNSUPrs_prodList<nodep>:  // IEEE: rs_prod+
//UNSUP		rs_prod					{ $$ = $1; }
//UNSUP	|	rs_prodList rs_prod			{ $$ = AstNode::addNextNull($1, $2); }
//UNSUP	;

//UNSUPrs_prod<nodep>:  // ==IEEE: rs_prod
//UNSUP		production_item				{ $$ = $1; }
//UNSUP	|	rs_code_block				{ $$ = $1; }
//UNSUP	//			// IEEE: rs_if_else
//UNSUP	|	yIF '(' expr ')' production_item %prec prLOWER_THAN_ELSE	{ }
//UNSUP	|	yIF '(' expr ')' production_item yELSE production_item		{ }
//UNSUP	//			// IEEE: rs_repeat
//UNSUP	|	yREPEAT '(' expr ')' production_item	{ }
//UNSUP	//			// IEEE: rs_case
//UNSUP	|	yCASE '(' expr ')' rs_case_itemList yENDCASE	{ }
//UNSUP	;

//UNSUPproduction_itemList<nodep>:  // IEEE: production_item+
//UNSUP		production_item				{ $$ = $1; }
//UNSUP	|	production_itemList production_item	{ $$ = AstNode::addNextNull($1, $2); }
//UNSUP	;

//UNSUPproduction_item<nodep>:  // ==IEEE: production_item
//UNSUP		id/*production_identifier*/ 		{ $$ = $1; }
//UNSUP	|	id/*production_identifier*/ '(' list_of_argumentsE ')'	{ }
//UNSUP	;

//UNSUPrs_case_itemList<nodep>:  // IEEE: rs_case_item+
//UNSUP		rs_case_item				{ $$ = $1; }
//UNSUP	|	rs_case_itemList rs_case_item		{ $$ = AstNode::addNextNull($1, $2); }
//UNSUP	;

//UNSUPrs_case_item<nodep>:  // ==IEEE: rs_case_item
//UNSUP		caseCondList ':' production_item ';'	{ }
//UNSUP	|	yDEFAULT production_item ';'		{ }
//UNSUP	|	yDEFAULT ':' production_item ';'	{ }
//UNSUP	;

//**********************************************************************
// Checker

//UNSUPchecker_declaration<nodep>:  // ==IEEE: part of checker_declaration
//UNSUP		checkerFront checker_port_listE ';'
//UNSUP			checker_or_generate_itemListE yENDCHECKER endLabelE
//UNSUP			{ SYMP->popScope($$); }
//UNSUP	;

//UNSUPcheckerFront<nodep>:  // IEEE: part of checker_declaration
//UNSUP		yCHECKER idAny/*checker_identifier*/
//UNSUP			{ SYMP->pushNew($$); }
//UNSUP	;

//UNSUPchecker_port_listE<nodep>:  // IEEE: [ ( [ checker_port_list ] ) ]
//UNSUP	//			// checker_port_item is basically the same as property_port_item, minus yLOCAL::
//UNSUP	//			// Want to bet 1800-2012 adds local to checkers?
//UNSUP		property_port_listE			{ $$ = $1; }
//UNSUP	;

//UNSUPchecker_or_generate_itemListE<nodep>:  // IEEE: [{ checker_or_generate_itemList }]
//UNSUP		/* empty */				{ $$ = nullptr; }
//UNSUP	|	checker_or_generate_itemList		{ $$ = $1; }
//UNSUP	;

//UNSUPchecker_or_generate_itemList<nodep>:  // IEEE: { checker_or_generate_itemList }
//UNSUP		checker_or_generate_item		{ $$ = $1; }
//UNSUP	|	checker_or_generate_itemList checker_or_generate_item	{ $$ = AstNode::addNextNull($1, $2); }
//UNSUP	;

//UNSUPchecker_or_generate_item<nodep>:  // ==IEEE: checker_or_generate_item
//UNSUP		checker_or_generate_item_declaration	{ $$ = $1; }
//UNSUP	|	initial_construct			{ $$ = $1; }
//UNSUP	//			// IEEE: checker_construct
//UNSUP	|	yALWAYS stmtBlock			{ }
//UNSUP	|	final_construct				{ $$ = $1; }
//UNSUP	|	assertion_item				{ $$ = $1; }
//UNSUP	|	continuous_assign			{ $$ = $1; }
//UNSUP	|	checker_generate_item			{ $$ = $1; }
//UNSUP	;

//UNSUPchecker_or_generate_item_declaration<nodep>:  // ==IEEE: checker_or_generate_item_declaration
//UNSUP		data_declaration			{ $$ = $1; }
//UNSUP	|	yRAND data_declaration			{ }
//UNSUP	|	function_declaration			{ $$ = $1; }
//UNSUP	|	checker_declaration			{ $$ = $1; }
//UNSUP	|	assertion_item_declaration		{ $$ = $1; }
//UNSUP	|	covergroup_declaration			{ $$ = $1; }
//UNSUP	//	// IEEE deprecated: overload_declaration
//UNSUP	|	genvar_declaration			{ $$ = $1; }
//UNSUP	|	clocking_declaration			{ $$ = $1; }
//UNSUP	|	yDEFAULT yCLOCKING id/*clocking_identifier*/ ';'	{ }
//UNSUP	|	yDEFAULT yDISABLE yIFF expr/*expression_or_dist*/ ';'	{ }
//UNSUP	|	';'					{ $$ = nullptr; }
//UNSUP	;

//UNSUPchecker_generate_item<nodep>:  // ==IEEE: checker_generate_item
//UNSUP	//			// Specialized for checker so need "c_" prefixes here
//UNSUP		c_loop_generate_construct		{ $$ = $1; }
//UNSUP	|	c_conditional_generate_construct	{ $$ = $1; }
//UNSUP	|	c_generate_region			{ $$ = $1; }
//UNSUP	//
//UNSUP	|	elaboration_system_task			{ $$ = $1; }
//UNSUP	;

//UNSUPchecker_instantiation<nodep>:
//UNSUP	//			// Only used for procedural_assertion_item's
//UNSUP	//			// Version in concurrent_assertion_item looks like etcInst
//UNSUP	//			// Thus instead of *_checker_port_connection we can use etcInst's cellpinList
//UNSUP		id/*checker_identifier*/ id '(' cellpinList ')' ';'	{ }
//UNSUP	;

//**********************************************************************
// Class

class_declaration<nodep>:	// ==IEEE: part of class_declaration
	//			// IEEE-2012: using this also for interface_class_declaration
	//			// The classExtendsE rule relys on classFront having the
	//			// new class scope correct via classFront
		classFront parameter_port_listE classExtendsE classImplementsE ';'
	/*mid*/		{ // Allow resolving types declared in base extends class
			  if ($<scp>3) SYMP->importExtends($<scp>3);
			}
	/*cont*/    class_itemListE yENDCLASS endLabelE
			{ $$ = $1; $1->addMembersp($2);
			  $1->extendsp($3);
			  $1->addMembersp($4);
			  $1->addMembersp($7);
			  SYMP->popScope($$);
			  GRAMMARP->endLabel($<fl>7, $1, $9); }
	;

classFront<classp>:		// IEEE: part of class_declaration
		classVirtualE yCLASS lifetimeE idAny/*class_identifier*/
			{ $$ = new AstClass($2, *$4);
			  $$->isVirtual($1);
			  $$->lifetime($3);
			  SYMP->pushNew($<classp>$); }
	//			// IEEE: part of interface_class_declaration
	|	yINTERFACE yCLASS lifetimeE idAny/*class_identifier*/
			{ $$ = new AstClass($2, *$4);
			  $$->lifetime($3);
			  SYMP->pushNew($<classp>$);
			  BBUNSUP($2, "Unsupported: interface classes");  }
	;

classVirtualE<cbool>:
		/* empty */				{ $$ = false; }
	|	yVIRTUAL__CLASS				{ $$ = true; }
	;

classExtendsE<nodep>:		// IEEE: part of class_declaration
	//			// The classExtendsE rule relys on classFront having the
	//			// new class scope correct via classFront
		/* empty */				{ $$ = nullptr; $<scp>$ = nullptr; }
	|	yEXTENDS classExtendsList		{ $$ = $2; $<scp>$ = $<scp>2; }
	;

classExtendsList<nodep>:	// IEEE: part of class_declaration
		classExtendsOne				{ $$ = $1; $<scp>$ = $<scp>1; }
	|	classExtendsList ',' classExtendsOne
			{ $$ = $3; $<scp>$ = $<scp>3;
			  BBUNSUP($3, "Multiple inheritance illegal on non-interface classes (IEEE 1800-2017 8.13), "
				      "and unsupported for interface classes."); }
	;

classExtendsOne<nodep>:		// IEEE: part of class_declaration
		class_typeExtImpList
			{ $$ = new AstClassExtends($1->fileline(), $1);
                          $<scp>$ = $<scp>1; }
	//
	|	class_typeExtImpList '(' list_of_argumentsE ')'
			{ $$ = new AstClassExtends($1->fileline(), $1);
                          $<scp>$ = $<scp>1;
			  if ($3) BBUNSUP($3, "Unsupported: extends with parameters"); }
	;

classImplementsE<nodep>:	// IEEE: part of class_declaration
	//			// All 1800-2012
		/* empty */				{ $$ = nullptr; }
	|	yIMPLEMENTS classImplementsList		{ $$ = $2; }
	;

classImplementsList<nodep>:	// IEEE: part of class_declaration
	//			// All 1800-2012
		class_typeExtImpList			{ $$ = nullptr; BBUNSUP($1, "Unsupported: implements class"); }
	|	classImplementsList ',' class_typeExtImpList	{ $$ = AstNode::addNextNull($1, $3); }
	;

class_typeExtImpList<nodep>:	// IEEE: class_type: "[package_scope] id [ parameter_value_assignment ]"
	//			// but allow yaID__aTYPE for extends/implements
	//			// If you follow the rules down, class_type is really a list via ps_class_identifier
		class_typeExtImpOne			{ $$ = $1; $<scp>$ = $<scp>1; }
	|	class_typeExtImpList yP_COLONCOLON class_typeExtImpOne
			{ $$ = $3; $<scp>$ = $<scp>1;
			  // Cannot just add as next() as that breaks implements lists
			  //UNSUP $$ = new AstDot($<fl>1, true, $1, $3);
			  BBUNSUP($2, "Unsupported: Hierarchical class references"); }
	;

class_typeExtImpOne<nodep>:	// part of IEEE: class_type, where we either get a package_scope component or class
	//			// If you follow the rules down, class_type is really a list via ps_class_identifier
	//			// Not listed in IEEE, but see bug627 any parameter type maybe a class
	//			// If idAny below is a class, parameter_value is legal
	//			// If idAny below is a package, parameter_value is not legal
	//			// If idAny below is otherwise, not legal
		idAny
	/*mid*/		{ /* no nextId as not refing it above this*/ }
	/*cont*/    parameter_value_assignmentE
			{ $$ = new AstClassOrPackageRef($<fl>1, *$1, $<scp>1, $3);
			  $<scp>$ = $<scp>1; }
	//
	//			// package_sopeIdFollows expanded
	|	yD_UNIT yP_COLONCOLON
			{ $$ = new AstClassOrPackageRef($<fl>1, "$unit", nullptr, nullptr);
                          $<scp>$ = nullptr;  // No purpose otherwise, every symtab can see root
			  SYMP->nextId(PARSEP->rootp()); }
	//
	|	yLOCAL__COLONCOLON yP_COLONCOLON
			{ $$ = new AstClassOrPackageRef($<fl>1, "local::", nullptr, nullptr);
                          $<scp>$ = nullptr;  // UNSUP
			  SYMP->nextId(PARSEP->rootp());
			  BBUNSUP($1, "Unsupported: Randomize 'local::'"); }
	;

//=========
// Package scoping - to traverse the symbol table properly, the final identifer
// must be included in the rules below.
// Each of these must end with {symsPackageDone | symsClassDone}

//=== Below rules assume special scoping per above

packageClassScopeNoId<nodep>:	// IEEE: [package_scope] not followed by yaID
		packageClassScope			{ $$ = $1; $<scp>$ = $<scp>1; SYMP->nextId(nullptr); }
	;

packageClassScopeE<nodep>:	// IEEE: [package_scope]
	//			// IMPORTANT: The lexer will parse the following ID to be in the found package
	//			//     if not needed must use packageClassScopeNoId
	//			// TODO: To support classes should return generic type, not packagep
	//			// class_qualifier := [ yLOCAL '::'  ] [ implicit_class_handle '.'  class_scope ]
		/* empty */				{ $$ = nullptr; $<scp>$ = nullptr; }
	|	packageClassScope			{ $$ = $1; $<scp>$ = $<scp>1; }
	;

packageClassScope<nodep>:	// IEEE: class_scope
	//			// IEEE: "class_type yP_COLONCOLON"
	//			// IMPORTANT: The lexer will parse the following ID to be in the found package
	//			//     if not needed must use packageClassScopeNoId
	//			// In this parser <package_identifier>:: and <class_identifier>:: are indistinguishible
	//			// This copies <scp> to document it is important
		packageClassScopeList			{ $$ = $1; $<scp>$ = $<scp>1; }
	|	localNextId yP_COLONCOLON		{ $$ = $1; $<scp>$ = $<scp>1; }
	|	dollarUnitNextId yP_COLONCOLON		{ $$ = $1; $<scp>$ = $<scp>1; }
	|	dollarUnitNextId yP_COLONCOLON packageClassScopeList
			{ $$ = new AstDot($2, true, $1, $3); $<scp>$ = $<scp>3; }
	;

packageClassScopeList<nodep>:	// IEEE: class_type: "id [ parameter_value_assignment ]" but allow yaID__aTYPE
	//			// Or IEEE: [package_scope]
	//			// IMPORTANT: The lexer will parse the following ID to be in the found package
	//			//     if not needed must use packageClassScopeNoId
	//			// In this parser <package_identifier>:: and <class_identifier>:: are indistinguishible
	//			// If you follow the rules down, class_type is really a list via ps_class_identifier
		packageClassScopeItem			{ $$ = $1; $<scp>$ = $<scp>1; }
	|	packageClassScopeList packageClassScopeItem
			{ $$ = new AstDot($<fl>2, true, $1, $2); $<scp>$ = $<scp>2; }
	;

packageClassScopeItem<nodep>:	// IEEE: package_scope or [package_scope]::[class_scope]
	//			// IMPORTANT: The lexer will parse the following ID to be in the found package
	//			//     if not needed must use packageClassScopeNoId
	//			// IEEE: class_type: "id [ parameter_value_assignment ]" but allow yaID__aTYPE
	//			//vv mid rule action needed otherwise we might not have NextId in time to parse the id token
		idCC
	/*mid*/		{ SYMP->nextId($<scp>1); }
	/*cont*/    yP_COLONCOLON
			{ $$ = new AstClassOrPackageRef($<fl>1, *$1, $<scp>1, nullptr); $<scp>$ = $<scp>1; }
	//
	|	idCC parameter_value_assignment
	/*mid*/		{ SYMP->nextId($<scp>1); }   // Change next *after* we handle parameters, not before
	/*cont*/    yP_COLONCOLON
			{ $$ = new AstClassOrPackageRef($<fl>1, *$1, $<scp>1, $2); $<scp>$ = $<scp>1; }
	;

dollarUnitNextId<nodep>:	// $unit
	//			// IMPORTANT: The lexer will parse the following ID to be in the found package
	//			//     if not needed must use packageClassScopeNoId
	//			// Must call nextId without any additional tokens following
		yD_UNIT
			{ $$ = new AstClassOrPackageRef($1, "$unit", GRAMMARP->unitPackage($<fl>1), nullptr);
                          SYMP->nextId(PARSEP->rootp()); }
	;

localNextId<nodep>:		// local
	//			// IMPORTANT: The lexer will parse the following ID to be in the found package
	//			//     if not needed must use packageClassScopeNoId
	//			// Must call nextId without any additional tokens following
		yLOCAL__COLONCOLON
			{ $$ = new AstClassOrPackageRef($1, "local::", GRAMMARP->unitPackage($<fl>1), nullptr);
                          SYMP->nextId(PARSEP->rootp());
			  BBUNSUP($<fl>1, "Unsupported: Randomize 'local::'"); }
	;

//^^^=========

class_itemListE<nodep>:
		/* empty */				{ $$ = nullptr; }
	|	class_itemList				{ $$ = $1; }
	;

class_itemList<nodep>:
		class_item				{ $$ = $1; }
	|	class_itemList class_item  		{ $$ = AstNode::addNextNull($1, $2); }
	;

class_item<nodep>:			// ==IEEE: class_item
		class_property				{ $$ = $1; }
	|	class_method				{ $$ = $1; }
	|	class_constraint			{ $$ = $1; }
	//
	|	class_declaration			{ $$ = nullptr; BBUNSUP($1, "Unsupported: class within class"); }
	|	timeunits_declaration			{ $$ = $1; }
	//UNSUP	covergroup_declaration			{ $$ = $1; }
	//			// local_parameter_declaration under parameter_declaration
	|	parameter_declaration ';'		{ $$ = $1; BBUNSUP($2, "Unsupported: class parameters"); }  // 1800-2009
	|	';'					{ $$ = nullptr; }
	//
	|	error ';'				{ $$ = nullptr; }
	;

class_method<nodep>:		// ==IEEE: class_method
		memberQualListE task_declaration	{ $$ = $2; $1.applyToNodes($2); }
	|	memberQualListE function_declaration	{ $$ = $2; $1.applyToNodes($2); }
	|	yPURE yVIRTUAL__ETC memberQualListE method_prototype ';'
			{ $$ = $4; $3.applyToNodes($4); $4->pureVirtual(true); $4->isVirtual(true); }
	|	yEXTERN memberQualListE method_prototype ';'
			{ $$ = $3; $2.applyToNodes($3); $3->isExternProto(true); }
	//			// IEEE: "method_qualifierE class_constructor_declaration"
	//			// part of function_declaration
	|	yEXTERN memberQualListE class_constructor_prototype
			{ $$ = $3; $2.applyToNodes($3); $3->isExternProto(true); }
	;

// IEEE: class_constructor_prototype
// See function_declaration

memberQualListE<qualifiers>:	// Called from class_property for all qualifiers before yVAR
	//			// Also before method declarations, to prevent grammar conflict
	//			// Thus both types of qualifiers (method/property) are here
		/*empty*/				{ $$ = VMemberQualifiers::none(); }
	|	memberQualList				{ $$ = $1; }
	;

memberQualList<qualifiers>:
		memberQualOne				{ $$ = $1; }
	|	memberQualList memberQualOne		{ $$ = VMemberQualifiers::combine($1, $2); }
	;

memberQualOne<qualifiers>:			// IEEE: property_qualifier + method_qualifier
	//			// Part of method_qualifier and property_qualifier
	//			// IMPORTANT: yPROTECTED | yLOCAL is in a lex rule
		yPROTECTED				{ $$ = VMemberQualifiers::none(); $$.m_protected = true; }
	|	yLOCAL__ETC				{ $$ = VMemberQualifiers::none(); $$.m_local = true; }
	|	ySTATIC__ETC				{ $$ = VMemberQualifiers::none(); $$.m_static = true; }
	//			// Part of method_qualifier only
	|	yVIRTUAL__ETC				{ $$ = VMemberQualifiers::none(); $$.m_virtual = true; }
	//			// Part of property_qualifier only
	|	random_qualifier			{ $$ = $1; }
	//			// Part of lifetime, but here as ySTATIC can be in different positions
	|	yAUTOMATIC		 		{ $$ = VMemberQualifiers::none(); $$.m_automatic = true; }
	//			// Part of data_declaration, but not in data_declarationVarFrontClass
	|	yCONST__ETC				{ $$ = VMemberQualifiers::none(); $$.m_const = true; }
	;

//**********************************************************************
// Constraints

class_constraint<nodep>:  // ==IEEE: class_constraint
	//			// IEEE: constraint_declaration
	//			// UNSUP: We have the unsupported warning on the randomize() call, so don't bother on
	//			// constraint blocks. When we support randomize we need to make AST nodes for below rules
		constraintStaticE yCONSTRAINT idAny constraint_block	{ $$ = nullptr; /*UNSUP*/ }
	//			// IEEE: constraint_prototype + constraint_prototype_qualifier
	|	constraintStaticE yCONSTRAINT idAny ';'		{ $$ = nullptr; }
	|	yEXTERN constraintStaticE yCONSTRAINT idAny ';'	{ $$ = nullptr; BBUNSUP($1, "Unsupported: extern constraint"); }
	|	yPURE constraintStaticE yCONSTRAINT idAny ';'	{ $$ = nullptr; BBUNSUP($1, "Unsupported: pure constraint"); }
	;

constraint_block<nodep>:  // ==IEEE: constraint_block
		'{' constraint_block_itemList '}'		{ $$ = $2; }
	;

constraint_block_itemList<nodep>:  // IEEE: { constraint_block_item }
		constraint_block_item				{ $$ = $1; }
	|	constraint_block_itemList constraint_block_item	{ $$ = AstNode::addNextNull($1, $2); }
	;

constraint_block_item<nodep>:  // ==IEEE: constraint_block_item
		constraint_expression				{ $$ = $1; }
	|	ySOLVE solve_before_list yBEFORE solve_before_list ';'	{ $$ = nullptr; BBUNSUP($2, "Unsupported: solve before"); }
	;

solve_before_list<nodep>:  // ==IEEE: solve_before_list
		constraint_primary				{ $$ = $1; }
	|	solve_before_list ',' constraint_primary	{ $$ = AstNode::addNextNull($1, $3); }
	;

constraint_primary<nodep>:  // ==IEEE: constraint_primary
	//			// exprScope more general than: [ implicit_class_handle '.' | class_scope ] hierarchical_identifier select
		exprScope					{ $$ = $1; }
	;

constraint_expressionList<nodep>:  // ==IEEE: { constraint_expression }
		constraint_expression				{ $$ = $1; }
	|	constraint_expressionList constraint_expression	{ $$ = AstNode::addNextNull($1, $2); }
	;

constraint_expression<nodep>:  // ==IEEE: constraint_expression
		expr/*expression_or_dist*/ ';'		{ $$ = $1; }
	//			// 1800-2012:
	|	ySOFT expr/*expression_or_dist*/ ';'	{ $$ = nullptr; /*UNSUP-no-UVM*/ }
	//			// 1800-2012:
	//			// IEEE: uniqueness_constraint ';'
	|	yUNIQUE '{' open_range_list '}'		{ $$ = nullptr; /*UNSUP-no-UVM*/ }
	//			// IEEE: expr yP_MINUSGT constraint_set
	//			// Conflicts with expr:"expr yP_MINUSGT expr"; rule moved there
	//
	|	yIF '(' expr ')' constraint_set	%prec prLOWER_THAN_ELSE	{ $$ = nullptr; /*UNSUP-UVM*/ }
	|	yIF '(' expr ')' constraint_set	yELSE constraint_set	{ $$ = nullptr; /*UNSUP-UVM*/ }
	//			// IEEE says array_identifier here, but dotted accepted in VMM + 1800-2009
	|	yFOREACH '(' idClassSelForeach ')' constraint_set	{ $$ = nullptr; /*UNSUP-UVM*/ }
	//			// soft is 1800-2012
	|	yDISABLE ySOFT expr/*constraint_primary*/ ';'	{ $$ = nullptr; /*UNSUP-no-UVM*/ }
	;

constraint_set<nodep>:  // ==IEEE: constraint_set
		constraint_expression			{ $$ = $1; }
	|	'{' constraint_expressionList '}'	{ $$ = $2; }
	;

dist_list<nodep>:  // ==IEEE: dist_list
		dist_item				{ $$ = $1; }
	|	dist_list ',' dist_item			{ $$ = AstNode::addNextNull($1, $3); }
	;

dist_item<nodep>:  // ==IEEE: dist_item + dist_weight
		value_range				{ $$ = $1; /* Same as := 1 */ }
	|	value_range yP_COLONEQ  expr		{ $$ = $1; nullptr; /*UNSUP-no-UVM*/ }
	|	value_range yP_COLONDIV expr		{ $$ = $1; nullptr; /*UNSUP-no-UVM*/ }
	;

//UNSUPextern_constraint_declaration:  // ==IEEE: extern_constraint_declaration
//UNSUP		constraintStaticE yCONSTRAINT class_scope_id constraint_block	{ }
//UNSUP	;

constraintStaticE<cbool>:  // IEEE: part of extern_constraint_declaration
		/* empty */				{ $$ = false; }
	|	ySTATIC__CONSTRAINT			{ $$ = true; }
	;

//**********************************************************************
// Constants

timeNumAdjusted<nodep>:		// Time constant, adjusted to module's time units/precision
		yaTIMENUM
			{ $$ = new AstTimeImport($<fl>1, new AstConst($<fl>1, AstConst::RealDouble(), $1)); }
	;

//**********************************************************************
// Generic tokens

colon<fl>:			// Generic colon that isn't making a label (e.g. in a case_item)
		':'					{ $$ = $1; }
	|	yP_COLON__BEGIN				{ $$ = $1; }
	|	yP_COLON__FORK				{ $$ = $1; }
	;

//**********************************************************************
// VLT Files

vltItem:

		vltOffFront			{ V3Config::addIgnore($1, false, "*", 0, 0); }
	|	vltOffFront yVLT_D_FILE yaSTRING
			{ V3Config::addIgnore($1, false, *$3, 0, 0); }
	|	vltOffFront yVLT_D_FILE yaSTRING yVLT_D_LINES yaINTNUM
			{ V3Config::addIgnore($1, false, *$3, $5->toUInt(), $5->toUInt()+1); }
	|	vltOffFront yVLT_D_FILE yaSTRING yVLT_D_LINES yaINTNUM '-' yaINTNUM
			{ V3Config::addIgnore($1, false, *$3, $5->toUInt(), $7->toUInt()+1); }
	|	vltOffFront yVLT_D_FILE yaSTRING yVLT_D_MATCH yaSTRING
			{	if (($1==V3ErrorCode::I_COVERAGE) || ($1==V3ErrorCode::I_TRACING)) {
					$<fl>1->v3error("Argument -match only supported for lint_off");
				} else {
					V3Config::addWaiver($1,*$3,*$5);
				}}
	|	vltOnFront			{ V3Config::addIgnore($1, true, "*", 0, 0); }
	|	vltOnFront yVLT_D_FILE yaSTRING
			{ V3Config::addIgnore($1, true, *$3, 0, 0); }
	|	vltOnFront yVLT_D_FILE yaSTRING yVLT_D_LINES yaINTNUM
			{ V3Config::addIgnore($1, true, *$3, $5->toUInt(), $5->toUInt()+1); }
	|	vltOnFront yVLT_D_FILE yaSTRING yVLT_D_LINES yaINTNUM '-' yaINTNUM
			{ V3Config::addIgnore($1, true, *$3, $5->toUInt(), $7->toUInt()+1); }
	|	vltVarAttrFront vltDModuleE vltDFTaskE vltVarAttrVarE attr_event_controlE
			{ V3Config::addVarAttr($<fl>1, *$2, *$3, *$4, $1, $5); }
	|	vltInlineFront vltDModuleE vltDFTaskE
			{ V3Config::addInline($<fl>1, *$2, *$3, $1); }
	|	yVLT_COVERAGE_BLOCK_OFF yVLT_D_FILE yaSTRING
			{ V3Config::addCoverageBlockOff(*$3, 0); }
	|	yVLT_COVERAGE_BLOCK_OFF yVLT_D_FILE yaSTRING yVLT_D_LINES yaINTNUM
			{ V3Config::addCoverageBlockOff(*$3, $5->toUInt()); }
	|	yVLT_COVERAGE_BLOCK_OFF yVLT_D_MODULE yaSTRING yVLT_D_BLOCK yaSTRING
			{ V3Config::addCoverageBlockOff(*$3, *$5); }
	|	yVLT_FULL_CASE yVLT_D_FILE yaSTRING
			{ V3Config::addCaseFull(*$3, 0); }
	|	yVLT_FULL_CASE yVLT_D_FILE yaSTRING yVLT_D_LINES yaINTNUM
			{ V3Config::addCaseFull(*$3, $5->toUInt()); }
	|	yVLT_HIER_BLOCK vltDModuleE
			{ V3Config::addModulePragma(*$2, AstPragmaType::HIER_BLOCK); }
	|	yVLT_PARALLEL_CASE yVLT_D_FILE yaSTRING
			{ V3Config::addCaseParallel(*$3, 0); }
	|	yVLT_PARALLEL_CASE yVLT_D_FILE yaSTRING yVLT_D_LINES yaINTNUM
			{ V3Config::addCaseParallel(*$3, $5->toUInt()); }
	;

vltOffFront<errcodeen>:
		yVLT_COVERAGE_OFF			{ $$ = V3ErrorCode::I_COVERAGE; }
	|	yVLT_TRACING_OFF			{ $$ = V3ErrorCode::I_TRACING; }
	|	yVLT_LINT_OFF				{ $$ = V3ErrorCode::I_LINT; }
	|	yVLT_LINT_OFF yVLT_D_MSG idAny
			{ $$ = V3ErrorCode((*$3).c_str());
			  if ($$ == V3ErrorCode::EC_ERROR) { $1->v3error("Unknown Error Code: " << *$3); }
			  $2->v3warn(DEPRECATED, "Deprecated -msg in configuration files, use -rule instead."); }
	|	yVLT_LINT_OFF yVLT_D_RULE idAny
			{ $$ = V3ErrorCode((*$3).c_str());
			  if ($$ == V3ErrorCode::EC_ERROR) { $1->v3error("Unknown Error Code: " << *$3);  } }
	;

vltOnFront<errcodeen>:
		yVLT_COVERAGE_ON			{ $$ = V3ErrorCode::I_COVERAGE; }
	|	yVLT_TRACING_ON				{ $$ = V3ErrorCode::I_TRACING; }
	|	yVLT_LINT_ON				{ $$ = V3ErrorCode::I_LINT; }
	|	yVLT_LINT_ON yVLT_D_MSG idAny
			{ $$ = V3ErrorCode((*$3).c_str());
			  if ($$ == V3ErrorCode::EC_ERROR) { $1->v3error("Unknown Error Code: " << *$3);  }
			  $2->v3warn(DEPRECATED, "Deprecated -msg in configuration files, use -rule instead."); }
	|	yVLT_LINT_ON yVLT_D_RULE idAny
			{ $$ = V3ErrorCode((*$3).c_str());
			  if ($$ == V3ErrorCode::EC_ERROR) { $1->v3error("Unknown Error Code: " << *$3);  } }
	;

vltDModuleE<strp>:
		/* empty */				{ static string unit = "__024unit"; $$ = &unit; }
	|	yVLT_D_MODULE str			{ $$ = $2; }
	;

vltDFTaskE<strp>:
		/* empty */				{ static string empty = ""; $$ = &empty; }
	|	yVLT_D_FUNCTION str			{ $$ = $2; }
	|	yVLT_D_TASK str				{ $$ = $2; }
	;

vltInlineFront<cbool>:
		yVLT_INLINE				{ $$ = true; }
	|	yVLT_NO_INLINE				{ $$ = false; }
	;

vltVarAttrVarE<strp>:
		/* empty */				{ static string empty = ""; $$ = &empty; }
	|	yVLT_D_VAR str				{ $$ = $2; }
	;

vltVarAttrFront<attrtypeen>:
		yVLT_CLOCK_ENABLE           { $$ = AstAttrType::VAR_CLOCK_ENABLE; }
	|	yVLT_CLOCKER                { $$ = AstAttrType::VAR_CLOCKER; }
	|	yVLT_ISOLATE_ASSIGNMENTS    { $$ = AstAttrType::VAR_ISOLATE_ASSIGNMENTS; }
	|	yVLT_NO_CLOCKER             { $$ = AstAttrType::VAR_NO_CLOCKER; }
	|	yVLT_PUBLIC                 { $$ = AstAttrType::VAR_PUBLIC; v3Global.dpi(true); }
	|	yVLT_PUBLIC_FLAT            { $$ = AstAttrType::VAR_PUBLIC_FLAT; v3Global.dpi(true); }
	|	yVLT_PUBLIC_FLAT_RD         { $$ = AstAttrType::VAR_PUBLIC_FLAT_RD; v3Global.dpi(true); }
	|	yVLT_PUBLIC_FLAT_RW         { $$ = AstAttrType::VAR_PUBLIC_FLAT_RW; v3Global.dpi(true); }
	|	yVLT_SC_BV                  { $$ = AstAttrType::VAR_SC_BV; }
	|	yVLT_SFORMAT                { $$ = AstAttrType::VAR_SFORMAT; }
	|	yVLT_SPLIT_VAR              { $$ = AstAttrType::VAR_SPLIT_VAR; }
	;

//**********************************************************************
%%
// For implementation functions see V3ParseGrammar.cpp

//YACC = /kits/sources/bison-2.4.1/src/bison --report=lookahead
// --report=lookahead
// --report=itemset
// --graph
