module RedParse::ReduceWithsFor_RedParse_RedParse__MacroMixin_RedParse__WithMacros_1_9

Public Class Methods

redparse_modules_init(parser) click to toggle source
# File lib/macro/ReduceWithsFor_RedParse_RedParse__MacroMixin_RedParse__WithMacros_1_9.rb, line 35
        def self.redparse_modules_init(parser)
          return if defined? @@ref_0
          rules=parser.rules.map{|rule|
            rule.left.subregs.map{|pat|
              case pat
              when String,Regexp #not needed anymore...?
                RedParse::KW(pat)
              when Reg::LookBack,Reg::LookAhead,Reg::Repeat #Reg::Repeat should be handled already by now
                pat.subregs[0]
              #subseqs handled already
              else pat
              end
            }<<rule.right
          }
@@ref_0=rules[68][0]
warn_unless_equal 0,mui(@@ref_0),'-{, :lvalue=>true, , , }'
@@ref_1=rules[68][1]
warn_unless_equal 1,mui(@@ref_1),'~(RubyLexer::OperatorToken | RubyLexer::KeywordToken & -{, :ident=>"=", , , } | RubyLexer::OperatorToken | RubyLexer::KeywordToken & -{, :ident=>/^(([^=])\\2|[^<>=!])=$/, , , } | RubyLexer::OperatorToken | RubyLexer::KeywordToken & -{, :ident=>"lhs,", , , })'
@@ref_2=rules[68][2]
warn_unless_equal 2,mui(@@ref_2),'#<RedParse::StackMonkey: @and_expect_node=-{, :lvalue=>nil, , , } @first_changed_index=-2 @monkey_code=#<Proc:@/home/caleb/lab/ocelot.w/redparse/lib/redparse.rb:1724> @name="lval2rval">'
@@ref_3=rules[67][0]
warn_unless_equal 3,mui(@@ref_3),'RubyLexer::OperatorToken | RubyLexer::KeywordToken & -{, :ident=>/,$/, , , }'
@@ref_4=rules[67][1]
warn_unless_equal 4,mui(@@ref_4),'RubyLexer::KeywordToken & -{, :ident=>/^([}\\]])$/, , , }'
@@ref_5=rules[67][2]
warn_unless_equal 5,mui(@@ref_5),'#<RedParse::DeleteMonkey: @and_expect_node=nil @first_changed_index=-2 @index=-2 @monkey_code=#<Proc:@/home/caleb/lab/ocelot.w/redparse/lib/redparse.rb:125> @name="comma_cleanup">'
@@ref_6=rules[21][2]
warn_unless_equal 6,mui(@@ref_6),'RubyLexer::OperatorToken | RubyLexer::KeywordToken & -{, :ident=>"=", , , }'
@@ref_7=rules[21][1]
warn_unless_equal 7,mui(@@ref_7),'RedParse::UnaryStarNode | RedParse::ParenedNode & ~(-{, :after_comma=>true, , , })'
@@ref_8=rules[21][0]
warn_unless_equal 8,mui(@@ref_8),'RubyLexer::OperatorToken | RubyLexer::KeywordToken & -{, :ident=>"lhs,", , , }'
@@ref_9=rules[21][3]
warn_unless_equal 9,mui(@@ref_9),'#<RedParse::StackMonkey: @and_expect_node=RedParse::UnaryStarNode | RedParse::ParenedNode & -{, :after_comma=>true, , , } @first_changed_index=-3 @monkey_code=#<Proc:@/home/caleb/lab/ocelot.w/redparse/lib/redparse.rb:1596> @name="after_comma">'
@@ref_10=rules[11][0]
warn_unless_equal 10,mui(@@ref_10),'RubyLexer::OperatorToken | RubyLexer::KeywordToken & -{, :ident=>/,$/, , , }'
@@ref_11=rules[11][1]
warn_unless_equal 11,mui(@@ref_11),'RedParse::GoalPostToken | RubyLexer::KeywordToken & -{, :ident=>/^(in|[=)|;])$/, , , }'
@@ref_12=rules[11][2]
warn_unless_equal 12,mui(@@ref_12),'#<RedParse::StackMonkey: @and_expect_node=RedParse::DanglingCommaNode @first_changed_index=-1 @monkey_code=#<Proc:@/home/caleb/lab/ocelot.w/redparse/lib/redparse.rb:1551> @name="DanglingComma">'
@@ref_13=rules[10][0]
warn_unless_equal 13,mui(@@ref_13),'RubyLexer::OperatorToken & -{, :ident=>/^(?:unary|lhs)\\*$/, , , }'
@@ref_14=rules[10][1]
warn_unless_equal 14,mui(@@ref_14),'RedParse::GoalPostToken | RubyLexer::OperatorToken | RubyLexer::KeywordToken & -{, :ident=>/,$/, , , } | RubyLexer::KeywordToken & -{, :ident=>/^(in|[=)|;])$/, , , }'
@@ref_15=rules[71][0]
warn_unless_equal 15,mui(@@ref_15),'RubyLexer::NumberToken & -{, :negative=>true, , , }'
@@ref_16=rules[71][1]
warn_unless_equal 16,mui(@@ref_16),'RubyLexer::OperatorToken & -{, :ident=>"**", , , }'
@@ref_17=rules[71][2]
warn_unless_equal 17,mui(@@ref_17),'#<RedParse::StackMonkey: @and_expect_node=RubyLexer::OperatorToken | RubyLexer::KeywordToken & -{, :ident=>"-@", , , } @first_changed_index=-2 @monkey_code=#<Proc:@/home/caleb/lab/ocelot.w/redparse/lib/redparse.rb:1750> @name="fix_neg_exp">'
@@ref_18=rules[70][0]
warn_unless_equal 18,mui(@@ref_18),'RubyLexer::NumberToken | RubyLexer::SymbolToken'
@@ref_19=rules[47][2]
warn_unless_equal 19,mui(@@ref_19),'RubyLexer::MethNameToken | RedParse::LiteralNode & -{, :bare_method=>true, , , }'
@@ref_20=rules[47][1]
warn_unless_equal 20,mui(@@ref_20),'RubyLexer::OperatorToken | RubyLexer::KeywordToken & -{, :ident=>",", , , }'
@@ref_21=rules[46][0]
warn_unless_equal 21,mui(@@ref_21),'RubyLexer::KeywordToken & -{, :ident=>"undef", , , }'
@@ref_22=rules[45][2]
warn_unless_equal 22,mui(@@ref_22),'RubyLexer::MethNameToken | RedParse::LiteralNode & -{, :bare_method=>true, , , } | RedParse::VarNode'
@@ref_23=rules[45][1]
warn_unless_equal 23,mui(@@ref_23),'RubyLexer::MethNameToken | RedParse::LiteralNode & -{, :bare_method=>true, , , } | RedParse::VarNode'
@@ref_24=rules[45][0]
warn_unless_equal 24,mui(@@ref_24),'RubyLexer::KeywordToken & -{, :ident=>"alias", , , }'
@@ref_25=rules[58][0]
warn_unless_equal 25,mui(@@ref_25),'RubyLexer::OperatorToken | RubyLexer::KeywordToken & -{, :ident=>/^(not | defined\\? | rescue3 | .*[@,] | [~!;\\(\\[\\{?:] | \\.{1,3} | :: | => | ![=~])$/x, , , } | RubyLexer::KeywordToken & -{, :ident=>/^( \\*\\*? | << | >> | &&? | \\|\\|? | \\^ | % | \\/ | - | \\+ )?=$/x, , , } | RubyLexer::KeywordToken & -{, :ident=>/^(?:def|class|module|begin|for|case|do|if|unless|while|until)$/, , , } | RubyLexer::KeywordToken & -{, :ident=>/^(?:else|elsif|ensure|in|then|rescue|when)$/, , , } | RedParse::RescueHeaderNode | RedParse::StartToken | RedParse::GoalPostToken | RedParse::BlockFormalsNode | RubyLexer::AssignmentRhsListStartToken & ~(RubyLexer::StringToken | RedParse::HereDocNode)'
@@ref_26=rules[58][2]
warn_unless_equal 26,mui(@@ref_26),'~(RubyLexer::StringToken)'
@@ref_27=rules[57][0]
warn_unless_equal 27,mui(@@ref_27),'RubyLexer::OperatorToken | RubyLexer::KeywordToken & -{, :ident=>/^(not | defined\\? | rescue3 | .*[@,] | [~!;\\(\\[\\{?:] | \\.{1,3} | :: | => | ![=~])$/x, , , } | RubyLexer::KeywordToken & -{, :ident=>/^( \\*\\*? | << | >> | &&? | \\|\\|? | \\^ | % | \\/ | - | \\+ )?=$/x, , , } | RubyLexer::KeywordToken & -{, :ident=>/^(?:def|class|module|begin|for|case|do|if|unless|while|until)$/, , , } | RubyLexer::KeywordToken & -{, :ident=>/^(?:else|elsif|ensure|in|then|rescue|when)$/, , , } | RedParse::RescueHeaderNode | RedParse::StartToken | RedParse::GoalPostToken | RedParse::BlockFormalsNode | RubyLexer::AssignmentRhsListStartToken & ~(RubyLexer::StringToken | RedParse::HereDocNode)'
@@ref_28=rules[57][2]
warn_unless_equal 28,mui(@@ref_28),'~(RubyLexer::StringToken)'
@@ref_29=rules[56][2]
warn_unless_equal 29,mui(@@ref_29),'~(RubyLexer::StringToken)'
@@ref_30=rules[16][1]
warn_unless_equal 30,mui(@@ref_30),'RedParse::ValueNode & -{, :lvalue=>nil, , , }'
@@ref_31=rules[15][1]
warn_unless_equal 31,mui(@@ref_31),'RubyLexer::OperatorToken | RubyLexer::KeywordToken & -{, :ident=>"=", , , }'
@@ref_32=rules[15][0]
warn_unless_equal 32,mui(@@ref_32),'RedParse::VarNode | RedParse::CallSiteNode | RedParse::BracketsGetNode | RedParse::CommaOpNode | RedParse::ParenedNode | RedParse::ConstantNode | RedParse::UnaryStarNode & -{, :lvalue=>true, , , }'
@@ref_33=rules[15][3]
warn_unless_equal 33,mui(@@ref_33),'lower_op'
@@ref_34=rules[52][2]
warn_unless_equal 34,mui(@@ref_34),'RubyLexer::KeywordToken & -{, :ident=>";", , , }'
@@ref_35=rules[52][3]
warn_unless_equal 35,mui(@@ref_35),'RubyLexer::KeywordToken & -{, :ident=>/^(else|ensure|end)$/, , , } | RubyLexer::KeywordToken & -{, :ident=>"rescue", , , } & -{, :infix=>nil, , , }'
@@ref_36=rules[64][2]
warn_unless_equal 36,mui(@@ref_36),'RubyLexer::KeywordToken & -{, :ident=>";", , , }'
@@ref_37=rules[64][0]
warn_unless_equal 37,mui(@@ref_37),'~(RubyLexer::OperatorToken & -{, :ident=>/^(<<|=>|\\.|::)$/, , , } | RubyLexer::KeywordToken & -{, :ident=>/^(while|until|if|unless|def|case|when|in|rescue|elsif|class|module|<<|=>|\\.|::)$/, , , } | RubyLexer::KeywordToken & -{, :ident=>"macro", , , })'
@@ref_38=rules[64][4]
warn_unless_equal 38,mui(@@ref_38),'#<RedParse::DeleteMonkey: @and_expect_node=nil @first_changed_index=-3 @index=-3 @monkey_code=#<Proc:@/home/caleb/lab/ocelot.w/redparse/lib/redparse.rb:125> @name="semi_cleanup_before_rescue">'
@@ref_39=rules[83][7]
warn_unless_equal 39,mui(@@ref_39),'RubyLexer::KeywordToken & -{, :ident=>"end", , , }'
@@ref_40=rules[83][2]
warn_unless_equal 40,mui(@@ref_40),'RubyLexer::KeywordToken & -{, :ident=>";", , , }'
@@ref_41=rules[83][0]
warn_unless_equal 41,mui(@@ref_41),'RubyLexer::KeywordToken & -{, :ident=>"macro", , , }'
@@ref_42=rules[61][6]
warn_unless_equal 42,mui(@@ref_42),'RubyLexer::KeywordToken & -{, :ident=>"end", , , }'
@@ref_43=rules[61][4]
warn_unless_equal 43,mui(@@ref_43),'RubyLexer::KeywordToken & -{, :ident=>/^([:;]|do)$/, , , }'
@@ref_44=rules[61][2]
warn_unless_equal 44,mui(@@ref_44),'RubyLexer::KeywordToken & -{, :ident=>"in", , , }'
@@ref_45=rules[61][0]
warn_unless_equal 45,mui(@@ref_45),'RubyLexer::KeywordToken & -{, :ident=>"for", , , }'
@@ref_46=rules[59][5]
warn_unless_equal 46,mui(@@ref_46),'RubyLexer::KeywordToken & -{, :ident=>"end", , , }'
@@ref_47=rules[59][2]
warn_unless_equal 47,mui(@@ref_47),'RubyLexer::KeywordToken & -{, :ident=>";", , , }'
@@ref_48=rules[59][0]
warn_unless_equal 48,mui(@@ref_48),'RubyLexer::KeywordToken & -{, :ident=>"case", , , }'
@@ref_49=rules[49][5]
warn_unless_equal 49,mui(@@ref_49),'RubyLexer::KeywordToken & -{, :ident=>"end", , , }'
@@ref_50=rules[49][0]
warn_unless_equal 50,mui(@@ref_50),'RubyLexer::KeywordToken & -{, :ident=>"begin", , , }'
@@ref_51=rules[48][8]
warn_unless_equal 51,mui(@@ref_51),'RubyLexer::KeywordToken & -{, :ident=>"end", , , }'
@@ref_52=rules[48][3]
warn_unless_equal 52,mui(@@ref_52),'RubyLexer::KeywordToken & -{, :ident=>";", , , }'
@@ref_53=rules[48][2]
warn_unless_equal 53,mui(@@ref_53),'RubyLexer::OperatorToken & -{, :ident=>"=", , , }'
@@ref_54=rules[48][0]
warn_unless_equal 54,mui(@@ref_54),'RubyLexer::KeywordToken & -{, :ident=>"def", , , }'
@@ref_55=rules[44][8]
warn_unless_equal 55,mui(@@ref_55),'RubyLexer::KeywordToken & -{, :ident=>"end", , , }'
@@ref_56=rules[44][3]
warn_unless_equal 56,mui(@@ref_56),'RubyLexer::KeywordToken & -{, :ident=>";", , , }'
@@ref_57=rules[44][1]
warn_unless_equal 57,mui(@@ref_57),'RubyLexer::OperatorToken & -{, :ident=>"<<", , , }'
@@ref_58=rules[44][0]
warn_unless_equal 58,mui(@@ref_58),'RubyLexer::KeywordToken & -{, :ident=>"class", , , }'
@@ref_59=rules[42][7]
warn_unless_equal 59,mui(@@ref_59),'RubyLexer::KeywordToken & -{, :ident=>"end", , , }'
@@ref_60=rules[42][2]
warn_unless_equal 60,mui(@@ref_60),'RubyLexer::KeywordToken & -{, :ident=>";", , , }'
@@ref_61=rules[42][0]
warn_unless_equal 61,mui(@@ref_61),'RubyLexer::KeywordToken & -{, :ident=>"class", , , }'
@@ref_62=rules[41][7]
warn_unless_equal 62,mui(@@ref_62),'RubyLexer::KeywordToken & -{, :ident=>"end", , , }'
@@ref_63=rules[41][2]
warn_unless_equal 63,mui(@@ref_63),'RubyLexer::KeywordToken & -{, :ident=>";", , , }'
@@ref_64=rules[41][1]
warn_unless_equal 64,mui(@@ref_64),'RedParse::ConstantNode | RedParse::VarNode'
@@ref_65=rules[41][0]
warn_unless_equal 65,mui(@@ref_65),'RubyLexer::KeywordToken & -{, :ident=>"module", , , }'
@@ref_66=rules[38][6]
warn_unless_equal 66,mui(@@ref_66),'RubyLexer::KeywordToken & -{, :ident=>"end", , , }'
@@ref_67=rules[38][2]
warn_unless_equal 67,mui(@@ref_67),'RubyLexer::KeywordToken & -{, :ident=>/^(;|then|:)$/, , , }'
@@ref_68=rules[38][0]
warn_unless_equal 68,mui(@@ref_68),'RubyLexer::KeywordToken & -{, :ident=>/^(if|unless)$/, , , }'
@@ref_69=rules[37][4]
warn_unless_equal 69,mui(@@ref_69),'RubyLexer::KeywordToken & -{, :ident=>"end", , , }'
@@ref_70=rules[37][2]
warn_unless_equal 70,mui(@@ref_70),'RubyLexer::KeywordToken & -{, :ident=>/^([:;]|do)$/, , , }'
@@ref_71=rules[37][0]
warn_unless_equal 71,mui(@@ref_71),'RubyLexer::KeywordToken & -{, :ident=>/^(while|until)$/, , , }'
@@ref_72=rules[35][4]
warn_unless_equal 72,mui(@@ref_72),'RubyLexer::KeywordToken & -{, :ident=>"end", , , }'
@@ref_73=rules[35][1]
warn_unless_equal 73,mui(@@ref_73),'RubyLexer::KeywordToken & -{, :ident=>"do", , , }'
@@ref_74=rules[35][0]
warn_unless_equal 74,mui(@@ref_74),'RubyLexer::KeywordToken & -{, :ident=>")", , , }'
@@ref_75=rules[6][2]
warn_unless_equal 75,mui(@@ref_75),'RubyLexer::KeywordToken & -{, :ident=>"end", , , }'
@@ref_76=rules[6][1]
warn_unless_equal 76,mui(@@ref_76),'~(RubyLexer::KeywordToken & -{, :ident=>/^(?:def|class|module|begin|for|case|do|if|unless|while|until)$/, , , } | RubyLexer::KeywordToken & -{, :ident=>"end", , , })'
@@ref_77=rules[6][0]
warn_unless_equal 77,mui(@@ref_77),'RubyLexer::KeywordToken & -{, :ident=>/^(?:def|class|module|begin|for|case|do|if|unless|while|until)$/, , , }'
@@ref_78=rules[6][3]
warn_unless_equal 78,mui(@@ref_78),'~(RubyLexer::KeywordToken & -{, :ident=>/^(do|\\{)$/, , , })'
@@ref_79=rules[0][2]
warn_unless_equal 79,mui(@@ref_79),'RubyLexer::KeywordToken & -{, :ident=>"end", , , }'
@@ref_80=rules[0][1]
warn_unless_equal 80,mui(@@ref_80),'~(RubyLexer::KeywordToken & -{, :ident=>/(?-mix:^((?-mix:^(?:def|class|module|begin|for|case|do|if|unless|while|until)$)|end|\\)|\\]|\\})$)|^macro$/, , , })'
@@ref_81=rules[0][0]
warn_unless_equal 81,mui(@@ref_81),'RubyLexer::KeywordToken & -{, :ident=>"macro", , , }'
@@ref_82=rules[0][3]
warn_unless_equal 82,mui(@@ref_82),'~(RubyLexer::KeywordToken & -{, :ident=>/^(do|\\{)$/, , , })'
@@ref_83=rules[72][0]
warn_unless_equal 83,mui(@@ref_83),'RubyLexer::KeywordToken & -{, :ident=>/(?:(?-mix:(?-mix:^(?:__FILE__|__LINE__|false|nil|self|true)$)|^(?:__ENCODING__)$)|^(?:__ENCODING__)$)/, , , }'
@@ref_84=rules[39][0]
warn_unless_equal 84,mui(@@ref_84),'RubyLexer::KeywordToken & -{, :ident=>"else", , , }'
@@ref_85=rules[39][2]
warn_unless_equal 85,mui(@@ref_85),'RubyLexer::KeywordToken & -{, :ident=>/^(ensure|end)$/, , , }'
@@ref_86=rules[53][0]
warn_unless_equal 86,mui(@@ref_86),'RubyLexer::KeywordToken & -{, :ident=>"ensure", , , }'
@@ref_87=rules[53][2]
warn_unless_equal 87,mui(@@ref_87),'RubyLexer::KeywordToken & -{, :ident=>"end", , , }'
@@ref_88=rules[60][2]
warn_unless_equal 88,mui(@@ref_88),'RubyLexer::KeywordToken & -{, :ident=>/^([:;]|then)$/, , , }'
@@ref_89=rules[60][0]
warn_unless_equal 89,mui(@@ref_89),'RubyLexer::KeywordToken & -{, :ident=>"when", , , }'
@@ref_90=rules[60][4]
warn_unless_equal 90,mui(@@ref_90),'RubyLexer::KeywordToken & -{, :ident=>/^(when|else|end)$/, , , }'
@@ref_91=rules[51][4]
warn_unless_equal 91,mui(@@ref_91),'RubyLexer::KeywordToken & -{, :ident=>/^([:;]|then)$/, , , }'
@@ref_92=rules[51][2]
warn_unless_equal 92,mui(@@ref_92),'RubyLexer::KeywordToken & -{, :ident=>"=>", , , }'
@@ref_93=rules[51][1]
warn_unless_equal 93,mui(@@ref_93),'RubyLexer::KeywordToken & -{, :ident=>"rescue", , , } & -{, :infix=>nil, , , }'
@@ref_94=rules[51][0]
warn_unless_equal 94,mui(@@ref_94),'RubyLexer::KeywordToken & -{, :ident=>/^(;|begin)$/, , , } | RedParse::RescueNode'
@@ref_95=rules[40][2]
warn_unless_equal 95,mui(@@ref_95),'RubyLexer::KeywordToken & -{, :ident=>/^(;|then|:)$/, , , }'
@@ref_96=rules[40][0]
warn_unless_equal 96,mui(@@ref_96),'RubyLexer::KeywordToken & -{, :ident=>"elsif", , , }'
@@ref_97=rules[40][4]
warn_unless_equal 97,mui(@@ref_97),'RubyLexer::KeywordToken & -{, :ident=>/^(end|else|elsif)$/, , , }'
@@ref_98=rules[84][6]
warn_unless_equal 98,mui(@@ref_98),'RubyLexer::KeywordToken & -{, :ident=>")", , , }'
@@ref_99=rules[84][4]
warn_unless_equal 99,mui(@@ref_99),'RubyLexer::KeywordToken & -{, :ident=>"(", , , }'
@@ref_100=rules[84][3]
warn_unless_equal 100,mui(@@ref_100),'RubyLexer::KeywordToken & -{, :ident=>"<doubled-parens>", , , }'
@@ref_101=rules[84][2]
warn_unless_equal 101,mui(@@ref_101),'RubyLexer::KeywordToken & -{, :ident=>")", , , }'
@@ref_102=rules[84][0]
warn_unless_equal 102,mui(@@ref_102),'RubyLexer::KeywordToken & -{, :ident=>"(", , , }'
@@ref_103=rules[84][8]
warn_unless_equal 103,mui(@@ref_103),'~(RubyLexer::KeywordToken & -{, :ident=>"do", , , })'
@@ref_104=rules[78][5]
warn_unless_equal 104,mui(@@ref_104),'RubyLexer::KeywordToken & -{, :ident=>")", , , }'
@@ref_105=rules[78][3]
warn_unless_equal 105,mui(@@ref_105),'RubyLexer::KeywordToken & -{, :ident=>"(", , , }'
@@ref_106=rules[78][2]
warn_unless_equal 106,mui(@@ref_106),'RubyLexer::KeywordToken & -{, :ident=>/^;$|^<doubled-parens>$/, , , }'
@@ref_107=rules[78][0]
warn_unless_equal 107,mui(@@ref_107),'RubyLexer::OperatorToken & -{, :ident=>"v", , , }'
@@ref_108=rules[75][3]
warn_unless_equal 108,mui(@@ref_108),'RubyLexer::KeywordToken & -{, :ident=>")", , , }'
@@ref_109=rules[75][1]
warn_unless_equal 109,mui(@@ref_109),'RubyLexer::KeywordToken & -{, :ident=>"(", , , }'
@@ref_110=rules[75][0]
warn_unless_equal 110,mui(@@ref_110),'RubyLexer::KeywordToken & -{, :ident=>".", , , } | RubyLexer::KeywordToken & -{, :ident=>"::", , , }'
@@ref_111=rules[75][5]
warn_unless_equal 111,mui(@@ref_111),'~(RubyLexer::KeywordToken & -{, :ident=>"do", , , })'
@@ref_112=rules[31][2]
warn_unless_equal 112,mui(@@ref_112),'RubyLexer::KeywordToken & -{, :ident=>")", , , } & ~(-{, :callsite?=>true, , , } | -{, :not_real?=>true, , , })'
@@ref_113=rules[31][1]
warn_unless_equal 113,mui(@@ref_113),'RubyLexer::KeywordToken & -{, :ident=>"(", , , }'
@@ref_114=rules[31][0]
warn_unless_equal 114,mui(@@ref_114),'~(RubyLexer::MethNameToken | RubyLexer::KeywordToken & -{, :ident=>/(?-mix:(?-mix:(?-mix:^(?:break|next|redo|return|yield|retry|super|BEGIN|END)$)|^(?:not)$)|^(?:not)$)|^->$/, , , })'
@@ref_115=rules[31][3]
warn_unless_equal 115,mui(@@ref_115),'~(RubyLexer::KeywordToken & -{, :ident=>"do", , , })'
@@ref_116=rules[30][3]
warn_unless_equal 116,mui(@@ref_116),'RubyLexer::KeywordToken & -{, :ident=>")", , , } & ~(-{, :callsite?=>true, , , } | -{, :not_real?=>true, , , })'
@@ref_117=rules[30][1]
warn_unless_equal 117,mui(@@ref_117),'RubyLexer::KeywordToken & -{, :ident=>"(", , , }'
@@ref_118=rules[30][0]
warn_unless_equal 118,mui(@@ref_118),'~(RubyLexer::MethNameToken | RubyLexer::KeywordToken & -{, :ident=>/(?-mix:(?-mix:(?-mix:^(?:break|next|redo|return|yield|retry|super|BEGIN|END)$)|^(?:not)$)|^(?:not)$)|^->$/, , , })'
@@ref_119=rules[30][4]
warn_unless_equal 119,mui(@@ref_119),'~(RubyLexer::KeywordToken & -{, :ident=>"do", , , })'
@@ref_120=rules[29][3]
warn_unless_equal 120,mui(@@ref_120),'RubyLexer::KeywordToken & -{, :ident=>")", , , }'
@@ref_121=rules[29][1]
warn_unless_equal 121,mui(@@ref_121),'RubyLexer::KeywordToken & -{, :ident=>"(", , , }'
@@ref_122=rules[29][0]
warn_unless_equal 122,mui(@@ref_122),'RubyLexer::KeywordToken & -{, :ident=>/(?-mix:(?-mix:(?-mix:^(?:break|next|redo|return|yield|retry|super|BEGIN|END)$)|^(?:not)$)|^(?:not)$)|^->$/, , , }'
@@ref_123=rules[29][5]
warn_unless_equal 123,mui(@@ref_123),'~(RubyLexer::KeywordToken & -{, :ident=>"do", , , })'
@@ref_124=rules[28][3]
warn_unless_equal 124,mui(@@ref_124),'RubyLexer::KeywordToken & -{, :ident=>")", , , }'
@@ref_125=rules[28][1]
warn_unless_equal 125,mui(@@ref_125),'RubyLexer::KeywordToken & -{, :ident=>"(", , , }'
@@ref_126=rules[28][5]
warn_unless_equal 126,mui(@@ref_126),'~(RubyLexer::KeywordToken & -{, :ident=>"do", , , })'
@@ref_127=rules[4][2]
warn_unless_equal 127,mui(@@ref_127),'RubyLexer::KeywordToken & -{, :ident=>")", , , }'
@@ref_128=rules[4][1]
warn_unless_equal 128,mui(@@ref_128),'~(RubyLexer::KeywordToken & -{, :ident=>"(", , , } | RubyLexer::KeywordToken & -{, :ident=>")", , , })'
@@ref_129=rules[4][0]
warn_unless_equal 129,mui(@@ref_129),'RubyLexer::KeywordToken & -{, :ident=>"(", , , }'
@@ref_130=rules[4][3]
warn_unless_equal 130,mui(@@ref_130),'~(RubyLexer::KeywordToken & -{, :ident=>/^(do|\\{)$/, , , })'
@@ref_131=rules[55][3]
warn_unless_equal 131,mui(@@ref_131),'RubyLexer::KeywordToken & -{, :ident=>"]", , , }'
@@ref_132=rules[55][1]
warn_unless_equal 132,mui(@@ref_132),'RubyLexer::KeywordToken & -{, :ident=>"[", , , }'
@@ref_133=rules[54][2]
warn_unless_equal 133,mui(@@ref_133),'RubyLexer::KeywordToken & -{, :ident=>"]", , , }'
@@ref_134=rules[54][0]
warn_unless_equal 134,mui(@@ref_134),'RubyLexer::KeywordToken & -{, :ident=>"[", , , }'
@@ref_135=rules[5][2]
warn_unless_equal 135,mui(@@ref_135),'RubyLexer::KeywordToken & -{, :ident=>"]", , , }'
@@ref_136=rules[5][1]
warn_unless_equal 136,mui(@@ref_136),'~(RubyLexer::KeywordToken & -{, :ident=>"[", , , } | RubyLexer::KeywordToken & -{, :ident=>"]", , , })'
@@ref_137=rules[5][0]
warn_unless_equal 137,mui(@@ref_137),'RubyLexer::KeywordToken & -{, :ident=>"[", , , }'
@@ref_138=rules[5][3]
warn_unless_equal 138,mui(@@ref_138),'~(RubyLexer::KeywordToken & -{, :ident=>/^(do|\\{)$/, , , })'
@@ref_139=rules[34][2]
warn_unless_equal 139,mui(@@ref_139),'RubyLexer::KeywordToken & -{, :ident=>"}", , , }'
@@ref_140=rules[34][1]
warn_unless_equal 140,mui(@@ref_140),'RedParse::CommaOpNode | RedParse::ArrowOpNode'
@@ref_141=rules[34][0]
warn_unless_equal 141,mui(@@ref_141),'RubyLexer::KeywordToken & -{, :ident=>"{", , , }'
@@ref_142=rules[3][2]
warn_unless_equal 142,mui(@@ref_142),'RubyLexer::KeywordToken & -{, :ident=>"}", , , }'
@@ref_143=rules[3][1]
warn_unless_equal 143,mui(@@ref_143),'~(RubyLexer::KeywordToken & -{, :ident=>"{", , , } | RubyLexer::KeywordToken & -{, :ident=>"}", , , })'
@@ref_144=rules[3][0]
warn_unless_equal 144,mui(@@ref_144),'RubyLexer::KeywordToken & -{, :ident=>"{", , , }'
@@ref_145=rules[3][3]
warn_unless_equal 145,mui(@@ref_145),'~(RubyLexer::KeywordToken & -{, :ident=>/^(do|\\{)$/, , , })'
@@ref_146=rules[79][2]
warn_unless_equal 146,mui(@@ref_146),'RubyLexer::KeywordToken & -{, :ident=>";", , , }'
@@ref_147=rules[79][0]
warn_unless_equal 147,mui(@@ref_147),'RubyLexer::OperatorToken & -{, :ident=>"v", , , }'
@@ref_148=rules[79][3]
warn_unless_equal 148,mui(@@ref_148),'~(RubyLexer::KeywordToken & -{, :ident=>"(", , , })'
@@ref_149=rules[66][1]
warn_unless_equal 149,mui(@@ref_149),'RubyLexer::KeywordToken & -{, :ident=>";", , , }'
@@ref_150=rules[66][0]
warn_unless_equal 150,mui(@@ref_150),'RedParse::StartToken | RedParse::RescueHeaderNode'
@@ref_151=rules[66][2]
warn_unless_equal 151,mui(@@ref_151),'#<RedParse::DeleteMonkey: @and_expect_node=nil @first_changed_index=-2 @index=-2 @monkey_code=#<Proc:@/home/caleb/lab/ocelot.w/redparse/lib/redparse.rb:125> @name="semi_cleanup_after_rescue">'
@@ref_152=rules[65][1]
warn_unless_equal 152,mui(@@ref_152),'RubyLexer::KeywordToken & -{, :ident=>";", , , }'
@@ref_153=rules[65][0]
warn_unless_equal 153,mui(@@ref_153),'RubyLexer::KeywordToken & -{, :ident=>/^(begin|[;:({|]|then|do|else|ensure)$/, , , } | RedParse::BlockFormalsNode'
@@ref_154=rules[65][2]
warn_unless_equal 154,mui(@@ref_154),'#<RedParse::DeleteMonkey: @and_expect_node=nil @first_changed_index=-2 @index=-2 @monkey_code=#<Proc:@/home/caleb/lab/ocelot.w/redparse/lib/redparse.rb:125> @name="semi_cleanup_after_oplike">'
@@ref_155=rules[63][1]
warn_unless_equal 155,mui(@@ref_155),'RubyLexer::KeywordToken & -{, :ident=>";", , , }'
@@ref_156=rules[63][2]
warn_unless_equal 156,mui(@@ref_156),'RubyLexer::KeywordToken & -{, :ident=>"then", , , }'
@@ref_157=rules[63][3]
warn_unless_equal 157,mui(@@ref_157),'#<RedParse::DeleteMonkey: @and_expect_node=nil @first_changed_index=-2 @index=-2 @monkey_code=#<Proc:@/home/caleb/lab/ocelot.w/redparse/lib/redparse.rb:125> @name="semi_cleanup_before_then">'
@@ref_158=rules[62][2]
warn_unless_equal 158,mui(@@ref_158),'RubyLexer::KeywordToken & -{, :ident=>";", , , }'
@@ref_159=rules[62][0]
warn_unless_equal 159,mui(@@ref_159),'RubyLexer::OperatorToken | RubyLexer::KeywordToken & -{, :ident=>/^(not | defined\\? | rescue3 | .*[@,] | [~!;\\(\\[\\{?:] | \\.{1,3} | :: | => | ![=~])$/x, , , } | RubyLexer::KeywordToken & -{, :ident=>/^( \\*\\*? | << | >> | &&? | \\|\\|? | \\^ | % | \\/ | - | \\+ )?=$/x, , , } | RubyLexer::KeywordToken & -{, :ident=>/^(?:def|class|module|begin|for|case|do|if|unless|while|until)$/, , , } | RubyLexer::KeywordToken & -{, :ident=>/^(?:else|elsif|ensure|in|then|rescue|when)$/, , , } | RedParse::RescueHeaderNode | RedParse::StartToken | RedParse::GoalPostToken | RedParse::BlockFormalsNode | RubyLexer::AssignmentRhsListStartToken & ~(RubyLexer::OperatorToken & -{, :ident=>/^(<<|=>|\\.|::)$/, , , } | RubyLexer::KeywordToken & -{, :ident=>/^(while|until|if|unless|def|case|when|in|rescue|elsif|class|module|<<|=>|\\.|::)$/, , , } | RubyLexer::KeywordToken & -{, :ident=>"macro", , , })'
@@ref_160=rules[62][3]
warn_unless_equal 160,mui(@@ref_160),'RubyLexer::KeywordToken & -{, :ident=>/^(?:else|elsif|ensure|in|when|end|[)}\\]])$/, , , } | RubyLexer::EoiToken'
@@ref_161=rules[62][4]
warn_unless_equal 161,mui(@@ref_161),'#<RedParse::DeleteMonkey: @and_expect_node=nil @first_changed_index=-2 @index=-2 @monkey_code=#<Proc:@/home/caleb/lab/ocelot.w/redparse/lib/redparse.rb:125> @name="semi_cleanup_before_ISB">'
@@ref_162=rules[69][2]
warn_unless_equal 162,mui(@@ref_162),'RubyLexer::KeywordToken & -{, :ident=>".", , , } | RubyLexer::KeywordToken & -{, :ident=>"::", , , }'
@@ref_163=rules[69][0]
warn_unless_equal 163,mui(@@ref_163),'RubyLexer::OperatorToken | RubyLexer::KeywordToken & -{, :ident=>/^(not | defined\\? | rescue3 | .*[@,] | [~!;\\(\\[\\{?:] | \\.{1,3} | :: | => | ![=~])$/x, , , } | RubyLexer::KeywordToken & -{, :ident=>/^( \\*\\*? | << | >> | &&? | \\|\\|? | \\^ | % | \\/ | - | \\+ )?=$/x, , , } | RubyLexer::KeywordToken & -{, :ident=>/^(?:def|class|module|begin|for|case|do|if|unless|while|until)$/, , , } | RubyLexer::KeywordToken & -{, :ident=>/^(?:else|elsif|ensure|in|then|rescue|when)$/, , , } | RedParse::RescueHeaderNode | RedParse::StartToken | RedParse::GoalPostToken | RedParse::BlockFormalsNode | RubyLexer::AssignmentRhsListStartToken & ~(RubyLexer::KeywordToken & -{, :ident=>"def", , , })'
@@ref_164=rules[69][3]
warn_unless_equal 164,mui(@@ref_164),'RubyLexer::MethNameToken & -{, :has_equals=>true, , , }'
@@ref_165=rules[69][4]
warn_unless_equal 165,mui(@@ref_165),'#<RedParse::StackMonkey: @and_expect_node=RedParse::CallNode @first_changed_index=-1 @monkey_code=#<Proc:@/home/caleb/lab/ocelot.w/redparse/lib/redparse.rb:1732> @name="expand_equals">'
@@ref_166=rules[17][3]
warn_unless_equal 166,mui(@@ref_166),'RubyLexer::OperatorToken & -{, :ident=>"rescue3", , , }'
@@ref_167=rules[17][1]
warn_unless_equal 167,mui(@@ref_167),'RubyLexer::OperatorToken | RubyLexer::KeywordToken & -{, :ident=>"=", , , }'
@@ref_168=rules[7][0]
warn_unless_equal 168,mui(@@ref_168),'RubyLexer::OperatorToken | RubyLexer::KeywordToken & -{, :ident=>/^(?:[+-]@|unary[&*]|(?:lhs|rhs)[*])$/, , , } | RubyLexer::OperatorToken | RubyLexer::KeywordToken & -{, :ident=>/^([~!]|not|defined\\?)$/, , , }'
@@ref_169=rules[32][1]
warn_unless_equal 169,mui(@@ref_169),'RubyLexer::OperatorToken | RubyLexer::KeywordToken & -{, :ident=>/,$/, , , }'
@@ref_170=rules[33][2]
warn_unless_equal 170,mui(@@ref_170),'RubyLexer::KeywordToken & -{, :ident=>";", , , }'
@@ref_171=rules[33][0]
warn_unless_equal 171,mui(@@ref_171),'RubyLexer::OperatorToken | RubyLexer::KeywordToken & -{, :ident=>/^(not | defined\\? | rescue3 | .*[@,] | [~!;\\(\\[\\{?:] | \\.{1,3} | :: | => | ![=~])$/x, , , } | RubyLexer::KeywordToken & -{, :ident=>/^( \\*\\*? | << | >> | &&? | \\|\\|? | \\^ | % | \\/ | - | \\+ )?=$/x, , , } | RubyLexer::KeywordToken & -{, :ident=>/^(?:def|class|module|begin|for|case|do|if|unless|while|until)$/, , , } | RubyLexer::KeywordToken & -{, :ident=>/^(?:else|elsif|ensure|in|then|rescue|when)$/, , , } | RedParse::RescueHeaderNode | RedParse::StartToken | RedParse::GoalPostToken | RedParse::BlockFormalsNode | RubyLexer::AssignmentRhsListStartToken & ~(RubyLexer::OperatorToken & -{, :ident=>/^(<<|=>|\\.|::)$/, , , } | RubyLexer::KeywordToken & -{, :ident=>/^(while|until|if|unless|def|case|when|in|rescue|elsif|class|module|<<|=>|\\.|::)$/, , , } | RubyLexer::KeywordToken & -{, :ident=>"macro", , , })'
@@ref_172=rules[26][1]
warn_unless_equal 172,mui(@@ref_172),'RubyLexer::KeywordToken & -{, :ident=>"::", , , }'
@@ref_173=rules[27][3]
warn_unless_equal 173,mui(@@ref_173),'RubyLexer::KeywordToken & -{, :ident=>":", , , }'
@@ref_174=rules[27][1]
warn_unless_equal 174,mui(@@ref_174),'RubyLexer::KeywordToken & -{, :ident=>"?", , , }'
@@ref_175=rules[19][2]
warn_unless_equal 175,mui(@@ref_175),'RubyLexer::OperatorToken | RubyLexer::KeywordToken & -{, :ident=>"=", , , }'
@@ref_176=rules[19][0]
warn_unless_equal 176,mui(@@ref_176),'RubyLexer::OperatorToken | RubyLexer::KeywordToken & -{, :ident=>"rhs,", , , }'
@@ref_177=rules[18][2]
warn_unless_equal 177,mui(@@ref_177),'RubyLexer::OperatorToken | RubyLexer::KeywordToken & -{, :ident=>"=", , , }'
@@ref_178=rules[18][0]
warn_unless_equal 178,mui(@@ref_178),'~(RubyLexer::OperatorToken | RubyLexer::KeywordToken & -{, :ident=>"=", , , } | RedParse::ValueNode & -{, :lvalue=>nil, , , })'
@@ref_179=rules[13][1]
warn_unless_equal 179,mui(@@ref_179),'RubyLexer::KeywordToken & -{, :ident=>"=>", , , }'
@@ref_180=rules[20][3]
warn_unless_equal 180,mui(@@ref_180),'RubyLexer::OperatorToken | RubyLexer::KeywordToken & -{, :ident=>"=", , , }'
@@ref_181=rules[14][1]
warn_unless_equal 181,mui(@@ref_181),'RubyLexer::OperatorToken | RubyLexer::KeywordToken & -{, :ident=>/^(([^=])\\2|[^<>=!])=$/, , , }'
@@ref_182=rules[8][0]
warn_unless_equal 182,mui(@@ref_182),'RubyLexer::OperatorToken | RubyLexer::KeywordToken & -{, :ident=>"defined?", , , }'
@@ref_183=rules[50][1]
warn_unless_equal 183,mui(@@ref_183),'RedParse::BeginNode & -{, :after_equals=>nil, , , } & -{, :non_empty=>true, , , }'
@@ref_184=rules[50][0]
warn_unless_equal 184,mui(@@ref_184),'RubyLexer::OperatorToken | RubyLexer::KeywordToken & -{, :ident=>"=", , , }'
@@ref_185=rules[50][2]
warn_unless_equal 185,mui(@@ref_185),'RubyLexer::OperatorToken & -{, :ident=>"rescue", , , }'
@@ref_186=rules[50][3]
warn_unless_equal 186,mui(@@ref_186),'#<RedParse::StackMonkey: @and_expect_node=RedParse::BeginNode & -{, :after_equals=>true, , , } & -{, :non_empty=>true, , , } @first_changed_index=-2 @monkey_code=#<Proc:@/home/caleb/lab/ocelot.w/redparse/lib/redparse.rb:1677> @name="begin after equals">'
@@ref_187=rules[25][4]
warn_unless_equal 187,mui(@@ref_187),'#<RedParse::StackMonkey: @and_expect_node=RedParse::CallNode @first_changed_index=-4 @monkey_code=#<Proc:@/home/caleb/lab/ocelot.w/redparse/lib/redparse.rb:1448> @name="DotCall">'
@@ref_188=rules[24][1]
warn_unless_equal 188,mui(@@ref_188),'RubyLexer::KeywordToken & -{, :ident=>".", , , }'
@@ref_189=rules[43][2]
warn_unless_equal 189,mui(@@ref_189),'RubyLexer::OperatorToken & -{, :ident=>"<", , , }'
@@ref_190=rules[43][0]
warn_unless_equal 190,mui(@@ref_190),'RubyLexer::KeywordToken & -{, :ident=>"class", , , }'
@@ref_191=rules[43][4]
warn_unless_equal 191,mui(@@ref_191),'~(RubyLexer::KeywordToken & -{, :ident=>";", , , })'
@@ref_192=rules[9][0]
warn_unless_equal 192,mui(@@ref_192),'RubyLexer::OperatorToken & -{, :ident=>/^(?:unary|lhs|rhs)\\*$/, , , }'
@@ref_193=rules[81][0]
warn_unless_equal 193,mui(@@ref_193),'RubyLexer::OperatorToken & -{, :ident=>"^@", , , }'
@@ref_194=rules[80][0]
warn_unless_equal 194,mui(@@ref_194),'RubyLexer::OperatorToken & -{, :ident=>"v", , , }'
@@ref_195=rules[80][2]
warn_unless_equal 195,mui(@@ref_195),'RubyLexer::KeywordToken & -{, :ident=>";", , , } & -{, :not_real?=>false, , , }'
@@ref_196=rules[77][0]
warn_unless_equal 196,mui(@@ref_196),'RubyLexer::OperatorToken & -{, :ident=>"v", , , }'
@@ref_197=rules[82][1]
warn_unless_equal 197,mui(@@ref_197),'RedParse::ParenedNode & -{, :size=>0..1, , , } | RedParse::SequenceNode & -{, :size=>0, , , }'
@@ref_198=rules[82][0]
warn_unless_equal 198,mui(@@ref_198),'RubyLexer::OperatorToken & -{, :ident=>":@", , , }'
        end

Public Instance Methods

redparse_modules_init() click to toggle source
Calls superclass method
# File lib/macro/ReduceWithsFor_RedParse_RedParse__MacroMixin_RedParse__WithMacros_1_9.rb, line 448
def redparse_modules_init
  ::RedParse::ReduceWithsFor_RedParse_RedParse__MacroMixin_RedParse__WithMacros_1_9.redparse_modules_init(self) 
  super
end