Module: RedParse::ReduceWithsFor_RedParse_RedParse__MacroMixin_RedParse__WithMacros_1_9

Extended by:
ReduceWithUtils
Defined in:
lib/macro/ReduceWithsFor_RedParse_RedParse__MacroMixin_RedParse__WithMacros_1_9.rb

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.redparse_modules_init(parser) ⇒ Object 



35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
 
# 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

Instance Method Details

#redparse_modules_init ⇒ Object 



448
449
450
451
 
# 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