Trait VerylGrammarTrait

pub trait VerylGrammarTrait {
    // Provided methods
    fn comments_term(&mut self, _arg: &CommentsTerm) -> Result<()> { ... }
    fn string_literal_term(&mut self, _arg: &StringLiteralTerm) -> Result<()> { ... }
    fn exponent_term(&mut self, _arg: &ExponentTerm) -> Result<()> { ... }
    fn fixed_point_term(&mut self, _arg: &FixedPointTerm) -> Result<()> { ... }
    fn based_term(&mut self, _arg: &BasedTerm) -> Result<()> { ... }
    fn all_bit_term(&mut self, _arg: &AllBitTerm) -> Result<()> { ... }
    fn base_less_term(&mut self, _arg: &BaseLessTerm) -> Result<()> { ... }
    fn minus_colon_term(&mut self, _arg: &MinusColonTerm) -> Result<()> { ... }
    fn minus_g_t_term(&mut self, _arg: &MinusGTTerm) -> Result<()> { ... }
    fn plus_colon_term(&mut self, _arg: &PlusColonTerm) -> Result<()> { ... }
    fn assignment_operator_term(
        &mut self,
        _arg: &AssignmentOperatorTerm,
    ) -> Result<()> { ... }
    fn operator11_term(&mut self, _arg: &Operator11Term) -> Result<()> { ... }
    fn operator10_term(&mut self, _arg: &Operator10Term) -> Result<()> { ... }
    fn operator09_term(&mut self, _arg: &Operator09Term) -> Result<()> { ... }
    fn operator08_term(&mut self, _arg: &Operator08Term) -> Result<()> { ... }
    fn operator07_term(&mut self, _arg: &Operator07Term) -> Result<()> { ... }
    fn operator06_term(&mut self, _arg: &Operator06Term) -> Result<()> { ... }
    fn operator02_term(&mut self, _arg: &Operator02Term) -> Result<()> { ... }
    fn operator01_term(&mut self, _arg: &Operator01Term) -> Result<()> { ... }
    fn operator05_term(&mut self, _arg: &Operator05Term) -> Result<()> { ... }
    fn operator04_term(&mut self, _arg: &Operator04Term) -> Result<()> { ... }
    fn operator03_term(&mut self, _arg: &Operator03Term) -> Result<()> { ... }
    fn unary_operator_term(&mut self, _arg: &UnaryOperatorTerm) -> Result<()> { ... }
    fn back_quote_term(&mut self, _arg: &BackQuoteTerm) -> Result<()> { ... }
    fn colon_colon_l_angle_term(
        &mut self,
        _arg: &ColonColonLAngleTerm,
    ) -> Result<()> { ... }
    fn colon_colon_term(&mut self, _arg: &ColonColonTerm) -> Result<()> { ... }
    fn colon_term(&mut self, _arg: &ColonTerm) -> Result<()> { ... }
    fn comma_term(&mut self, _arg: &CommaTerm) -> Result<()> { ... }
    fn dot_dot_equ_term(&mut self, _arg: &DotDotEquTerm) -> Result<()> { ... }
    fn dot_dot_term(&mut self, _arg: &DotDotTerm) -> Result<()> { ... }
    fn dot_term(&mut self, _arg: &DotTerm) -> Result<()> { ... }
    fn equ_term(&mut self, _arg: &EquTerm) -> Result<()> { ... }
    fn hash_term(&mut self, _arg: &HashTerm) -> Result<()> { ... }
    fn l_angle_term(&mut self, _arg: &LAngleTerm) -> Result<()> { ... }
    fn quote_l_brace_term(&mut self, _arg: &QuoteLBraceTerm) -> Result<()> { ... }
    fn l_brace_term(&mut self, _arg: &LBraceTerm) -> Result<()> { ... }
    fn l_bracket_term(&mut self, _arg: &LBracketTerm) -> Result<()> { ... }
    fn l_paren_term(&mut self, _arg: &LParenTerm) -> Result<()> { ... }
    fn r_angle_term(&mut self, _arg: &RAngleTerm) -> Result<()> { ... }
    fn r_brace_term(&mut self, _arg: &RBraceTerm) -> Result<()> { ... }
    fn r_bracket_term(&mut self, _arg: &RBracketTerm) -> Result<()> { ... }
    fn r_paren_term(&mut self, _arg: &RParenTerm) -> Result<()> { ... }
    fn semicolon_term(&mut self, _arg: &SemicolonTerm) -> Result<()> { ... }
    fn star_term(&mut self, _arg: &StarTerm) -> Result<()> { ... }
    fn always_comb_term(&mut self, _arg: &AlwaysCombTerm) -> Result<()> { ... }
    fn always_ff_term(&mut self, _arg: &AlwaysFfTerm) -> Result<()> { ... }
    fn assign_term(&mut self, _arg: &AssignTerm) -> Result<()> { ... }
    fn as_term(&mut self, _arg: &AsTerm) -> Result<()> { ... }
    fn bit_term(&mut self, _arg: &BitTerm) -> Result<()> { ... }
    fn case_term(&mut self, _arg: &CaseTerm) -> Result<()> { ... }
    fn clock_term(&mut self, _arg: &ClockTerm) -> Result<()> { ... }
    fn clock_posedge_term(&mut self, _arg: &ClockPosedgeTerm) -> Result<()> { ... }
    fn clock_negedge_term(&mut self, _arg: &ClockNegedgeTerm) -> Result<()> { ... }
    fn const_term(&mut self, _arg: &ConstTerm) -> Result<()> { ... }
    fn default_term(&mut self, _arg: &DefaultTerm) -> Result<()> { ... }
    fn else_term(&mut self, _arg: &ElseTerm) -> Result<()> { ... }
    fn embed_term(&mut self, _arg: &EmbedTerm) -> Result<()> { ... }
    fn enum_term(&mut self, _arg: &EnumTerm) -> Result<()> { ... }
    fn export_term(&mut self, _arg: &ExportTerm) -> Result<()> { ... }
    fn f32_term(&mut self, _arg: &F32Term) -> Result<()> { ... }
    fn f64_term(&mut self, _arg: &F64Term) -> Result<()> { ... }
    fn final_term(&mut self, _arg: &FinalTerm) -> Result<()> { ... }
    fn for_term(&mut self, _arg: &ForTerm) -> Result<()> { ... }
    fn function_term(&mut self, _arg: &FunctionTerm) -> Result<()> { ... }
    fn i32_term(&mut self, _arg: &I32Term) -> Result<()> { ... }
    fn i64_term(&mut self, _arg: &I64Term) -> Result<()> { ... }
    fn if_reset_term(&mut self, _arg: &IfResetTerm) -> Result<()> { ... }
    fn if_term(&mut self, _arg: &IfTerm) -> Result<()> { ... }
    fn import_term(&mut self, _arg: &ImportTerm) -> Result<()> { ... }
    fn include_term(&mut self, _arg: &IncludeTerm) -> Result<()> { ... }
    fn initial_term(&mut self, _arg: &InitialTerm) -> Result<()> { ... }
    fn inout_term(&mut self, _arg: &InoutTerm) -> Result<()> { ... }
    fn input_term(&mut self, _arg: &InputTerm) -> Result<()> { ... }
    fn inside_term(&mut self, _arg: &InsideTerm) -> Result<()> { ... }
    fn inst_term(&mut self, _arg: &InstTerm) -> Result<()> { ... }
    fn interface_term(&mut self, _arg: &InterfaceTerm) -> Result<()> { ... }
    fn in_term(&mut self, _arg: &InTerm) -> Result<()> { ... }
    fn let_term(&mut self, _arg: &LetTerm) -> Result<()> { ... }
    fn logic_term(&mut self, _arg: &LogicTerm) -> Result<()> { ... }
    fn lsb_term(&mut self, _arg: &LsbTerm) -> Result<()> { ... }
    fn modport_term(&mut self, _arg: &ModportTerm) -> Result<()> { ... }
    fn module_term(&mut self, _arg: &ModuleTerm) -> Result<()> { ... }
    fn msb_term(&mut self, _arg: &MsbTerm) -> Result<()> { ... }
    fn output_term(&mut self, _arg: &OutputTerm) -> Result<()> { ... }
    fn outside_term(&mut self, _arg: &OutsideTerm) -> Result<()> { ... }
    fn package_term(&mut self, _arg: &PackageTerm) -> Result<()> { ... }
    fn param_term(&mut self, _arg: &ParamTerm) -> Result<()> { ... }
    fn proto_term(&mut self, _arg: &ProtoTerm) -> Result<()> { ... }
    fn pub_term(&mut self, _arg: &PubTerm) -> Result<()> { ... }
    fn ref_term(&mut self, _arg: &RefTerm) -> Result<()> { ... }
    fn repeat_term(&mut self, _arg: &RepeatTerm) -> Result<()> { ... }
    fn reset_term(&mut self, _arg: &ResetTerm) -> Result<()> { ... }
    fn reset_async_high_term(&mut self, _arg: &ResetAsyncHighTerm) -> Result<()> { ... }
    fn reset_async_low_term(&mut self, _arg: &ResetAsyncLowTerm) -> Result<()> { ... }
    fn reset_sync_high_term(&mut self, _arg: &ResetSyncHighTerm) -> Result<()> { ... }
    fn reset_sync_low_term(&mut self, _arg: &ResetSyncLowTerm) -> Result<()> { ... }
    fn return_term(&mut self, _arg: &ReturnTerm) -> Result<()> { ... }
    fn break_term(&mut self, _arg: &BreakTerm) -> Result<()> { ... }
    fn signed_term(&mut self, _arg: &SignedTerm) -> Result<()> { ... }
    fn step_term(&mut self, _arg: &StepTerm) -> Result<()> { ... }
    fn string_term(&mut self, _arg: &StringTerm) -> Result<()> { ... }
    fn struct_term(&mut self, _arg: &StructTerm) -> Result<()> { ... }
    fn switch_term(&mut self, _arg: &SwitchTerm) -> Result<()> { ... }
    fn tri_term(&mut self, _arg: &TriTerm) -> Result<()> { ... }
    fn type_term(&mut self, _arg: &TypeTerm) -> Result<()> { ... }
    fn u32_term(&mut self, _arg: &U32Term) -> Result<()> { ... }
    fn u64_term(&mut self, _arg: &U64Term) -> Result<()> { ... }
    fn union_term(&mut self, _arg: &UnionTerm) -> Result<()> { ... }
    fn unsafe_term(&mut self, _arg: &UnsafeTerm) -> Result<()> { ... }
    fn var_term(&mut self, _arg: &VarTerm) -> Result<()> { ... }
    fn dollar_identifier_term(
        &mut self,
        _arg: &DollarIdentifierTerm,
    ) -> Result<()> { ... }
    fn identifier_term(&mut self, _arg: &IdentifierTerm) -> Result<()> { ... }
    fn any_term(&mut self, _arg: &AnyTerm) -> Result<()> { ... }
    fn comments(&mut self, _arg: &Comments) -> Result<()> { ... }
    fn start_token(&mut self, _arg: &StartToken) -> Result<()> { ... }
    fn string_literal_token(&mut self, _arg: &StringLiteralToken) -> Result<()> { ... }
    fn exponent_token(&mut self, _arg: &ExponentToken) -> Result<()> { ... }
    fn fixed_point_token(&mut self, _arg: &FixedPointToken) -> Result<()> { ... }
    fn based_token(&mut self, _arg: &BasedToken) -> Result<()> { ... }
    fn base_less_token(&mut self, _arg: &BaseLessToken) -> Result<()> { ... }
    fn all_bit_token(&mut self, _arg: &AllBitToken) -> Result<()> { ... }
    fn assignment_operator_token(
        &mut self,
        _arg: &AssignmentOperatorToken,
    ) -> Result<()> { ... }
    fn operator01_token(&mut self, _arg: &Operator01Token) -> Result<()> { ... }
    fn operator02_token(&mut self, _arg: &Operator02Token) -> Result<()> { ... }
    fn operator03_token(&mut self, _arg: &Operator03Token) -> Result<()> { ... }
    fn operator04_token(&mut self, _arg: &Operator04Token) -> Result<()> { ... }
    fn operator05_token(&mut self, _arg: &Operator05Token) -> Result<()> { ... }
    fn operator06_token(&mut self, _arg: &Operator06Token) -> Result<()> { ... }
    fn operator07_token(&mut self, _arg: &Operator07Token) -> Result<()> { ... }
    fn operator08_token(&mut self, _arg: &Operator08Token) -> Result<()> { ... }
    fn operator09_token(&mut self, _arg: &Operator09Token) -> Result<()> { ... }
    fn operator10_token(&mut self, _arg: &Operator10Token) -> Result<()> { ... }
    fn operator11_token(&mut self, _arg: &Operator11Token) -> Result<()> { ... }
    fn unary_operator_token(&mut self, _arg: &UnaryOperatorToken) -> Result<()> { ... }
    fn back_quote_token(&mut self, _arg: &BackQuoteToken) -> Result<()> { ... }
    fn colon_token(&mut self, _arg: &ColonToken) -> Result<()> { ... }
    fn colon_colon_l_angle_token(
        &mut self,
        _arg: &ColonColonLAngleToken,
    ) -> Result<()> { ... }
    fn colon_colon_token(&mut self, _arg: &ColonColonToken) -> Result<()> { ... }
    fn comma_token(&mut self, _arg: &CommaToken) -> Result<()> { ... }
    fn dot_dot_token(&mut self, _arg: &DotDotToken) -> Result<()> { ... }
    fn dot_dot_equ_token(&mut self, _arg: &DotDotEquToken) -> Result<()> { ... }
    fn dot_token(&mut self, _arg: &DotToken) -> Result<()> { ... }
    fn equ_token(&mut self, _arg: &EquToken) -> Result<()> { ... }
    fn hash_token(&mut self, _arg: &HashToken) -> Result<()> { ... }
    fn quote_l_brace_token(&mut self, _arg: &QuoteLBraceToken) -> Result<()> { ... }
    fn l_angle_token(&mut self, _arg: &LAngleToken) -> Result<()> { ... }
    fn l_brace_token(&mut self, _arg: &LBraceToken) -> Result<()> { ... }
    fn l_bracket_token(&mut self, _arg: &LBracketToken) -> Result<()> { ... }
    fn l_paren_token(&mut self, _arg: &LParenToken) -> Result<()> { ... }
    fn minus_colon_token(&mut self, _arg: &MinusColonToken) -> Result<()> { ... }
    fn minus_g_t_token(&mut self, _arg: &MinusGTToken) -> Result<()> { ... }
    fn plus_colon_token(&mut self, _arg: &PlusColonToken) -> Result<()> { ... }
    fn r_angle_token(&mut self, _arg: &RAngleToken) -> Result<()> { ... }
    fn r_brace_token(&mut self, _arg: &RBraceToken) -> Result<()> { ... }
    fn r_bracket_token(&mut self, _arg: &RBracketToken) -> Result<()> { ... }
    fn r_paren_token(&mut self, _arg: &RParenToken) -> Result<()> { ... }
    fn semicolon_token(&mut self, _arg: &SemicolonToken) -> Result<()> { ... }
    fn star_token(&mut self, _arg: &StarToken) -> Result<()> { ... }
    fn always_comb_token(&mut self, _arg: &AlwaysCombToken) -> Result<()> { ... }
    fn always_ff_token(&mut self, _arg: &AlwaysFfToken) -> Result<()> { ... }
    fn as_token(&mut self, _arg: &AsToken) -> Result<()> { ... }
    fn assign_token(&mut self, _arg: &AssignToken) -> Result<()> { ... }
    fn bit_token(&mut self, _arg: &BitToken) -> Result<()> { ... }
    fn case_token(&mut self, _arg: &CaseToken) -> Result<()> { ... }
    fn clock_token(&mut self, _arg: &ClockToken) -> Result<()> { ... }
    fn clock_posedge_token(&mut self, _arg: &ClockPosedgeToken) -> Result<()> { ... }
    fn clock_negedge_token(&mut self, _arg: &ClockNegedgeToken) -> Result<()> { ... }
    fn const_token(&mut self, _arg: &ConstToken) -> Result<()> { ... }
    fn default_token(&mut self, _arg: &DefaultToken) -> Result<()> { ... }
    fn else_token(&mut self, _arg: &ElseToken) -> Result<()> { ... }
    fn embed_token(&mut self, _arg: &EmbedToken) -> Result<()> { ... }
    fn enum_token(&mut self, _arg: &EnumToken) -> Result<()> { ... }
    fn export_token(&mut self, _arg: &ExportToken) -> Result<()> { ... }
    fn f32_token(&mut self, _arg: &F32Token) -> Result<()> { ... }
    fn f64_token(&mut self, _arg: &F64Token) -> Result<()> { ... }
    fn final_token(&mut self, _arg: &FinalToken) -> Result<()> { ... }
    fn for_token(&mut self, _arg: &ForToken) -> Result<()> { ... }
    fn function_token(&mut self, _arg: &FunctionToken) -> Result<()> { ... }
    fn i32_token(&mut self, _arg: &I32Token) -> Result<()> { ... }
    fn i64_token(&mut self, _arg: &I64Token) -> Result<()> { ... }
    fn if_reset_token(&mut self, _arg: &IfResetToken) -> Result<()> { ... }
    fn if_token(&mut self, _arg: &IfToken) -> Result<()> { ... }
    fn import_token(&mut self, _arg: &ImportToken) -> Result<()> { ... }
    fn include_token(&mut self, _arg: &IncludeToken) -> Result<()> { ... }
    fn initial_token(&mut self, _arg: &InitialToken) -> Result<()> { ... }
    fn inout_token(&mut self, _arg: &InoutToken) -> Result<()> { ... }
    fn input_token(&mut self, _arg: &InputToken) -> Result<()> { ... }
    fn inside_token(&mut self, _arg: &InsideToken) -> Result<()> { ... }
    fn inst_token(&mut self, _arg: &InstToken) -> Result<()> { ... }
    fn interface_token(&mut self, _arg: &InterfaceToken) -> Result<()> { ... }
    fn in_token(&mut self, _arg: &InToken) -> Result<()> { ... }
    fn let_token(&mut self, _arg: &LetToken) -> Result<()> { ... }
    fn logic_token(&mut self, _arg: &LogicToken) -> Result<()> { ... }
    fn lsb_token(&mut self, _arg: &LsbToken) -> Result<()> { ... }
    fn modport_token(&mut self, _arg: &ModportToken) -> Result<()> { ... }
    fn module_token(&mut self, _arg: &ModuleToken) -> Result<()> { ... }
    fn msb_token(&mut self, _arg: &MsbToken) -> Result<()> { ... }
    fn output_token(&mut self, _arg: &OutputToken) -> Result<()> { ... }
    fn outside_token(&mut self, _arg: &OutsideToken) -> Result<()> { ... }
    fn package_token(&mut self, _arg: &PackageToken) -> Result<()> { ... }
    fn param_token(&mut self, _arg: &ParamToken) -> Result<()> { ... }
    fn proto_token(&mut self, _arg: &ProtoToken) -> Result<()> { ... }
    fn pub_token(&mut self, _arg: &PubToken) -> Result<()> { ... }
    fn ref_token(&mut self, _arg: &RefToken) -> Result<()> { ... }
    fn repeat_token(&mut self, _arg: &RepeatToken) -> Result<()> { ... }
    fn reset_token(&mut self, _arg: &ResetToken) -> Result<()> { ... }
    fn reset_async_high_token(
        &mut self,
        _arg: &ResetAsyncHighToken,
    ) -> Result<()> { ... }
    fn reset_async_low_token(&mut self, _arg: &ResetAsyncLowToken) -> Result<()> { ... }
    fn reset_sync_high_token(&mut self, _arg: &ResetSyncHighToken) -> Result<()> { ... }
    fn reset_sync_low_token(&mut self, _arg: &ResetSyncLowToken) -> Result<()> { ... }
    fn return_token(&mut self, _arg: &ReturnToken) -> Result<()> { ... }
    fn break_token(&mut self, _arg: &BreakToken) -> Result<()> { ... }
    fn signed_token(&mut self, _arg: &SignedToken) -> Result<()> { ... }
    fn step_token(&mut self, _arg: &StepToken) -> Result<()> { ... }
    fn string_token(&mut self, _arg: &StringToken) -> Result<()> { ... }
    fn struct_token(&mut self, _arg: &StructToken) -> Result<()> { ... }
    fn switch_token(&mut self, _arg: &SwitchToken) -> Result<()> { ... }
    fn tri_token(&mut self, _arg: &TriToken) -> Result<()> { ... }
    fn type_token(&mut self, _arg: &TypeToken) -> Result<()> { ... }
    fn u32_token(&mut self, _arg: &U32Token) -> Result<()> { ... }
    fn u64_token(&mut self, _arg: &U64Token) -> Result<()> { ... }
    fn union_token(&mut self, _arg: &UnionToken) -> Result<()> { ... }
    fn unsafe_token(&mut self, _arg: &UnsafeToken) -> Result<()> { ... }
    fn var_token(&mut self, _arg: &VarToken) -> Result<()> { ... }
    fn dollar_identifier_token(
        &mut self,
        _arg: &DollarIdentifierToken,
    ) -> Result<()> { ... }
    fn identifier_token(&mut self, _arg: &IdentifierToken) -> Result<()> { ... }
    fn start(&mut self, _arg: &Start) -> Result<()> { ... }
    fn string_literal(&mut self, _arg: &StringLiteral) -> Result<()> { ... }
    fn exponent(&mut self, _arg: &Exponent) -> Result<()> { ... }
    fn fixed_point(&mut self, _arg: &FixedPoint) -> Result<()> { ... }
    fn based(&mut self, _arg: &Based) -> Result<()> { ... }
    fn base_less(&mut self, _arg: &BaseLess) -> Result<()> { ... }
    fn all_bit(&mut self, _arg: &AllBit) -> Result<()> { ... }
    fn assignment_operator(&mut self, _arg: &AssignmentOperator) -> Result<()> { ... }
    fn operator01(&mut self, _arg: &Operator01) -> Result<()> { ... }
    fn operator02(&mut self, _arg: &Operator02) -> Result<()> { ... }
    fn operator03(&mut self, _arg: &Operator03) -> Result<()> { ... }
    fn operator04(&mut self, _arg: &Operator04) -> Result<()> { ... }
    fn operator05(&mut self, _arg: &Operator05) -> Result<()> { ... }
    fn operator06(&mut self, _arg: &Operator06) -> Result<()> { ... }
    fn operator07(&mut self, _arg: &Operator07) -> Result<()> { ... }
    fn operator08(&mut self, _arg: &Operator08) -> Result<()> { ... }
    fn operator09(&mut self, _arg: &Operator09) -> Result<()> { ... }
    fn operator10(&mut self, _arg: &Operator10) -> Result<()> { ... }
    fn operator11(&mut self, _arg: &Operator11) -> Result<()> { ... }
    fn unary_operator(&mut self, _arg: &UnaryOperator) -> Result<()> { ... }
    fn back_quote(&mut self, _arg: &BackQuote) -> Result<()> { ... }
    fn colon(&mut self, _arg: &Colon) -> Result<()> { ... }
    fn colon_colon_l_angle(&mut self, _arg: &ColonColonLAngle) -> Result<()> { ... }
    fn colon_colon(&mut self, _arg: &ColonColon) -> Result<()> { ... }
    fn comma(&mut self, _arg: &Comma) -> Result<()> { ... }
    fn dot_dot(&mut self, _arg: &DotDot) -> Result<()> { ... }
    fn dot_dot_equ(&mut self, _arg: &DotDotEqu) -> Result<()> { ... }
    fn dot(&mut self, _arg: &Dot) -> Result<()> { ... }
    fn equ(&mut self, _arg: &Equ) -> Result<()> { ... }
    fn hash(&mut self, _arg: &Hash) -> Result<()> { ... }
    fn quote_l_brace(&mut self, _arg: &QuoteLBrace) -> Result<()> { ... }
    fn l_angle(&mut self, _arg: &LAngle) -> Result<()> { ... }
    fn l_brace(&mut self, _arg: &LBrace) -> Result<()> { ... }
    fn l_bracket(&mut self, _arg: &LBracket) -> Result<()> { ... }
    fn l_paren(&mut self, _arg: &LParen) -> Result<()> { ... }
    fn minus_colon(&mut self, _arg: &MinusColon) -> Result<()> { ... }
    fn minus_g_t(&mut self, _arg: &MinusGT) -> Result<()> { ... }
    fn plus_colon(&mut self, _arg: &PlusColon) -> Result<()> { ... }
    fn r_angle(&mut self, _arg: &RAngle) -> Result<()> { ... }
    fn r_brace(&mut self, _arg: &RBrace) -> Result<()> { ... }
    fn r_bracket(&mut self, _arg: &RBracket) -> Result<()> { ... }
    fn r_paren(&mut self, _arg: &RParen) -> Result<()> { ... }
    fn semicolon(&mut self, _arg: &Semicolon) -> Result<()> { ... }
    fn star(&mut self, _arg: &Star) -> Result<()> { ... }
    fn always_comb(&mut self, _arg: &AlwaysComb) -> Result<()> { ... }
    fn always_ff(&mut self, _arg: &AlwaysFf) -> Result<()> { ... }
    fn as(&mut self, _arg: &As) -> Result<()> { ... }
    fn assign(&mut self, _arg: &Assign) -> Result<()> { ... }
    fn bit(&mut self, _arg: &Bit) -> Result<()> { ... }
    fn break(&mut self, _arg: &Break) -> Result<()> { ... }
    fn case(&mut self, _arg: &Case) -> Result<()> { ... }
    fn clock(&mut self, _arg: &Clock) -> Result<()> { ... }
    fn clock_posedge(&mut self, _arg: &ClockPosedge) -> Result<()> { ... }
    fn clock_negedge(&mut self, _arg: &ClockNegedge) -> Result<()> { ... }
    fn const(&mut self, _arg: &Const) -> Result<()> { ... }
    fn defaul(&mut self, _arg: &Defaul) -> Result<()> { ... }
    fn else(&mut self, _arg: &Else) -> Result<()> { ... }
    fn embed(&mut self, _arg: &Embed) -> Result<()> { ... }
    fn enum(&mut self, _arg: &Enum) -> Result<()> { ... }
    fn export(&mut self, _arg: &Export) -> Result<()> { ... }
    fn f32(&mut self, _arg: &F32) -> Result<()> { ... }
    fn f64(&mut self, _arg: &F64) -> Result<()> { ... }
    fn final(&mut self, _arg: &Final) -> Result<()> { ... }
    fn for(&mut self, _arg: &For) -> Result<()> { ... }
    fn function(&mut self, _arg: &Function) -> Result<()> { ... }
    fn i32(&mut self, _arg: &I32) -> Result<()> { ... }
    fn i64(&mut self, _arg: &I64) -> Result<()> { ... }
    fn if(&mut self, _arg: &If) -> Result<()> { ... }
    fn if_reset(&mut self, _arg: &IfReset) -> Result<()> { ... }
    fn import(&mut self, _arg: &Import) -> Result<()> { ... }
    fn in(&mut self, _arg: &In) -> Result<()> { ... }
    fn include(&mut self, _arg: &Include) -> Result<()> { ... }
    fn initial(&mut self, _arg: &Initial) -> Result<()> { ... }
    fn inout(&mut self, _arg: &Inout) -> Result<()> { ... }
    fn input(&mut self, _arg: &Input) -> Result<()> { ... }
    fn inside(&mut self, _arg: &Inside) -> Result<()> { ... }
    fn inst(&mut self, _arg: &Inst) -> Result<()> { ... }
    fn interface(&mut self, _arg: &Interface) -> Result<()> { ... }
    fn let(&mut self, _arg: &Let) -> Result<()> { ... }
    fn logic(&mut self, _arg: &Logic) -> Result<()> { ... }
    fn lsb(&mut self, _arg: &Lsb) -> Result<()> { ... }
    fn modport(&mut self, _arg: &Modport) -> Result<()> { ... }
    fn module(&mut self, _arg: &Module) -> Result<()> { ... }
    fn msb(&mut self, _arg: &Msb) -> Result<()> { ... }
    fn output(&mut self, _arg: &Output) -> Result<()> { ... }
    fn outside(&mut self, _arg: &Outside) -> Result<()> { ... }
    fn package(&mut self, _arg: &Package) -> Result<()> { ... }
    fn param(&mut self, _arg: &Param) -> Result<()> { ... }
    fn proto(&mut self, _arg: &Proto) -> Result<()> { ... }
    fn pub(&mut self, _arg: &Pub) -> Result<()> { ... }
    fn ref(&mut self, _arg: &Ref) -> Result<()> { ... }
    fn repeat(&mut self, _arg: &Repeat) -> Result<()> { ... }
    fn reset(&mut self, _arg: &Reset) -> Result<()> { ... }
    fn reset_async_high(&mut self, _arg: &ResetAsyncHigh) -> Result<()> { ... }
    fn reset_async_low(&mut self, _arg: &ResetAsyncLow) -> Result<()> { ... }
    fn reset_sync_high(&mut self, _arg: &ResetSyncHigh) -> Result<()> { ... }
    fn reset_sync_low(&mut self, _arg: &ResetSyncLow) -> Result<()> { ... }
    fn return(&mut self, _arg: &Return) -> Result<()> { ... }
    fn signed(&mut self, _arg: &Signed) -> Result<()> { ... }
    fn step(&mut self, _arg: &Step) -> Result<()> { ... }
    fn strin(&mut self, _arg: &Strin) -> Result<()> { ... }
    fn struct(&mut self, _arg: &Struct) -> Result<()> { ... }
    fn switch(&mut self, _arg: &Switch) -> Result<()> { ... }
    fn tri(&mut self, _arg: &Tri) -> Result<()> { ... }
    fn type(&mut self, _arg: &Type) -> Result<()> { ... }
    fn u32(&mut self, _arg: &U32) -> Result<()> { ... }
    fn u64(&mut self, _arg: &U64) -> Result<()> { ... }
    fn union(&mut self, _arg: &Union) -> Result<()> { ... }
    fn unsafe(&mut self, _arg: &Unsafe) -> Result<()> { ... }
    fn var(&mut self, _arg: &Var) -> Result<()> { ... }
    fn dollar_identifier(&mut self, _arg: &DollarIdentifier) -> Result<()> { ... }
    fn identifier(&mut self, _arg: &Identifier) -> Result<()> { ... }
    fn number(&mut self, _arg: &Number) -> Result<()> { ... }
    fn integral_number(&mut self, _arg: &IntegralNumber) -> Result<()> { ... }
    fn real_number(&mut self, _arg: &RealNumber) -> Result<()> { ... }
    fn hierarchical_identifier(
        &mut self,
        _arg: &HierarchicalIdentifier,
    ) -> Result<()> { ... }
    fn scoped_identifier(&mut self, _arg: &ScopedIdentifier) -> Result<()> { ... }
    fn expression_identifier(
        &mut self,
        _arg: &ExpressionIdentifier,
    ) -> Result<()> { ... }
    fn expression(&mut self, _arg: &Expression) -> Result<()> { ... }
    fn expression01(&mut self, _arg: &Expression01) -> Result<()> { ... }
    fn expression02(&mut self, _arg: &Expression02) -> Result<()> { ... }
    fn expression03(&mut self, _arg: &Expression03) -> Result<()> { ... }
    fn expression04(&mut self, _arg: &Expression04) -> Result<()> { ... }
    fn expression05(&mut self, _arg: &Expression05) -> Result<()> { ... }
    fn expression06(&mut self, _arg: &Expression06) -> Result<()> { ... }
    fn expression07(&mut self, _arg: &Expression07) -> Result<()> { ... }
    fn expression08(&mut self, _arg: &Expression08) -> Result<()> { ... }
    fn expression09(&mut self, _arg: &Expression09) -> Result<()> { ... }
    fn expression10(&mut self, _arg: &Expression10) -> Result<()> { ... }
    fn expression11(&mut self, _arg: &Expression11) -> Result<()> { ... }
    fn expression12(&mut self, _arg: &Expression12) -> Result<()> { ... }
    fn factor(&mut self, _arg: &Factor) -> Result<()> { ... }
    fn function_call(&mut self, _arg: &FunctionCall) -> Result<()> { ... }
    fn argument_list(&mut self, _arg: &ArgumentList) -> Result<()> { ... }
    fn argument_item(&mut self, _arg: &ArgumentItem) -> Result<()> { ... }
    fn concatenation_list(&mut self, _arg: &ConcatenationList) -> Result<()> { ... }
    fn concatenation_item(&mut self, _arg: &ConcatenationItem) -> Result<()> { ... }
    fn array_literal_list(&mut self, _arg: &ArrayLiteralList) -> Result<()> { ... }
    fn array_literal_item(&mut self, _arg: &ArrayLiteralItem) -> Result<()> { ... }
    fn if_expression(&mut self, _arg: &IfExpression) -> Result<()> { ... }
    fn case_expression(&mut self, _arg: &CaseExpression) -> Result<()> { ... }
    fn switch_expression(&mut self, _arg: &SwitchExpression) -> Result<()> { ... }
    fn type_expression(&mut self, _arg: &TypeExpression) -> Result<()> { ... }
    fn inside_expression(&mut self, _arg: &InsideExpression) -> Result<()> { ... }
    fn outside_expression(&mut self, _arg: &OutsideExpression) -> Result<()> { ... }
    fn range_list(&mut self, _arg: &RangeList) -> Result<()> { ... }
    fn range_item(&mut self, _arg: &RangeItem) -> Result<()> { ... }
    fn select(&mut self, _arg: &Select) -> Result<()> { ... }
    fn select_operator(&mut self, _arg: &SelectOperator) -> Result<()> { ... }
    fn width(&mut self, _arg: &Width) -> Result<()> { ... }
    fn array(&mut self, _arg: &Array) -> Result<()> { ... }
    fn range(&mut self, _arg: &Range) -> Result<()> { ... }
    fn range_operator(&mut self, _arg: &RangeOperator) -> Result<()> { ... }
    fn fixed_type(&mut self, _arg: &FixedType) -> Result<()> { ... }
    fn variable_type(&mut self, _arg: &VariableType) -> Result<()> { ... }
    fn user_defined_type(&mut self, _arg: &UserDefinedType) -> Result<()> { ... }
    fn type_modifier(&mut self, _arg: &TypeModifier) -> Result<()> { ... }
    fn factor_type(&mut self, _arg: &FactorType) -> Result<()> { ... }
    fn scalar_type(&mut self, _arg: &ScalarType) -> Result<()> { ... }
    fn array_type(&mut self, _arg: &ArrayType) -> Result<()> { ... }
    fn casting_type(&mut self, _arg: &CastingType) -> Result<()> { ... }
    fn clock_domain(&mut self, _arg: &ClockDomain) -> Result<()> { ... }
    fn statement_block(&mut self, _arg: &StatementBlock) -> Result<()> { ... }
    fn statement_block_group(
        &mut self,
        _arg: &StatementBlockGroup,
    ) -> Result<()> { ... }
    fn statement_block_item(&mut self, _arg: &StatementBlockItem) -> Result<()> { ... }
    fn statement(&mut self, _arg: &Statement) -> Result<()> { ... }
    fn let_statement(&mut self, _arg: &LetStatement) -> Result<()> { ... }
    fn identifier_statement(&mut self, _arg: &IdentifierStatement) -> Result<()> { ... }
    fn assignment(&mut self, _arg: &Assignment) -> Result<()> { ... }
    fn if_statement(&mut self, _arg: &IfStatement) -> Result<()> { ... }
    fn if_reset_statement(&mut self, _arg: &IfResetStatement) -> Result<()> { ... }
    fn return_statement(&mut self, _arg: &ReturnStatement) -> Result<()> { ... }
    fn break_statement(&mut self, _arg: &BreakStatement) -> Result<()> { ... }
    fn for_statement(&mut self, _arg: &ForStatement) -> Result<()> { ... }
    fn case_statement(&mut self, _arg: &CaseStatement) -> Result<()> { ... }
    fn case_item(&mut self, _arg: &CaseItem) -> Result<()> { ... }
    fn case_condition(&mut self, _arg: &CaseCondition) -> Result<()> { ... }
    fn switch_statement(&mut self, _arg: &SwitchStatement) -> Result<()> { ... }
    fn switch_item(&mut self, _arg: &SwitchItem) -> Result<()> { ... }
    fn switch_condition(&mut self, _arg: &SwitchCondition) -> Result<()> { ... }
    fn attribute(&mut self, _arg: &Attribute) -> Result<()> { ... }
    fn attribute_list(&mut self, _arg: &AttributeList) -> Result<()> { ... }
    fn attribute_item(&mut self, _arg: &AttributeItem) -> Result<()> { ... }
    fn let_declaration(&mut self, _arg: &LetDeclaration) -> Result<()> { ... }
    fn var_declaration(&mut self, _arg: &VarDeclaration) -> Result<()> { ... }
    fn const_declaration(&mut self, _arg: &ConstDeclaration) -> Result<()> { ... }
    fn type_def_declaration(&mut self, _arg: &TypeDefDeclaration) -> Result<()> { ... }
    fn always_ff_declaration(
        &mut self,
        _arg: &AlwaysFfDeclaration,
    ) -> Result<()> { ... }
    fn alwayf_ff_event_list(&mut self, _arg: &AlwayfFfEventList) -> Result<()> { ... }
    fn always_ff_clock(&mut self, _arg: &AlwaysFfClock) -> Result<()> { ... }
    fn always_ff_reset(&mut self, _arg: &AlwaysFfReset) -> Result<()> { ... }
    fn always_comb_declaration(
        &mut self,
        _arg: &AlwaysCombDeclaration,
    ) -> Result<()> { ... }
    fn assign_declaration(&mut self, _arg: &AssignDeclaration) -> Result<()> { ... }
    fn modport_declaration(&mut self, _arg: &ModportDeclaration) -> Result<()> { ... }
    fn modport_list(&mut self, _arg: &ModportList) -> Result<()> { ... }
    fn modport_group(&mut self, _arg: &ModportGroup) -> Result<()> { ... }
    fn modport_item(&mut self, _arg: &ModportItem) -> Result<()> { ... }
    fn enum_declaration(&mut self, _arg: &EnumDeclaration) -> Result<()> { ... }
    fn enum_list(&mut self, _arg: &EnumList) -> Result<()> { ... }
    fn enum_group(&mut self, _arg: &EnumGroup) -> Result<()> { ... }
    fn enum_item(&mut self, _arg: &EnumItem) -> Result<()> { ... }
    fn struct_union(&mut self, _arg: &StructUnion) -> Result<()> { ... }
    fn struct_union_declaration(
        &mut self,
        _arg: &StructUnionDeclaration,
    ) -> Result<()> { ... }
    fn struct_union_list(&mut self, _arg: &StructUnionList) -> Result<()> { ... }
    fn struct_union_group(&mut self, _arg: &StructUnionGroup) -> Result<()> { ... }
    fn struct_union_item(&mut self, _arg: &StructUnionItem) -> Result<()> { ... }
    fn initial_declaration(&mut self, _arg: &InitialDeclaration) -> Result<()> { ... }
    fn final_declaration(&mut self, _arg: &FinalDeclaration) -> Result<()> { ... }
    fn inst_declaration(&mut self, _arg: &InstDeclaration) -> Result<()> { ... }
    fn inst_parameter(&mut self, _arg: &InstParameter) -> Result<()> { ... }
    fn inst_parameter_list(&mut self, _arg: &InstParameterList) -> Result<()> { ... }
    fn inst_parameter_group(&mut self, _arg: &InstParameterGroup) -> Result<()> { ... }
    fn inst_parameter_item(&mut self, _arg: &InstParameterItem) -> Result<()> { ... }
    fn inst_port_list(&mut self, _arg: &InstPortList) -> Result<()> { ... }
    fn inst_port_group(&mut self, _arg: &InstPortGroup) -> Result<()> { ... }
    fn inst_port_item(&mut self, _arg: &InstPortItem) -> Result<()> { ... }
    fn with_parameter(&mut self, _arg: &WithParameter) -> Result<()> { ... }
    fn with_parameter_list(&mut self, _arg: &WithParameterList) -> Result<()> { ... }
    fn with_parameter_group(&mut self, _arg: &WithParameterGroup) -> Result<()> { ... }
    fn with_parameter_item(&mut self, _arg: &WithParameterItem) -> Result<()> { ... }
    fn generic_bound(&mut self, _arg: &GenericBound) -> Result<()> { ... }
    fn with_generic_parameter(
        &mut self,
        _arg: &WithGenericParameter,
    ) -> Result<()> { ... }
    fn with_generic_parameter_list(
        &mut self,
        _arg: &WithGenericParameterList,
    ) -> Result<()> { ... }
    fn with_generic_parameter_item(
        &mut self,
        _arg: &WithGenericParameterItem,
    ) -> Result<()> { ... }
    fn with_generic_argument(
        &mut self,
        _arg: &WithGenericArgument,
    ) -> Result<()> { ... }
    fn with_generic_argument_list(
        &mut self,
        _arg: &WithGenericArgumentList,
    ) -> Result<()> { ... }
    fn with_generic_argument_item(
        &mut self,
        _arg: &WithGenericArgumentItem,
    ) -> Result<()> { ... }
    fn port_declaration(&mut self, _arg: &PortDeclaration) -> Result<()> { ... }
    fn port_declaration_list(
        &mut self,
        _arg: &PortDeclarationList,
    ) -> Result<()> { ... }
    fn port_declaration_group(
        &mut self,
        _arg: &PortDeclarationGroup,
    ) -> Result<()> { ... }
    fn port_declaration_item(
        &mut self,
        _arg: &PortDeclarationItem,
    ) -> Result<()> { ... }
    fn port_type_concrete(&mut self, _arg: &PortTypeConcrete) -> Result<()> { ... }
    fn port_type_abstract(&mut self, _arg: &PortTypeAbstract) -> Result<()> { ... }
    fn direction(&mut self, _arg: &Direction) -> Result<()> { ... }
    fn function_declaration(&mut self, _arg: &FunctionDeclaration) -> Result<()> { ... }
    fn import_declaration(&mut self, _arg: &ImportDeclaration) -> Result<()> { ... }
    fn export_declaration(&mut self, _arg: &ExportDeclaration) -> Result<()> { ... }
    fn unsafe_block(&mut self, _arg: &UnsafeBlock) -> Result<()> { ... }
    fn module_declaration(&mut self, _arg: &ModuleDeclaration) -> Result<()> { ... }
    fn module_group(&mut self, _arg: &ModuleGroup) -> Result<()> { ... }
    fn module_item(&mut self, _arg: &ModuleItem) -> Result<()> { ... }
    fn interface_declaration(
        &mut self,
        _arg: &InterfaceDeclaration,
    ) -> Result<()> { ... }
    fn interface_group(&mut self, _arg: &InterfaceGroup) -> Result<()> { ... }
    fn interface_item(&mut self, _arg: &InterfaceItem) -> Result<()> { ... }
    fn generate_if_declaration(
        &mut self,
        _arg: &GenerateIfDeclaration,
    ) -> Result<()> { ... }
    fn generate_for_declaration(
        &mut self,
        _arg: &GenerateForDeclaration,
    ) -> Result<()> { ... }
    fn generate_block_declaration(
        &mut self,
        _arg: &GenerateBlockDeclaration,
    ) -> Result<()> { ... }
    fn generate_named_block(&mut self, _arg: &GenerateNamedBlock) -> Result<()> { ... }
    fn generate_optional_named_block(
        &mut self,
        _arg: &GenerateOptionalNamedBlock,
    ) -> Result<()> { ... }
    fn generate_group(&mut self, _arg: &GenerateGroup) -> Result<()> { ... }
    fn generate_item(&mut self, _arg: &GenerateItem) -> Result<()> { ... }
    fn package_declaration(&mut self, _arg: &PackageDeclaration) -> Result<()> { ... }
    fn package_group(&mut self, _arg: &PackageGroup) -> Result<()> { ... }
    fn package_item(&mut self, _arg: &PackageItem) -> Result<()> { ... }
    fn proto_module_declaration(
        &mut self,
        _arg: &ProtoModuleDeclaration,
    ) -> Result<()> { ... }
    fn embed_declaration(&mut self, _arg: &EmbedDeclaration) -> Result<()> { ... }
    fn embed_content(&mut self, _arg: &EmbedContent) -> Result<()> { ... }
    fn embed_content_token(&mut self, _arg: &EmbedContentToken) -> Result<()> { ... }
    fn embed_item(&mut self, _arg: &EmbedItem) -> Result<()> { ... }
    fn include_declaration(&mut self, _arg: &IncludeDeclaration) -> Result<()> { ... }
    fn description_group(&mut self, _arg: &DescriptionGroup) -> Result<()> { ... }
    fn description_item(&mut self, _arg: &DescriptionItem) -> Result<()> { ... }
    fn veryl(&mut self, _arg: &Veryl) -> Result<()> { ... }
    fn on_comment_parsed(&mut self, _token: Token<'_>) { ... }
}

Semantic actions trait generated for the user grammar All functions have default implementations.

Provided Methods

fn comments_term(&mut self, _arg: &CommentsTerm) -> Result<()>

Semantic action for non-terminal ‘CommentsTerm’

fn string_literal_term(&mut self, _arg: &StringLiteralTerm) -> Result<()>

Semantic action for non-terminal ‘StringLiteralTerm’

fn exponent_term(&mut self, _arg: &ExponentTerm) -> Result<()>

Semantic action for non-terminal ‘ExponentTerm’

fn fixed_point_term(&mut self, _arg: &FixedPointTerm) -> Result<()>

Semantic action for non-terminal ‘FixedPointTerm’

fn based_term(&mut self, _arg: &BasedTerm) -> Result<()>

Semantic action for non-terminal ‘BasedTerm’

fn all_bit_term(&mut self, _arg: &AllBitTerm) -> Result<()>

Semantic action for non-terminal ‘AllBitTerm’

fn base_less_term(&mut self, _arg: &BaseLessTerm) -> Result<()>

Semantic action for non-terminal ‘BaseLessTerm’

fn minus_colon_term(&mut self, _arg: &MinusColonTerm) -> Result<()>

Semantic action for non-terminal ‘MinusColonTerm’

fn minus_g_t_term(&mut self, _arg: &MinusGTTerm) -> Result<()>

Semantic action for non-terminal ‘MinusGTTerm’

fn plus_colon_term(&mut self, _arg: &PlusColonTerm) -> Result<()>

Semantic action for non-terminal ‘PlusColonTerm’

fn assignment_operator_term( &mut self, _arg: &AssignmentOperatorTerm, ) -> Result<()>

Semantic action for non-terminal ‘AssignmentOperatorTerm’

fn operator11_term(&mut self, _arg: &Operator11Term) -> Result<()>

Semantic action for non-terminal ‘Operator11Term’

fn operator10_term(&mut self, _arg: &Operator10Term) -> Result<()>

Semantic action for non-terminal ‘Operator10Term’

fn operator09_term(&mut self, _arg: &Operator09Term) -> Result<()>

Semantic action for non-terminal ‘Operator09Term’

fn operator08_term(&mut self, _arg: &Operator08Term) -> Result<()>

Semantic action for non-terminal ‘Operator08Term’

fn operator07_term(&mut self, _arg: &Operator07Term) -> Result<()>

Semantic action for non-terminal ‘Operator07Term’

fn operator06_term(&mut self, _arg: &Operator06Term) -> Result<()>

Semantic action for non-terminal ‘Operator06Term’

fn operator02_term(&mut self, _arg: &Operator02Term) -> Result<()>

Semantic action for non-terminal ‘Operator02Term’

fn operator01_term(&mut self, _arg: &Operator01Term) -> Result<()>

Semantic action for non-terminal ‘Operator01Term’

fn operator05_term(&mut self, _arg: &Operator05Term) -> Result<()>

Semantic action for non-terminal ‘Operator05Term’

fn operator04_term(&mut self, _arg: &Operator04Term) -> Result<()>

Semantic action for non-terminal ‘Operator04Term’

fn operator03_term(&mut self, _arg: &Operator03Term) -> Result<()>

Semantic action for non-terminal ‘Operator03Term’

fn unary_operator_term(&mut self, _arg: &UnaryOperatorTerm) -> Result<()>

Semantic action for non-terminal ‘UnaryOperatorTerm’

fn back_quote_term(&mut self, _arg: &BackQuoteTerm) -> Result<()>

Semantic action for non-terminal ‘BackQuoteTerm’

fn colon_colon_l_angle_term( &mut self, _arg: &ColonColonLAngleTerm, ) -> Result<()>

Semantic action for non-terminal ‘ColonColonLAngleTerm’

fn colon_colon_term(&mut self, _arg: &ColonColonTerm) -> Result<()>

Semantic action for non-terminal ‘ColonColonTerm’

fn colon_term(&mut self, _arg: &ColonTerm) -> Result<()>

Semantic action for non-terminal ‘ColonTerm’

fn comma_term(&mut self, _arg: &CommaTerm) -> Result<()>

Semantic action for non-terminal ‘CommaTerm’

fn dot_dot_equ_term(&mut self, _arg: &DotDotEquTerm) -> Result<()>

Semantic action for non-terminal ‘DotDotEquTerm’

fn dot_dot_term(&mut self, _arg: &DotDotTerm) -> Result<()>

Semantic action for non-terminal ‘DotDotTerm’

fn dot_term(&mut self, _arg: &DotTerm) -> Result<()>

Semantic action for non-terminal ‘DotTerm’

fn equ_term(&mut self, _arg: &EquTerm) -> Result<()>

Semantic action for non-terminal ‘EquTerm’

fn hash_term(&mut self, _arg: &HashTerm) -> Result<()>

Semantic action for non-terminal ‘HashTerm’

fn l_angle_term(&mut self, _arg: &LAngleTerm) -> Result<()>

Semantic action for non-terminal ‘LAngleTerm’

fn quote_l_brace_term(&mut self, _arg: &QuoteLBraceTerm) -> Result<()>

Semantic action for non-terminal ‘QuoteLBraceTerm’

fn l_brace_term(&mut self, _arg: &LBraceTerm) -> Result<()>

Semantic action for non-terminal ‘LBraceTerm’

fn l_bracket_term(&mut self, _arg: &LBracketTerm) -> Result<()>

Semantic action for non-terminal ‘LBracketTerm’

fn l_paren_term(&mut self, _arg: &LParenTerm) -> Result<()>

Semantic action for non-terminal ‘LParenTerm’

fn r_angle_term(&mut self, _arg: &RAngleTerm) -> Result<()>

Semantic action for non-terminal ‘RAngleTerm’

fn r_brace_term(&mut self, _arg: &RBraceTerm) -> Result<()>

Semantic action for non-terminal ‘RBraceTerm’

fn r_bracket_term(&mut self, _arg: &RBracketTerm) -> Result<()>

Semantic action for non-terminal ‘RBracketTerm’

fn r_paren_term(&mut self, _arg: &RParenTerm) -> Result<()>

Semantic action for non-terminal ‘RParenTerm’

fn semicolon_term(&mut self, _arg: &SemicolonTerm) -> Result<()>

Semantic action for non-terminal ‘SemicolonTerm’

fn star_term(&mut self, _arg: &StarTerm) -> Result<()>

Semantic action for non-terminal ‘StarTerm’

fn always_comb_term(&mut self, _arg: &AlwaysCombTerm) -> Result<()>

Semantic action for non-terminal ‘AlwaysCombTerm’

fn always_ff_term(&mut self, _arg: &AlwaysFfTerm) -> Result<()>

Semantic action for non-terminal ‘AlwaysFfTerm’

fn assign_term(&mut self, _arg: &AssignTerm) -> Result<()>

Semantic action for non-terminal ‘AssignTerm’

fn as_term(&mut self, _arg: &AsTerm) -> Result<()>

Semantic action for non-terminal ‘AsTerm’

fn bit_term(&mut self, _arg: &BitTerm) -> Result<()>

Semantic action for non-terminal ‘BitTerm’

fn case_term(&mut self, _arg: &CaseTerm) -> Result<()>

Semantic action for non-terminal ‘CaseTerm’

fn clock_term(&mut self, _arg: &ClockTerm) -> Result<()>

Semantic action for non-terminal ‘ClockTerm’

fn clock_posedge_term(&mut self, _arg: &ClockPosedgeTerm) -> Result<()>

Semantic action for non-terminal ‘ClockPosedgeTerm’

fn clock_negedge_term(&mut self, _arg: &ClockNegedgeTerm) -> Result<()>

Semantic action for non-terminal ‘ClockNegedgeTerm’

fn const_term(&mut self, _arg: &ConstTerm) -> Result<()>

Semantic action for non-terminal ‘ConstTerm’

fn default_term(&mut self, _arg: &DefaultTerm) -> Result<()>

Semantic action for non-terminal ‘DefaultTerm’

fn else_term(&mut self, _arg: &ElseTerm) -> Result<()>

Semantic action for non-terminal ‘ElseTerm’

fn embed_term(&mut self, _arg: &EmbedTerm) -> Result<()>

Semantic action for non-terminal ‘EmbedTerm’

fn enum_term(&mut self, _arg: &EnumTerm) -> Result<()>

Semantic action for non-terminal ‘EnumTerm’

fn export_term(&mut self, _arg: &ExportTerm) -> Result<()>

Semantic action for non-terminal ‘ExportTerm’

fn f32_term(&mut self, _arg: &F32Term) -> Result<()>

Semantic action for non-terminal ‘F32Term’

fn f64_term(&mut self, _arg: &F64Term) -> Result<()>

Semantic action for non-terminal ‘F64Term’

fn final_term(&mut self, _arg: &FinalTerm) -> Result<()>

Semantic action for non-terminal ‘FinalTerm’

fn for_term(&mut self, _arg: &ForTerm) -> Result<()>

Semantic action for non-terminal ‘ForTerm’

fn function_term(&mut self, _arg: &FunctionTerm) -> Result<()>

Semantic action for non-terminal ‘FunctionTerm’

fn i32_term(&mut self, _arg: &I32Term) -> Result<()>

Semantic action for non-terminal ‘I32Term’

fn i64_term(&mut self, _arg: &I64Term) -> Result<()>

Semantic action for non-terminal ‘I64Term’

fn if_reset_term(&mut self, _arg: &IfResetTerm) -> Result<()>

Semantic action for non-terminal ‘IfResetTerm’

fn if_term(&mut self, _arg: &IfTerm) -> Result<()>

Semantic action for non-terminal ‘IfTerm’

fn import_term(&mut self, _arg: &ImportTerm) -> Result<()>

Semantic action for non-terminal ‘ImportTerm’

fn include_term(&mut self, _arg: &IncludeTerm) -> Result<()>

Semantic action for non-terminal ‘IncludeTerm’

fn initial_term(&mut self, _arg: &InitialTerm) -> Result<()>

Semantic action for non-terminal ‘InitialTerm’

fn inout_term(&mut self, _arg: &InoutTerm) -> Result<()>

Semantic action for non-terminal ‘InoutTerm’

fn input_term(&mut self, _arg: &InputTerm) -> Result<()>

Semantic action for non-terminal ‘InputTerm’

fn inside_term(&mut self, _arg: &InsideTerm) -> Result<()>

Semantic action for non-terminal ‘InsideTerm’

fn inst_term(&mut self, _arg: &InstTerm) -> Result<()>

Semantic action for non-terminal ‘InstTerm’

fn interface_term(&mut self, _arg: &InterfaceTerm) -> Result<()>

Semantic action for non-terminal ‘InterfaceTerm’

fn in_term(&mut self, _arg: &InTerm) -> Result<()>

Semantic action for non-terminal ‘InTerm’

fn let_term(&mut self, _arg: &LetTerm) -> Result<()>

Semantic action for non-terminal ‘LetTerm’

fn logic_term(&mut self, _arg: &LogicTerm) -> Result<()>

Semantic action for non-terminal ‘LogicTerm’

fn lsb_term(&mut self, _arg: &LsbTerm) -> Result<()>

Semantic action for non-terminal ‘LsbTerm’

fn modport_term(&mut self, _arg: &ModportTerm) -> Result<()>

Semantic action for non-terminal ‘ModportTerm’

fn module_term(&mut self, _arg: &ModuleTerm) -> Result<()>

Semantic action for non-terminal ‘ModuleTerm’

fn msb_term(&mut self, _arg: &MsbTerm) -> Result<()>

Semantic action for non-terminal ‘MsbTerm’

fn output_term(&mut self, _arg: &OutputTerm) -> Result<()>

Semantic action for non-terminal ‘OutputTerm’

fn outside_term(&mut self, _arg: &OutsideTerm) -> Result<()>

Semantic action for non-terminal ‘OutsideTerm’

fn package_term(&mut self, _arg: &PackageTerm) -> Result<()>

Semantic action for non-terminal ‘PackageTerm’

fn param_term(&mut self, _arg: &ParamTerm) -> Result<()>

Semantic action for non-terminal ‘ParamTerm’

fn proto_term(&mut self, _arg: &ProtoTerm) -> Result<()>

Semantic action for non-terminal ‘ProtoTerm’

fn pub_term(&mut self, _arg: &PubTerm) -> Result<()>

Semantic action for non-terminal ‘PubTerm’

fn ref_term(&mut self, _arg: &RefTerm) -> Result<()>

Semantic action for non-terminal ‘RefTerm’

fn repeat_term(&mut self, _arg: &RepeatTerm) -> Result<()>

Semantic action for non-terminal ‘RepeatTerm’

fn reset_term(&mut self, _arg: &ResetTerm) -> Result<()>

Semantic action for non-terminal ‘ResetTerm’

fn reset_async_high_term(&mut self, _arg: &ResetAsyncHighTerm) -> Result<()>

Semantic action for non-terminal ‘ResetAsyncHighTerm’

fn reset_async_low_term(&mut self, _arg: &ResetAsyncLowTerm) -> Result<()>

Semantic action for non-terminal ‘ResetAsyncLowTerm’

fn reset_sync_high_term(&mut self, _arg: &ResetSyncHighTerm) -> Result<()>

Semantic action for non-terminal ‘ResetSyncHighTerm’

fn reset_sync_low_term(&mut self, _arg: &ResetSyncLowTerm) -> Result<()>

Semantic action for non-terminal ‘ResetSyncLowTerm’

fn return_term(&mut self, _arg: &ReturnTerm) -> Result<()>

Semantic action for non-terminal ‘ReturnTerm’

fn break_term(&mut self, _arg: &BreakTerm) -> Result<()>

Semantic action for non-terminal ‘BreakTerm’

fn signed_term(&mut self, _arg: &SignedTerm) -> Result<()>

Semantic action for non-terminal ‘SignedTerm’

fn step_term(&mut self, _arg: &StepTerm) -> Result<()>

Semantic action for non-terminal ‘StepTerm’

fn string_term(&mut self, _arg: &StringTerm) -> Result<()>

Semantic action for non-terminal ‘StringTerm’

fn struct_term(&mut self, _arg: &StructTerm) -> Result<()>

Semantic action for non-terminal ‘StructTerm’

fn switch_term(&mut self, _arg: &SwitchTerm) -> Result<()>

Semantic action for non-terminal ‘SwitchTerm’

fn tri_term(&mut self, _arg: &TriTerm) -> Result<()>

Semantic action for non-terminal ‘TriTerm’

fn type_term(&mut self, _arg: &TypeTerm) -> Result<()>

Semantic action for non-terminal ‘TypeTerm’

fn u32_term(&mut self, _arg: &U32Term) -> Result<()>

Semantic action for non-terminal ‘U32Term’

fn u64_term(&mut self, _arg: &U64Term) -> Result<()>

Semantic action for non-terminal ‘U64Term’

fn union_term(&mut self, _arg: &UnionTerm) -> Result<()>

Semantic action for non-terminal ‘UnionTerm’

fn unsafe_term(&mut self, _arg: &UnsafeTerm) -> Result<()>

Semantic action for non-terminal ‘UnsafeTerm’

fn var_term(&mut self, _arg: &VarTerm) -> Result<()>

Semantic action for non-terminal ‘VarTerm’

fn dollar_identifier_term(&mut self, _arg: &DollarIdentifierTerm) -> Result<()>

Semantic action for non-terminal ‘DollarIdentifierTerm’

fn identifier_term(&mut self, _arg: &IdentifierTerm) -> Result<()>

Semantic action for non-terminal ‘IdentifierTerm’

fn any_term(&mut self, _arg: &AnyTerm) -> Result<()>

Semantic action for non-terminal ‘AnyTerm’

fn comments(&mut self, _arg: &Comments) -> Result<()>

Semantic action for non-terminal ‘Comments’

fn start_token(&mut self, _arg: &StartToken) -> Result<()>

Semantic action for non-terminal ‘StartToken’

fn string_literal_token(&mut self, _arg: &StringLiteralToken) -> Result<()>

Semantic action for non-terminal ‘StringLiteralToken’

fn exponent_token(&mut self, _arg: &ExponentToken) -> Result<()>

Semantic action for non-terminal ‘ExponentToken’

fn fixed_point_token(&mut self, _arg: &FixedPointToken) -> Result<()>

Semantic action for non-terminal ‘FixedPointToken’

fn based_token(&mut self, _arg: &BasedToken) -> Result<()>

Semantic action for non-terminal ‘BasedToken’

fn base_less_token(&mut self, _arg: &BaseLessToken) -> Result<()>

Semantic action for non-terminal ‘BaseLessToken’

fn all_bit_token(&mut self, _arg: &AllBitToken) -> Result<()>

Semantic action for non-terminal ‘AllBitToken’

fn assignment_operator_token( &mut self, _arg: &AssignmentOperatorToken, ) -> Result<()>

Semantic action for non-terminal ‘AssignmentOperatorToken’

fn operator01_token(&mut self, _arg: &Operator01Token) -> Result<()>

Semantic action for non-terminal ‘Operator01Token’

fn operator02_token(&mut self, _arg: &Operator02Token) -> Result<()>

Semantic action for non-terminal ‘Operator02Token’

fn operator03_token(&mut self, _arg: &Operator03Token) -> Result<()>

Semantic action for non-terminal ‘Operator03Token’

fn operator04_token(&mut self, _arg: &Operator04Token) -> Result<()>

Semantic action for non-terminal ‘Operator04Token’

fn operator05_token(&mut self, _arg: &Operator05Token) -> Result<()>

Semantic action for non-terminal ‘Operator05Token’

fn operator06_token(&mut self, _arg: &Operator06Token) -> Result<()>

Semantic action for non-terminal ‘Operator06Token’

fn operator07_token(&mut self, _arg: &Operator07Token) -> Result<()>

Semantic action for non-terminal ‘Operator07Token’

fn operator08_token(&mut self, _arg: &Operator08Token) -> Result<()>

Semantic action for non-terminal ‘Operator08Token’

fn operator09_token(&mut self, _arg: &Operator09Token) -> Result<()>

Semantic action for non-terminal ‘Operator09Token’

fn operator10_token(&mut self, _arg: &Operator10Token) -> Result<()>

Semantic action for non-terminal ‘Operator10Token’

fn operator11_token(&mut self, _arg: &Operator11Token) -> Result<()>

Semantic action for non-terminal ‘Operator11Token’

fn unary_operator_token(&mut self, _arg: &UnaryOperatorToken) -> Result<()>

Semantic action for non-terminal ‘UnaryOperatorToken’

fn back_quote_token(&mut self, _arg: &BackQuoteToken) -> Result<()>

Semantic action for non-terminal ‘BackQuoteToken’

fn colon_token(&mut self, _arg: &ColonToken) -> Result<()>

Semantic action for non-terminal ‘ColonToken’

fn colon_colon_l_angle_token( &mut self, _arg: &ColonColonLAngleToken, ) -> Result<()>

Semantic action for non-terminal ‘ColonColonLAngleToken’

fn colon_colon_token(&mut self, _arg: &ColonColonToken) -> Result<()>

Semantic action for non-terminal ‘ColonColonToken’

fn comma_token(&mut self, _arg: &CommaToken) -> Result<()>

Semantic action for non-terminal ‘CommaToken’

fn dot_dot_token(&mut self, _arg: &DotDotToken) -> Result<()>

Semantic action for non-terminal ‘DotDotToken’

fn dot_dot_equ_token(&mut self, _arg: &DotDotEquToken) -> Result<()>

Semantic action for non-terminal ‘DotDotEquToken’

fn dot_token(&mut self, _arg: &DotToken) -> Result<()>

Semantic action for non-terminal ‘DotToken’

fn equ_token(&mut self, _arg: &EquToken) -> Result<()>

Semantic action for non-terminal ‘EquToken’

fn hash_token(&mut self, _arg: &HashToken) -> Result<()>

Semantic action for non-terminal ‘HashToken’

fn quote_l_brace_token(&mut self, _arg: &QuoteLBraceToken) -> Result<()>

Semantic action for non-terminal ‘QuoteLBraceToken’

fn l_angle_token(&mut self, _arg: &LAngleToken) -> Result<()>

Semantic action for non-terminal ‘LAngleToken’

fn l_brace_token(&mut self, _arg: &LBraceToken) -> Result<()>

Semantic action for non-terminal ‘LBraceToken’

fn l_bracket_token(&mut self, _arg: &LBracketToken) -> Result<()>

Semantic action for non-terminal ‘LBracketToken’

fn l_paren_token(&mut self, _arg: &LParenToken) -> Result<()>

Semantic action for non-terminal ‘LParenToken’

fn minus_colon_token(&mut self, _arg: &MinusColonToken) -> Result<()>

Semantic action for non-terminal ‘MinusColonToken’

fn minus_g_t_token(&mut self, _arg: &MinusGTToken) -> Result<()>

Semantic action for non-terminal ‘MinusGTToken’

fn plus_colon_token(&mut self, _arg: &PlusColonToken) -> Result<()>

Semantic action for non-terminal ‘PlusColonToken’

fn r_angle_token(&mut self, _arg: &RAngleToken) -> Result<()>

Semantic action for non-terminal ‘RAngleToken’

fn r_brace_token(&mut self, _arg: &RBraceToken) -> Result<()>

Semantic action for non-terminal ‘RBraceToken’

fn r_bracket_token(&mut self, _arg: &RBracketToken) -> Result<()>

Semantic action for non-terminal ‘RBracketToken’

fn r_paren_token(&mut self, _arg: &RParenToken) -> Result<()>

Semantic action for non-terminal ‘RParenToken’

fn semicolon_token(&mut self, _arg: &SemicolonToken) -> Result<()>

Semantic action for non-terminal ‘SemicolonToken’

fn star_token(&mut self, _arg: &StarToken) -> Result<()>

Semantic action for non-terminal ‘StarToken’

fn always_comb_token(&mut self, _arg: &AlwaysCombToken) -> Result<()>

Semantic action for non-terminal ‘AlwaysCombToken’

fn always_ff_token(&mut self, _arg: &AlwaysFfToken) -> Result<()>

Semantic action for non-terminal ‘AlwaysFfToken’

fn as_token(&mut self, _arg: &AsToken) -> Result<()>

Semantic action for non-terminal ‘AsToken’

fn assign_token(&mut self, _arg: &AssignToken) -> Result<()>

Semantic action for non-terminal ‘AssignToken’

fn bit_token(&mut self, _arg: &BitToken) -> Result<()>

Semantic action for non-terminal ‘BitToken’

fn case_token(&mut self, _arg: &CaseToken) -> Result<()>

Semantic action for non-terminal ‘CaseToken’

fn clock_token(&mut self, _arg: &ClockToken) -> Result<()>

Semantic action for non-terminal ‘ClockToken’

fn clock_posedge_token(&mut self, _arg: &ClockPosedgeToken) -> Result<()>

Semantic action for non-terminal ‘ClockPosedgeToken’

fn clock_negedge_token(&mut self, _arg: &ClockNegedgeToken) -> Result<()>

Semantic action for non-terminal ‘ClockNegedgeToken’

fn const_token(&mut self, _arg: &ConstToken) -> Result<()>

Semantic action for non-terminal ‘ConstToken’

fn default_token(&mut self, _arg: &DefaultToken) -> Result<()>

Semantic action for non-terminal ‘DefaultToken’

fn else_token(&mut self, _arg: &ElseToken) -> Result<()>

Semantic action for non-terminal ‘ElseToken’

fn embed_token(&mut self, _arg: &EmbedToken) -> Result<()>

Semantic action for non-terminal ‘EmbedToken’

fn enum_token(&mut self, _arg: &EnumToken) -> Result<()>

Semantic action for non-terminal ‘EnumToken’

fn export_token(&mut self, _arg: &ExportToken) -> Result<()>

Semantic action for non-terminal ‘ExportToken’

fn f32_token(&mut self, _arg: &F32Token) -> Result<()>

Semantic action for non-terminal ‘F32Token’

fn f64_token(&mut self, _arg: &F64Token) -> Result<()>

Semantic action for non-terminal ‘F64Token’

fn final_token(&mut self, _arg: &FinalToken) -> Result<()>

Semantic action for non-terminal ‘FinalToken’

fn for_token(&mut self, _arg: &ForToken) -> Result<()>

Semantic action for non-terminal ‘ForToken’

fn function_token(&mut self, _arg: &FunctionToken) -> Result<()>

Semantic action for non-terminal ‘FunctionToken’

fn i32_token(&mut self, _arg: &I32Token) -> Result<()>

Semantic action for non-terminal ‘I32Token’

fn i64_token(&mut self, _arg: &I64Token) -> Result<()>

Semantic action for non-terminal ‘I64Token’

fn if_reset_token(&mut self, _arg: &IfResetToken) -> Result<()>

Semantic action for non-terminal ‘IfResetToken’

fn if_token(&mut self, _arg: &IfToken) -> Result<()>

Semantic action for non-terminal ‘IfToken’

fn import_token(&mut self, _arg: &ImportToken) -> Result<()>

Semantic action for non-terminal ‘ImportToken’

fn include_token(&mut self, _arg: &IncludeToken) -> Result<()>

Semantic action for non-terminal ‘IncludeToken’

fn initial_token(&mut self, _arg: &InitialToken) -> Result<()>

Semantic action for non-terminal ‘InitialToken’

fn inout_token(&mut self, _arg: &InoutToken) -> Result<()>

Semantic action for non-terminal ‘InoutToken’

fn input_token(&mut self, _arg: &InputToken) -> Result<()>

Semantic action for non-terminal ‘InputToken’

fn inside_token(&mut self, _arg: &InsideToken) -> Result<()>

Semantic action for non-terminal ‘InsideToken’

fn inst_token(&mut self, _arg: &InstToken) -> Result<()>

Semantic action for non-terminal ‘InstToken’

fn interface_token(&mut self, _arg: &InterfaceToken) -> Result<()>

Semantic action for non-terminal ‘InterfaceToken’

fn in_token(&mut self, _arg: &InToken) -> Result<()>

Semantic action for non-terminal ‘InToken’

fn let_token(&mut self, _arg: &LetToken) -> Result<()>

Semantic action for non-terminal ‘LetToken’

fn logic_token(&mut self, _arg: &LogicToken) -> Result<()>

Semantic action for non-terminal ‘LogicToken’

fn lsb_token(&mut self, _arg: &LsbToken) -> Result<()>

Semantic action for non-terminal ‘LsbToken’

fn modport_token(&mut self, _arg: &ModportToken) -> Result<()>

Semantic action for non-terminal ‘ModportToken’

fn module_token(&mut self, _arg: &ModuleToken) -> Result<()>

Semantic action for non-terminal ‘ModuleToken’

fn msb_token(&mut self, _arg: &MsbToken) -> Result<()>

Semantic action for non-terminal ‘MsbToken’

fn output_token(&mut self, _arg: &OutputToken) -> Result<()>

Semantic action for non-terminal ‘OutputToken’

fn outside_token(&mut self, _arg: &OutsideToken) -> Result<()>

Semantic action for non-terminal ‘OutsideToken’

fn package_token(&mut self, _arg: &PackageToken) -> Result<()>

Semantic action for non-terminal ‘PackageToken’

fn param_token(&mut self, _arg: &ParamToken) -> Result<()>

Semantic action for non-terminal ‘ParamToken’

fn proto_token(&mut self, _arg: &ProtoToken) -> Result<()>

Semantic action for non-terminal ‘ProtoToken’

fn pub_token(&mut self, _arg: &PubToken) -> Result<()>

Semantic action for non-terminal ‘PubToken’

fn ref_token(&mut self, _arg: &RefToken) -> Result<()>

Semantic action for non-terminal ‘RefToken’

fn repeat_token(&mut self, _arg: &RepeatToken) -> Result<()>

Semantic action for non-terminal ‘RepeatToken’

fn reset_token(&mut self, _arg: &ResetToken) -> Result<()>

Semantic action for non-terminal ‘ResetToken’

fn reset_async_high_token(&mut self, _arg: &ResetAsyncHighToken) -> Result<()>

Semantic action for non-terminal ‘ResetAsyncHighToken’

fn reset_async_low_token(&mut self, _arg: &ResetAsyncLowToken) -> Result<()>

Semantic action for non-terminal ‘ResetAsyncLowToken’

fn reset_sync_high_token(&mut self, _arg: &ResetSyncHighToken) -> Result<()>

Semantic action for non-terminal ‘ResetSyncHighToken’

fn reset_sync_low_token(&mut self, _arg: &ResetSyncLowToken) -> Result<()>

Semantic action for non-terminal ‘ResetSyncLowToken’

fn return_token(&mut self, _arg: &ReturnToken) -> Result<()>

Semantic action for non-terminal ‘ReturnToken’

fn break_token(&mut self, _arg: &BreakToken) -> Result<()>

Semantic action for non-terminal ‘BreakToken’

fn signed_token(&mut self, _arg: &SignedToken) -> Result<()>

Semantic action for non-terminal ‘SignedToken’

fn step_token(&mut self, _arg: &StepToken) -> Result<()>

Semantic action for non-terminal ‘StepToken’

fn string_token(&mut self, _arg: &StringToken) -> Result<()>

Semantic action for non-terminal ‘StringToken’

fn struct_token(&mut self, _arg: &StructToken) -> Result<()>

Semantic action for non-terminal ‘StructToken’

fn switch_token(&mut self, _arg: &SwitchToken) -> Result<()>

Semantic action for non-terminal ‘SwitchToken’

fn tri_token(&mut self, _arg: &TriToken) -> Result<()>

Semantic action for non-terminal ‘TriToken’

fn type_token(&mut self, _arg: &TypeToken) -> Result<()>

Semantic action for non-terminal ‘TypeToken’

fn u32_token(&mut self, _arg: &U32Token) -> Result<()>

Semantic action for non-terminal ‘U32Token’

fn u64_token(&mut self, _arg: &U64Token) -> Result<()>

Semantic action for non-terminal ‘U64Token’

fn union_token(&mut self, _arg: &UnionToken) -> Result<()>

Semantic action for non-terminal ‘UnionToken’

fn unsafe_token(&mut self, _arg: &UnsafeToken) -> Result<()>

Semantic action for non-terminal ‘UnsafeToken’

fn var_token(&mut self, _arg: &VarToken) -> Result<()>

Semantic action for non-terminal ‘VarToken’

fn dollar_identifier_token( &mut self, _arg: &DollarIdentifierToken, ) -> Result<()>

Semantic action for non-terminal ‘DollarIdentifierToken’

fn identifier_token(&mut self, _arg: &IdentifierToken) -> Result<()>

Semantic action for non-terminal ‘IdentifierToken’

fn start(&mut self, _arg: &Start) -> Result<()>

Semantic action for non-terminal ‘Start’

fn string_literal(&mut self, _arg: &StringLiteral) -> Result<()>

Semantic action for non-terminal ‘StringLiteral’

fn exponent(&mut self, _arg: &Exponent) -> Result<()>

Semantic action for non-terminal ‘Exponent’

fn fixed_point(&mut self, _arg: &FixedPoint) -> Result<()>

Semantic action for non-terminal ‘FixedPoint’

fn based(&mut self, _arg: &Based) -> Result<()>

Semantic action for non-terminal ‘Based’

fn base_less(&mut self, _arg: &BaseLess) -> Result<()>

Semantic action for non-terminal ‘BaseLess’

fn all_bit(&mut self, _arg: &AllBit) -> Result<()>

Semantic action for non-terminal ‘AllBit’

fn assignment_operator(&mut self, _arg: &AssignmentOperator) -> Result<()>

Semantic action for non-terminal ‘AssignmentOperator’

fn operator01(&mut self, _arg: &Operator01) -> Result<()>

Semantic action for non-terminal ‘Operator01’

fn operator02(&mut self, _arg: &Operator02) -> Result<()>

Semantic action for non-terminal ‘Operator02’

fn operator03(&mut self, _arg: &Operator03) -> Result<()>

Semantic action for non-terminal ‘Operator03’

fn operator04(&mut self, _arg: &Operator04) -> Result<()>

Semantic action for non-terminal ‘Operator04’

fn operator05(&mut self, _arg: &Operator05) -> Result<()>

Semantic action for non-terminal ‘Operator05’

fn operator06(&mut self, _arg: &Operator06) -> Result<()>

Semantic action for non-terminal ‘Operator06’

fn operator07(&mut self, _arg: &Operator07) -> Result<()>

Semantic action for non-terminal ‘Operator07’

fn operator08(&mut self, _arg: &Operator08) -> Result<()>

Semantic action for non-terminal ‘Operator08’

fn operator09(&mut self, _arg: &Operator09) -> Result<()>

Semantic action for non-terminal ‘Operator09’

fn operator10(&mut self, _arg: &Operator10) -> Result<()>

Semantic action for non-terminal ‘Operator10’

fn operator11(&mut self, _arg: &Operator11) -> Result<()>

Semantic action for non-terminal ‘Operator11’

fn unary_operator(&mut self, _arg: &UnaryOperator) -> Result<()>

Semantic action for non-terminal ‘UnaryOperator’

fn back_quote(&mut self, _arg: &BackQuote) -> Result<()>

Semantic action for non-terminal ‘BackQuote’

fn colon(&mut self, _arg: &Colon) -> Result<()>

Semantic action for non-terminal ‘Colon’

fn colon_colon_l_angle(&mut self, _arg: &ColonColonLAngle) -> Result<()>

Semantic action for non-terminal ‘ColonColonLAngle’

fn colon_colon(&mut self, _arg: &ColonColon) -> Result<()>

Semantic action for non-terminal ‘ColonColon’

fn comma(&mut self, _arg: &Comma) -> Result<()>

Semantic action for non-terminal ‘Comma’

fn dot_dot(&mut self, _arg: &DotDot) -> Result<()>

Semantic action for non-terminal ‘DotDot’

fn dot_dot_equ(&mut self, _arg: &DotDotEqu) -> Result<()>

Semantic action for non-terminal ‘DotDotEqu’

fn dot(&mut self, _arg: &Dot) -> Result<()>

Semantic action for non-terminal ‘Dot’

fn equ(&mut self, _arg: &Equ) -> Result<()>

Semantic action for non-terminal ‘Equ’

fn hash(&mut self, _arg: &Hash) -> Result<()>

Semantic action for non-terminal ‘Hash’

fn quote_l_brace(&mut self, _arg: &QuoteLBrace) -> Result<()>

Semantic action for non-terminal ‘QuoteLBrace’

fn l_angle(&mut self, _arg: &LAngle) -> Result<()>

Semantic action for non-terminal ‘LAngle’

fn l_brace(&mut self, _arg: &LBrace) -> Result<()>

Semantic action for non-terminal ‘LBrace’

fn l_bracket(&mut self, _arg: &LBracket) -> Result<()>

Semantic action for non-terminal ‘LBracket’

fn l_paren(&mut self, _arg: &LParen) -> Result<()>

Semantic action for non-terminal ‘LParen’

fn minus_colon(&mut self, _arg: &MinusColon) -> Result<()>

Semantic action for non-terminal ‘MinusColon’

fn minus_g_t(&mut self, _arg: &MinusGT) -> Result<()>

Semantic action for non-terminal ‘MinusGT’

fn plus_colon(&mut self, _arg: &PlusColon) -> Result<()>

Semantic action for non-terminal ‘PlusColon’

fn r_angle(&mut self, _arg: &RAngle) -> Result<()>

Semantic action for non-terminal ‘RAngle’

fn r_brace(&mut self, _arg: &RBrace) -> Result<()>

Semantic action for non-terminal ‘RBrace’

fn r_bracket(&mut self, _arg: &RBracket) -> Result<()>

Semantic action for non-terminal ‘RBracket’

fn r_paren(&mut self, _arg: &RParen) -> Result<()>

Semantic action for non-terminal ‘RParen’

fn semicolon(&mut self, _arg: &Semicolon) -> Result<()>

Semantic action for non-terminal ‘Semicolon’

fn star(&mut self, _arg: &Star) -> Result<()>

Semantic action for non-terminal ‘Star’

fn always_comb(&mut self, _arg: &AlwaysComb) -> Result<()>

Semantic action for non-terminal ‘AlwaysComb’

fn always_ff(&mut self, _arg: &AlwaysFf) -> Result<()>

Semantic action for non-terminal ‘AlwaysFf’

fn as(&mut self, _arg: &As) -> Result<()>

Semantic action for non-terminal ‘As’

fn assign(&mut self, _arg: &Assign) -> Result<()>

Semantic action for non-terminal ‘Assign’

fn bit(&mut self, _arg: &Bit) -> Result<()>

Semantic action for non-terminal ‘Bit’

fn break(&mut self, _arg: &Break) -> Result<()>

Semantic action for non-terminal ‘Break’

fn case(&mut self, _arg: &Case) -> Result<()>

Semantic action for non-terminal ‘Case’

fn clock(&mut self, _arg: &Clock) -> Result<()>

Semantic action for non-terminal ‘Clock’

fn clock_posedge(&mut self, _arg: &ClockPosedge) -> Result<()>

Semantic action for non-terminal ‘ClockPosedge’

fn clock_negedge(&mut self, _arg: &ClockNegedge) -> Result<()>

Semantic action for non-terminal ‘ClockNegedge’

fn const(&mut self, _arg: &Const) -> Result<()>

Semantic action for non-terminal ‘Const’

fn defaul(&mut self, _arg: &Defaul) -> Result<()>

Semantic action for non-terminal ‘Defaul’

fn else(&mut self, _arg: &Else) -> Result<()>

Semantic action for non-terminal ‘Else’

fn embed(&mut self, _arg: &Embed) -> Result<()>

Semantic action for non-terminal ‘Embed’

fn enum(&mut self, _arg: &Enum) -> Result<()>

Semantic action for non-terminal ‘Enum’

fn export(&mut self, _arg: &Export) -> Result<()>

Semantic action for non-terminal ‘Export’

fn f32(&mut self, _arg: &F32) -> Result<()>

Semantic action for non-terminal ‘F32’

fn f64(&mut self, _arg: &F64) -> Result<()>

Semantic action for non-terminal ‘F64’

fn final(&mut self, _arg: &Final) -> Result<()>

Semantic action for non-terminal ‘Final’

fn for(&mut self, _arg: &For) -> Result<()>

Semantic action for non-terminal ‘For’

fn function(&mut self, _arg: &Function) -> Result<()>

Semantic action for non-terminal ‘Function’

fn i32(&mut self, _arg: &I32) -> Result<()>

Semantic action for non-terminal ‘I32’

fn i64(&mut self, _arg: &I64) -> Result<()>

Semantic action for non-terminal ‘I64’

fn if(&mut self, _arg: &If) -> Result<()>

Semantic action for non-terminal ‘If’

fn if_reset(&mut self, _arg: &IfReset) -> Result<()>

Semantic action for non-terminal ‘IfReset’

fn import(&mut self, _arg: &Import) -> Result<()>

Semantic action for non-terminal ‘Import’

fn in(&mut self, _arg: &In) -> Result<()>

Semantic action for non-terminal ‘In’

fn include(&mut self, _arg: &Include) -> Result<()>

Semantic action for non-terminal ‘Include’

fn initial(&mut self, _arg: &Initial) -> Result<()>

Semantic action for non-terminal ‘Initial’

fn inout(&mut self, _arg: &Inout) -> Result<()>

Semantic action for non-terminal ‘Inout’

fn input(&mut self, _arg: &Input) -> Result<()>

Semantic action for non-terminal ‘Input’

fn inside(&mut self, _arg: &Inside) -> Result<()>

Semantic action for non-terminal ‘Inside’

fn inst(&mut self, _arg: &Inst) -> Result<()>

Semantic action for non-terminal ‘Inst’

fn interface(&mut self, _arg: &Interface) -> Result<()>

Semantic action for non-terminal ‘Interface’

fn let(&mut self, _arg: &Let) -> Result<()>

Semantic action for non-terminal ‘Let’

fn logic(&mut self, _arg: &Logic) -> Result<()>

Semantic action for non-terminal ‘Logic’

fn lsb(&mut self, _arg: &Lsb) -> Result<()>

Semantic action for non-terminal ‘Lsb’

fn modport(&mut self, _arg: &Modport) -> Result<()>

Semantic action for non-terminal ‘Modport’

fn module(&mut self, _arg: &Module) -> Result<()>

Semantic action for non-terminal ‘Module’

fn msb(&mut self, _arg: &Msb) -> Result<()>

Semantic action for non-terminal ‘Msb’

fn output(&mut self, _arg: &Output) -> Result<()>

Semantic action for non-terminal ‘Output’

fn outside(&mut self, _arg: &Outside) -> Result<()>

Semantic action for non-terminal ‘Outside’

fn package(&mut self, _arg: &Package) -> Result<()>

Semantic action for non-terminal ‘Package’

fn param(&mut self, _arg: &Param) -> Result<()>

Semantic action for non-terminal ‘Param’

fn proto(&mut self, _arg: &Proto) -> Result<()>

Semantic action for non-terminal ‘Proto’

fn pub(&mut self, _arg: &Pub) -> Result<()>

Semantic action for non-terminal ‘Pub’

fn ref(&mut self, _arg: &Ref) -> Result<()>

Semantic action for non-terminal ‘Ref’

fn repeat(&mut self, _arg: &Repeat) -> Result<()>

Semantic action for non-terminal ‘Repeat’

fn reset(&mut self, _arg: &Reset) -> Result<()>

Semantic action for non-terminal ‘Reset’

fn reset_async_high(&mut self, _arg: &ResetAsyncHigh) -> Result<()>

Semantic action for non-terminal ‘ResetAsyncHigh’

fn reset_async_low(&mut self, _arg: &ResetAsyncLow) -> Result<()>

Semantic action for non-terminal ‘ResetAsyncLow’

fn reset_sync_high(&mut self, _arg: &ResetSyncHigh) -> Result<()>

Semantic action for non-terminal ‘ResetSyncHigh’

fn reset_sync_low(&mut self, _arg: &ResetSyncLow) -> Result<()>

Semantic action for non-terminal ‘ResetSyncLow’

fn return(&mut self, _arg: &Return) -> Result<()>

Semantic action for non-terminal ‘Return’

fn signed(&mut self, _arg: &Signed) -> Result<()>

Semantic action for non-terminal ‘Signed’

fn step(&mut self, _arg: &Step) -> Result<()>

Semantic action for non-terminal ‘Step’

fn strin(&mut self, _arg: &Strin) -> Result<()>

Semantic action for non-terminal ‘Strin’

fn struct(&mut self, _arg: &Struct) -> Result<()>

Semantic action for non-terminal ‘Struct’

fn switch(&mut self, _arg: &Switch) -> Result<()>

Semantic action for non-terminal ‘Switch’

fn tri(&mut self, _arg: &Tri) -> Result<()>

Semantic action for non-terminal ‘Tri’

fn type(&mut self, _arg: &Type) -> Result<()>

Semantic action for non-terminal ‘Type’

fn u32(&mut self, _arg: &U32) -> Result<()>

Semantic action for non-terminal ‘U32’

fn u64(&mut self, _arg: &U64) -> Result<()>

Semantic action for non-terminal ‘U64’

fn union(&mut self, _arg: &Union) -> Result<()>

Semantic action for non-terminal ‘Union’

fn unsafe(&mut self, _arg: &Unsafe) -> Result<()>

Semantic action for non-terminal ‘Unsafe’

fn var(&mut self, _arg: &Var) -> Result<()>

Semantic action for non-terminal ‘Var’

fn dollar_identifier(&mut self, _arg: &DollarIdentifier) -> Result<()>

Semantic action for non-terminal ‘DollarIdentifier’

fn identifier(&mut self, _arg: &Identifier) -> Result<()>

Semantic action for non-terminal ‘Identifier’

fn number(&mut self, _arg: &Number) -> Result<()>

Semantic action for non-terminal ‘Number’

fn integral_number(&mut self, _arg: &IntegralNumber) -> Result<()>

Semantic action for non-terminal ‘IntegralNumber’

fn real_number(&mut self, _arg: &RealNumber) -> Result<()>

Semantic action for non-terminal ‘RealNumber’

fn hierarchical_identifier( &mut self, _arg: &HierarchicalIdentifier, ) -> Result<()>

Semantic action for non-terminal ‘HierarchicalIdentifier’

fn scoped_identifier(&mut self, _arg: &ScopedIdentifier) -> Result<()>

Semantic action for non-terminal ‘ScopedIdentifier’

fn expression_identifier(&mut self, _arg: &ExpressionIdentifier) -> Result<()>

Semantic action for non-terminal ‘ExpressionIdentifier’

fn expression(&mut self, _arg: &Expression) -> Result<()>

Semantic action for non-terminal ‘Expression’

fn expression01(&mut self, _arg: &Expression01) -> Result<()>

Semantic action for non-terminal ‘Expression01’

fn expression02(&mut self, _arg: &Expression02) -> Result<()>

Semantic action for non-terminal ‘Expression02’

fn expression03(&mut self, _arg: &Expression03) -> Result<()>

Semantic action for non-terminal ‘Expression03’

fn expression04(&mut self, _arg: &Expression04) -> Result<()>

Semantic action for non-terminal ‘Expression04’

fn expression05(&mut self, _arg: &Expression05) -> Result<()>

Semantic action for non-terminal ‘Expression05’

fn expression06(&mut self, _arg: &Expression06) -> Result<()>

Semantic action for non-terminal ‘Expression06’

fn expression07(&mut self, _arg: &Expression07) -> Result<()>

Semantic action for non-terminal ‘Expression07’

fn expression08(&mut self, _arg: &Expression08) -> Result<()>

Semantic action for non-terminal ‘Expression08’

fn expression09(&mut self, _arg: &Expression09) -> Result<()>

Semantic action for non-terminal ‘Expression09’

fn expression10(&mut self, _arg: &Expression10) -> Result<()>

Semantic action for non-terminal ‘Expression10’

fn expression11(&mut self, _arg: &Expression11) -> Result<()>

Semantic action for non-terminal ‘Expression11’

fn expression12(&mut self, _arg: &Expression12) -> Result<()>

Semantic action for non-terminal ‘Expression12’

fn factor(&mut self, _arg: &Factor) -> Result<()>

Semantic action for non-terminal ‘Factor’

fn function_call(&mut self, _arg: &FunctionCall) -> Result<()>

Semantic action for non-terminal ‘FunctionCall’

fn argument_list(&mut self, _arg: &ArgumentList) -> Result<()>

Semantic action for non-terminal ‘ArgumentList’

fn argument_item(&mut self, _arg: &ArgumentItem) -> Result<()>

Semantic action for non-terminal ‘ArgumentItem’

fn concatenation_list(&mut self, _arg: &ConcatenationList) -> Result<()>

Semantic action for non-terminal ‘ConcatenationList’

fn concatenation_item(&mut self, _arg: &ConcatenationItem) -> Result<()>

Semantic action for non-terminal ‘ConcatenationItem’

fn array_literal_list(&mut self, _arg: &ArrayLiteralList) -> Result<()>

Semantic action for non-terminal ‘ArrayLiteralList’

fn array_literal_item(&mut self, _arg: &ArrayLiteralItem) -> Result<()>

Semantic action for non-terminal ‘ArrayLiteralItem’

fn if_expression(&mut self, _arg: &IfExpression) -> Result<()>

Semantic action for non-terminal ‘IfExpression’

fn case_expression(&mut self, _arg: &CaseExpression) -> Result<()>

Semantic action for non-terminal ‘CaseExpression’

fn switch_expression(&mut self, _arg: &SwitchExpression) -> Result<()>

Semantic action for non-terminal ‘SwitchExpression’

fn type_expression(&mut self, _arg: &TypeExpression) -> Result<()>

Semantic action for non-terminal ‘TypeExpression’

fn inside_expression(&mut self, _arg: &InsideExpression) -> Result<()>

Semantic action for non-terminal ‘InsideExpression’

fn outside_expression(&mut self, _arg: &OutsideExpression) -> Result<()>

Semantic action for non-terminal ‘OutsideExpression’

fn range_list(&mut self, _arg: &RangeList) -> Result<()>

Semantic action for non-terminal ‘RangeList’

fn range_item(&mut self, _arg: &RangeItem) -> Result<()>

Semantic action for non-terminal ‘RangeItem’

fn select(&mut self, _arg: &Select) -> Result<()>

Semantic action for non-terminal ‘Select’

fn select_operator(&mut self, _arg: &SelectOperator) -> Result<()>

Semantic action for non-terminal ‘SelectOperator’

fn width(&mut self, _arg: &Width) -> Result<()>

Semantic action for non-terminal ‘Width’

fn array(&mut self, _arg: &Array) -> Result<()>

Semantic action for non-terminal ‘Array’

fn range(&mut self, _arg: &Range) -> Result<()>

Semantic action for non-terminal ‘Range’

fn range_operator(&mut self, _arg: &RangeOperator) -> Result<()>

Semantic action for non-terminal ‘RangeOperator’

fn fixed_type(&mut self, _arg: &FixedType) -> Result<()>

Semantic action for non-terminal ‘FixedType’

fn variable_type(&mut self, _arg: &VariableType) -> Result<()>

Semantic action for non-terminal ‘VariableType’

fn user_defined_type(&mut self, _arg: &UserDefinedType) -> Result<()>

Semantic action for non-terminal ‘UserDefinedType’

fn type_modifier(&mut self, _arg: &TypeModifier) -> Result<()>

Semantic action for non-terminal ‘TypeModifier’

fn factor_type(&mut self, _arg: &FactorType) -> Result<()>

Semantic action for non-terminal ‘FactorType’

fn scalar_type(&mut self, _arg: &ScalarType) -> Result<()>

Semantic action for non-terminal ‘ScalarType’

fn array_type(&mut self, _arg: &ArrayType) -> Result<()>

Semantic action for non-terminal ‘ArrayType’

fn casting_type(&mut self, _arg: &CastingType) -> Result<()>

Semantic action for non-terminal ‘CastingType’

fn clock_domain(&mut self, _arg: &ClockDomain) -> Result<()>

Semantic action for non-terminal ‘ClockDomain’

fn statement_block(&mut self, _arg: &StatementBlock) -> Result<()>

Semantic action for non-terminal ‘StatementBlock’

fn statement_block_group(&mut self, _arg: &StatementBlockGroup) -> Result<()>

Semantic action for non-terminal ‘StatementBlockGroup’

fn statement_block_item(&mut self, _arg: &StatementBlockItem) -> Result<()>

Semantic action for non-terminal ‘StatementBlockItem’

fn statement(&mut self, _arg: &Statement) -> Result<()>

Semantic action for non-terminal ‘Statement’

fn let_statement(&mut self, _arg: &LetStatement) -> Result<()>

Semantic action for non-terminal ‘LetStatement’

fn identifier_statement(&mut self, _arg: &IdentifierStatement) -> Result<()>

Semantic action for non-terminal ‘IdentifierStatement’

fn assignment(&mut self, _arg: &Assignment) -> Result<()>

Semantic action for non-terminal ‘Assignment’

fn if_statement(&mut self, _arg: &IfStatement) -> Result<()>

Semantic action for non-terminal ‘IfStatement’

fn if_reset_statement(&mut self, _arg: &IfResetStatement) -> Result<()>

Semantic action for non-terminal ‘IfResetStatement’

fn return_statement(&mut self, _arg: &ReturnStatement) -> Result<()>

Semantic action for non-terminal ‘ReturnStatement’

fn break_statement(&mut self, _arg: &BreakStatement) -> Result<()>

Semantic action for non-terminal ‘BreakStatement’

fn for_statement(&mut self, _arg: &ForStatement) -> Result<()>

Semantic action for non-terminal ‘ForStatement’

fn case_statement(&mut self, _arg: &CaseStatement) -> Result<()>

Semantic action for non-terminal ‘CaseStatement’

fn case_item(&mut self, _arg: &CaseItem) -> Result<()>

Semantic action for non-terminal ‘CaseItem’

fn case_condition(&mut self, _arg: &CaseCondition) -> Result<()>

Semantic action for non-terminal ‘CaseCondition’

fn switch_statement(&mut self, _arg: &SwitchStatement) -> Result<()>

Semantic action for non-terminal ‘SwitchStatement’

fn switch_item(&mut self, _arg: &SwitchItem) -> Result<()>

Semantic action for non-terminal ‘SwitchItem’

fn switch_condition(&mut self, _arg: &SwitchCondition) -> Result<()>

Semantic action for non-terminal ‘SwitchCondition’

fn attribute(&mut self, _arg: &Attribute) -> Result<()>

Semantic action for non-terminal ‘Attribute’

fn attribute_list(&mut self, _arg: &AttributeList) -> Result<()>

Semantic action for non-terminal ‘AttributeList’

fn attribute_item(&mut self, _arg: &AttributeItem) -> Result<()>

Semantic action for non-terminal ‘AttributeItem’

fn let_declaration(&mut self, _arg: &LetDeclaration) -> Result<()>

Semantic action for non-terminal ‘LetDeclaration’

fn var_declaration(&mut self, _arg: &VarDeclaration) -> Result<()>

Semantic action for non-terminal ‘VarDeclaration’

fn const_declaration(&mut self, _arg: &ConstDeclaration) -> Result<()>

Semantic action for non-terminal ‘ConstDeclaration’

fn type_def_declaration(&mut self, _arg: &TypeDefDeclaration) -> Result<()>

Semantic action for non-terminal ‘TypeDefDeclaration’

fn always_ff_declaration(&mut self, _arg: &AlwaysFfDeclaration) -> Result<()>

Semantic action for non-terminal ‘AlwaysFfDeclaration’

fn alwayf_ff_event_list(&mut self, _arg: &AlwayfFfEventList) -> Result<()>

Semantic action for non-terminal ‘AlwayfFfEventList’

fn always_ff_clock(&mut self, _arg: &AlwaysFfClock) -> Result<()>

Semantic action for non-terminal ‘AlwaysFfClock’

fn always_ff_reset(&mut self, _arg: &AlwaysFfReset) -> Result<()>

Semantic action for non-terminal ‘AlwaysFfReset’

fn always_comb_declaration( &mut self, _arg: &AlwaysCombDeclaration, ) -> Result<()>

Semantic action for non-terminal ‘AlwaysCombDeclaration’

fn assign_declaration(&mut self, _arg: &AssignDeclaration) -> Result<()>

Semantic action for non-terminal ‘AssignDeclaration’

fn modport_declaration(&mut self, _arg: &ModportDeclaration) -> Result<()>

Semantic action for non-terminal ‘ModportDeclaration’

fn modport_list(&mut self, _arg: &ModportList) -> Result<()>

Semantic action for non-terminal ‘ModportList’

fn modport_group(&mut self, _arg: &ModportGroup) -> Result<()>

Semantic action for non-terminal ‘ModportGroup’

fn modport_item(&mut self, _arg: &ModportItem) -> Result<()>

Semantic action for non-terminal ‘ModportItem’

fn enum_declaration(&mut self, _arg: &EnumDeclaration) -> Result<()>

Semantic action for non-terminal ‘EnumDeclaration’

fn enum_list(&mut self, _arg: &EnumList) -> Result<()>

Semantic action for non-terminal ‘EnumList’

fn enum_group(&mut self, _arg: &EnumGroup) -> Result<()>

Semantic action for non-terminal ‘EnumGroup’

fn enum_item(&mut self, _arg: &EnumItem) -> Result<()>

Semantic action for non-terminal ‘EnumItem’

fn struct_union(&mut self, _arg: &StructUnion) -> Result<()>

Semantic action for non-terminal ‘StructUnion’

fn struct_union_declaration( &mut self, _arg: &StructUnionDeclaration, ) -> Result<()>

Semantic action for non-terminal ‘StructUnionDeclaration’

fn struct_union_list(&mut self, _arg: &StructUnionList) -> Result<()>

Semantic action for non-terminal ‘StructUnionList’

fn struct_union_group(&mut self, _arg: &StructUnionGroup) -> Result<()>

Semantic action for non-terminal ‘StructUnionGroup’

fn struct_union_item(&mut self, _arg: &StructUnionItem) -> Result<()>

Semantic action for non-terminal ‘StructUnionItem’

fn initial_declaration(&mut self, _arg: &InitialDeclaration) -> Result<()>

Semantic action for non-terminal ‘InitialDeclaration’

fn final_declaration(&mut self, _arg: &FinalDeclaration) -> Result<()>

Semantic action for non-terminal ‘FinalDeclaration’

fn inst_declaration(&mut self, _arg: &InstDeclaration) -> Result<()>

Semantic action for non-terminal ‘InstDeclaration’

fn inst_parameter(&mut self, _arg: &InstParameter) -> Result<()>

Semantic action for non-terminal ‘InstParameter’

fn inst_parameter_list(&mut self, _arg: &InstParameterList) -> Result<()>

Semantic action for non-terminal ‘InstParameterList’

fn inst_parameter_group(&mut self, _arg: &InstParameterGroup) -> Result<()>

Semantic action for non-terminal ‘InstParameterGroup’

fn inst_parameter_item(&mut self, _arg: &InstParameterItem) -> Result<()>

Semantic action for non-terminal ‘InstParameterItem’

fn inst_port_list(&mut self, _arg: &InstPortList) -> Result<()>

Semantic action for non-terminal ‘InstPortList’

fn inst_port_group(&mut self, _arg: &InstPortGroup) -> Result<()>

Semantic action for non-terminal ‘InstPortGroup’

fn inst_port_item(&mut self, _arg: &InstPortItem) -> Result<()>

Semantic action for non-terminal ‘InstPortItem’

fn with_parameter(&mut self, _arg: &WithParameter) -> Result<()>

Semantic action for non-terminal ‘WithParameter’

fn with_parameter_list(&mut self, _arg: &WithParameterList) -> Result<()>

Semantic action for non-terminal ‘WithParameterList’

fn with_parameter_group(&mut self, _arg: &WithParameterGroup) -> Result<()>

Semantic action for non-terminal ‘WithParameterGroup’

fn with_parameter_item(&mut self, _arg: &WithParameterItem) -> Result<()>

Semantic action for non-terminal ‘WithParameterItem’

fn generic_bound(&mut self, _arg: &GenericBound) -> Result<()>

Semantic action for non-terminal ‘GenericBound’

fn with_generic_parameter(&mut self, _arg: &WithGenericParameter) -> Result<()>

Semantic action for non-terminal ‘WithGenericParameter’

fn with_generic_parameter_list( &mut self, _arg: &WithGenericParameterList, ) -> Result<()>

Semantic action for non-terminal ‘WithGenericParameterList’

fn with_generic_parameter_item( &mut self, _arg: &WithGenericParameterItem, ) -> Result<()>

Semantic action for non-terminal ‘WithGenericParameterItem’

fn with_generic_argument(&mut self, _arg: &WithGenericArgument) -> Result<()>

Semantic action for non-terminal ‘WithGenericArgument’

fn with_generic_argument_list( &mut self, _arg: &WithGenericArgumentList, ) -> Result<()>

Semantic action for non-terminal ‘WithGenericArgumentList’

fn with_generic_argument_item( &mut self, _arg: &WithGenericArgumentItem, ) -> Result<()>

Semantic action for non-terminal ‘WithGenericArgumentItem’

fn port_declaration(&mut self, _arg: &PortDeclaration) -> Result<()>

Semantic action for non-terminal ‘PortDeclaration’

fn port_declaration_list(&mut self, _arg: &PortDeclarationList) -> Result<()>

Semantic action for non-terminal ‘PortDeclarationList’

fn port_declaration_group(&mut self, _arg: &PortDeclarationGroup) -> Result<()>

Semantic action for non-terminal ‘PortDeclarationGroup’

fn port_declaration_item(&mut self, _arg: &PortDeclarationItem) -> Result<()>

Semantic action for non-terminal ‘PortDeclarationItem’

fn port_type_concrete(&mut self, _arg: &PortTypeConcrete) -> Result<()>

Semantic action for non-terminal ‘PortTypeConcrete’

fn port_type_abstract(&mut self, _arg: &PortTypeAbstract) -> Result<()>

Semantic action for non-terminal ‘PortTypeAbstract’

fn direction(&mut self, _arg: &Direction) -> Result<()>

Semantic action for non-terminal ‘Direction’

fn function_declaration(&mut self, _arg: &FunctionDeclaration) -> Result<()>

Semantic action for non-terminal ‘FunctionDeclaration’

fn import_declaration(&mut self, _arg: &ImportDeclaration) -> Result<()>

Semantic action for non-terminal ‘ImportDeclaration’

fn export_declaration(&mut self, _arg: &ExportDeclaration) -> Result<()>

Semantic action for non-terminal ‘ExportDeclaration’

fn unsafe_block(&mut self, _arg: &UnsafeBlock) -> Result<()>

Semantic action for non-terminal ‘UnsafeBlock’

fn module_declaration(&mut self, _arg: &ModuleDeclaration) -> Result<()>

Semantic action for non-terminal ‘ModuleDeclaration’

fn module_group(&mut self, _arg: &ModuleGroup) -> Result<()>

Semantic action for non-terminal ‘ModuleGroup’

fn module_item(&mut self, _arg: &ModuleItem) -> Result<()>

Semantic action for non-terminal ‘ModuleItem’

fn interface_declaration(&mut self, _arg: &InterfaceDeclaration) -> Result<()>

Semantic action for non-terminal ‘InterfaceDeclaration’

fn interface_group(&mut self, _arg: &InterfaceGroup) -> Result<()>

Semantic action for non-terminal ‘InterfaceGroup’

fn interface_item(&mut self, _arg: &InterfaceItem) -> Result<()>

Semantic action for non-terminal ‘InterfaceItem’

fn generate_if_declaration( &mut self, _arg: &GenerateIfDeclaration, ) -> Result<()>

Semantic action for non-terminal ‘GenerateIfDeclaration’

fn generate_for_declaration( &mut self, _arg: &GenerateForDeclaration, ) -> Result<()>

Semantic action for non-terminal ‘GenerateForDeclaration’

fn generate_block_declaration( &mut self, _arg: &GenerateBlockDeclaration, ) -> Result<()>

Semantic action for non-terminal ‘GenerateBlockDeclaration’

fn generate_named_block(&mut self, _arg: &GenerateNamedBlock) -> Result<()>

Semantic action for non-terminal ‘GenerateNamedBlock’

fn generate_optional_named_block( &mut self, _arg: &GenerateOptionalNamedBlock, ) -> Result<()>

Semantic action for non-terminal ‘GenerateOptionalNamedBlock’

fn generate_group(&mut self, _arg: &GenerateGroup) -> Result<()>

Semantic action for non-terminal ‘GenerateGroup’

fn generate_item(&mut self, _arg: &GenerateItem) -> Result<()>

Semantic action for non-terminal ‘GenerateItem’

fn package_declaration(&mut self, _arg: &PackageDeclaration) -> Result<()>

Semantic action for non-terminal ‘PackageDeclaration’

fn package_group(&mut self, _arg: &PackageGroup) -> Result<()>

Semantic action for non-terminal ‘PackageGroup’

fn package_item(&mut self, _arg: &PackageItem) -> Result<()>

Semantic action for non-terminal ‘PackageItem’

fn proto_module_declaration( &mut self, _arg: &ProtoModuleDeclaration, ) -> Result<()>

Semantic action for non-terminal ‘ProtoModuleDeclaration’

fn embed_declaration(&mut self, _arg: &EmbedDeclaration) -> Result<()>

Semantic action for non-terminal ‘EmbedDeclaration’

fn embed_content(&mut self, _arg: &EmbedContent) -> Result<()>

Semantic action for non-terminal ‘EmbedContent’

fn embed_content_token(&mut self, _arg: &EmbedContentToken) -> Result<()>

Semantic action for non-terminal ‘EmbedContentToken’

fn embed_item(&mut self, _arg: &EmbedItem) -> Result<()>

Semantic action for non-terminal ‘EmbedItem’

fn include_declaration(&mut self, _arg: &IncludeDeclaration) -> Result<()>

Semantic action for non-terminal ‘IncludeDeclaration’

fn description_group(&mut self, _arg: &DescriptionGroup) -> Result<()>

Semantic action for non-terminal ‘DescriptionGroup’

fn description_item(&mut self, _arg: &DescriptionItem) -> Result<()>

Semantic action for non-terminal ‘DescriptionItem’

fn veryl(&mut self, _arg: &Veryl) -> Result<()>

Semantic action for non-terminal ‘Veryl’

fn on_comment_parsed(&mut self, _token: Token<'_>)

This method provides skipped language comments. If you need comments please provide your own implementation of this method.

Implementors

impl VerylGrammarTrait for VerylGrammar