parser 2.7.1.4 → 3.0.1.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (99) hide show
  1. checksums.yaml +4 -4
  2. data/lib/parser.rb +1 -1
  3. data/lib/parser/all.rb +2 -1
  4. data/lib/parser/ast/processor.rb +3 -7
  5. data/lib/parser/base.rb +7 -5
  6. data/lib/parser/builders/default.rb +178 -29
  7. data/lib/parser/context.rb +4 -0
  8. data/lib/parser/current.rb +20 -11
  9. data/lib/parser/current_arg_stack.rb +5 -2
  10. data/lib/parser/lexer.rb +23780 -0
  11. data/lib/parser/macruby.rb +6149 -0
  12. data/lib/parser/max_numparam_stack.rb +13 -5
  13. data/lib/parser/messages.rb +3 -0
  14. data/lib/parser/meta.rb +7 -6
  15. data/lib/parser/ruby18.rb +5667 -0
  16. data/lib/parser/ruby19.rb +6092 -0
  17. data/lib/parser/ruby20.rb +6527 -0
  18. data/lib/parser/ruby21.rb +6578 -0
  19. data/lib/parser/ruby22.rb +6613 -0
  20. data/lib/parser/ruby23.rb +6624 -0
  21. data/lib/parser/ruby24.rb +6694 -0
  22. data/lib/parser/ruby25.rb +6662 -0
  23. data/lib/parser/ruby26.rb +6676 -0
  24. data/lib/parser/ruby27.rb +7862 -0
  25. data/lib/parser/ruby28.rb +8047 -0
  26. data/lib/parser/ruby30.rb +8060 -0
  27. data/lib/parser/ruby31.rb +8075 -0
  28. data/lib/parser/rubymotion.rb +6086 -0
  29. data/lib/parser/runner.rb +9 -4
  30. data/lib/parser/source/buffer.rb +50 -27
  31. data/lib/parser/source/comment.rb +14 -1
  32. data/lib/parser/source/comment/associator.rb +18 -5
  33. data/lib/parser/source/map/{endless_definition.rb → method_definition.rb} +5 -3
  34. data/lib/parser/source/range.rb +2 -2
  35. data/lib/parser/source/tree_rewriter.rb +27 -0
  36. data/lib/parser/static_environment.rb +4 -0
  37. data/lib/parser/variables_stack.rb +4 -0
  38. data/lib/parser/version.rb +1 -1
  39. data/parser.gemspec +1 -17
  40. metadata +9 -97
  41. data/.gitignore +0 -34
  42. data/.travis.yml +0 -40
  43. data/.yardopts +0 -21
  44. data/CHANGELOG.md +0 -1116
  45. data/CONTRIBUTING.md +0 -17
  46. data/Gemfile +0 -10
  47. data/README.md +0 -309
  48. data/Rakefile +0 -167
  49. data/ci/run_rubocop_specs +0 -14
  50. data/doc/AST_FORMAT.md +0 -2283
  51. data/doc/CUSTOMIZATION.md +0 -37
  52. data/doc/INTERNALS.md +0 -21
  53. data/doc/css/.gitkeep +0 -0
  54. data/doc/css/common.css +0 -68
  55. data/lib/parser/lexer.rl +0 -2550
  56. data/lib/parser/macruby.y +0 -2208
  57. data/lib/parser/ruby18.y +0 -1936
  58. data/lib/parser/ruby19.y +0 -2185
  59. data/lib/parser/ruby20.y +0 -2363
  60. data/lib/parser/ruby21.y +0 -2364
  61. data/lib/parser/ruby22.y +0 -2371
  62. data/lib/parser/ruby23.y +0 -2377
  63. data/lib/parser/ruby24.y +0 -2415
  64. data/lib/parser/ruby25.y +0 -2412
  65. data/lib/parser/ruby26.y +0 -2420
  66. data/lib/parser/ruby27.y +0 -2950
  67. data/lib/parser/ruby28.y +0 -3043
  68. data/lib/parser/rubymotion.y +0 -2192
  69. data/test/bug_163/fixtures/input.rb +0 -5
  70. data/test/bug_163/fixtures/output.rb +0 -5
  71. data/test/bug_163/rewriter.rb +0 -20
  72. data/test/helper.rb +0 -103
  73. data/test/parse_helper.rb +0 -323
  74. data/test/racc_coverage_helper.rb +0 -133
  75. data/test/test_ast_processor.rb +0 -32
  76. data/test/test_base.rb +0 -31
  77. data/test/test_current.rb +0 -31
  78. data/test/test_diagnostic.rb +0 -95
  79. data/test/test_diagnostic_engine.rb +0 -59
  80. data/test/test_encoding.rb +0 -99
  81. data/test/test_lexer.rb +0 -3617
  82. data/test/test_lexer_stack_state.rb +0 -78
  83. data/test/test_meta.rb +0 -12
  84. data/test/test_parse_helper.rb +0 -80
  85. data/test/test_parser.rb +0 -9780
  86. data/test/test_runner_parse.rb +0 -56
  87. data/test/test_runner_rewrite.rb +0 -47
  88. data/test/test_source_buffer.rb +0 -165
  89. data/test/test_source_comment.rb +0 -36
  90. data/test/test_source_comment_associator.rb +0 -399
  91. data/test/test_source_map.rb +0 -14
  92. data/test/test_source_range.rb +0 -192
  93. data/test/test_source_rewriter.rb +0 -541
  94. data/test/test_source_rewriter_action.rb +0 -46
  95. data/test/test_source_tree_rewriter.rb +0 -361
  96. data/test/test_static_environment.rb +0 -45
  97. data/test/using_tree_rewriter/fixtures/input.rb +0 -3
  98. data/test/using_tree_rewriter/fixtures/output.rb +0 -3
  99. data/test/using_tree_rewriter/using_tree_rewriter.rb +0 -9
data/lib/parser/ruby27.y DELETED
@@ -1,2950 +0,0 @@
1
- class Parser::Ruby27
2
-
3
- token kCLASS kMODULE kDEF kUNDEF kBEGIN kRESCUE kENSURE kEND kIF kUNLESS
4
- kTHEN kELSIF kELSE kCASE kWHEN kWHILE kUNTIL kFOR kBREAK kNEXT
5
- kREDO kRETRY kIN kDO kDO_COND kDO_BLOCK kDO_LAMBDA kRETURN kYIELD kSUPER
6
- kSELF kNIL kTRUE kFALSE kAND kOR kNOT kIF_MOD kUNLESS_MOD kWHILE_MOD
7
- kUNTIL_MOD kRESCUE_MOD kALIAS kDEFINED klBEGIN klEND k__LINE__
8
- k__FILE__ k__ENCODING__ tIDENTIFIER tFID tGVAR tIVAR tCONSTANT
9
- tLABEL tCVAR tNTH_REF tBACK_REF tSTRING_CONTENT tINTEGER tFLOAT
10
- tUPLUS tUMINUS tUNARY_NUM tPOW tCMP tEQ tEQQ tNEQ
11
- tGEQ tLEQ tANDOP tOROP tMATCH tNMATCH tDOT tDOT2 tDOT3 tAREF
12
- tASET tLSHFT tRSHFT tCOLON2 tCOLON3 tOP_ASGN tASSOC tLPAREN
13
- tLPAREN2 tRPAREN tLPAREN_ARG tLBRACK tLBRACK2 tRBRACK tLBRACE
14
- tLBRACE_ARG tSTAR tSTAR2 tAMPER tAMPER2 tTILDE tPERCENT tDIVIDE
15
- tDSTAR tPLUS tMINUS tLT tGT tPIPE tBANG tCARET tLCURLY tRCURLY
16
- tBACK_REF2 tSYMBEG tSTRING_BEG tXSTRING_BEG tREGEXP_BEG tREGEXP_OPT
17
- tWORDS_BEG tQWORDS_BEG tSYMBOLS_BEG tQSYMBOLS_BEG tSTRING_DBEG
18
- tSTRING_DVAR tSTRING_END tSTRING_DEND tSTRING tSYMBOL
19
- tNL tEH tCOLON tCOMMA tSPACE tSEMI tLAMBDA tLAMBEG tCHARACTER
20
- tRATIONAL tIMAGINARY tLABEL_END tANDDOT tBDOT2 tBDOT3
21
-
22
- prechigh
23
- right tBANG tTILDE tUPLUS
24
- right tPOW
25
- right tUNARY_NUM tUMINUS
26
- left tSTAR2 tDIVIDE tPERCENT
27
- left tPLUS tMINUS
28
- left tLSHFT tRSHFT
29
- left tAMPER2
30
- left tPIPE tCARET
31
- left tGT tGEQ tLT tLEQ
32
- nonassoc tCMP tEQ tEQQ tNEQ tMATCH tNMATCH
33
- left tANDOP
34
- left tOROP
35
- nonassoc tDOT2 tDOT3 tBDOT2 tBDOT3
36
- right tEH tCOLON
37
- left kRESCUE_MOD
38
- right tEQL tOP_ASGN
39
- nonassoc kDEFINED
40
- right kNOT
41
- left kOR kAND
42
- nonassoc kIF_MOD kUNLESS_MOD kWHILE_MOD kUNTIL_MOD kIN
43
- nonassoc tLBRACE_ARG
44
- nonassoc tLOWEST
45
- preclow
46
-
47
- rule
48
-
49
- program: top_compstmt
50
-
51
- top_compstmt: top_stmts opt_terms
52
- {
53
- result = @builder.compstmt(val[0])
54
- }
55
-
56
- top_stmts: # nothing
57
- {
58
- result = []
59
- }
60
- | top_stmt
61
- {
62
- result = [ val[0] ]
63
- }
64
- | top_stmts terms top_stmt
65
- {
66
- result = val[0] << val[2]
67
- }
68
- | error top_stmt
69
- {
70
- result = [ val[1] ]
71
- }
72
-
73
- top_stmt: stmt
74
- | klBEGIN begin_block
75
- {
76
- result = @builder.preexe(val[0], *val[1])
77
- }
78
-
79
- begin_block: tLCURLY top_compstmt tRCURLY
80
- {
81
- result = val
82
- }
83
-
84
- bodystmt: compstmt opt_rescue opt_else opt_ensure
85
- {
86
- rescue_bodies = val[1]
87
- else_t, else_ = val[2]
88
- ensure_t, ensure_ = val[3]
89
-
90
- if rescue_bodies.empty? && !else_t.nil?
91
- diagnostic :error, :useless_else, nil, else_t
92
- end
93
-
94
- result = @builder.begin_body(val[0],
95
- rescue_bodies,
96
- else_t, else_,
97
- ensure_t, ensure_)
98
- }
99
-
100
- compstmt: stmts opt_terms
101
- {
102
- result = @builder.compstmt(val[0])
103
- }
104
-
105
- stmts: # nothing
106
- {
107
- result = []
108
- }
109
- | stmt_or_begin
110
- {
111
- result = [ val[0] ]
112
- }
113
- | stmts terms stmt_or_begin
114
- {
115
- result = val[0] << val[2]
116
- }
117
- | error stmt
118
- {
119
- result = [ val[1] ]
120
- }
121
-
122
- stmt_or_begin: stmt
123
- | klBEGIN begin_block
124
- {
125
- diagnostic :error, :begin_in_method, nil, val[0]
126
- }
127
-
128
- stmt: kALIAS fitem
129
- {
130
- @lexer.state = :expr_fname
131
- }
132
- fitem
133
- {
134
- result = @builder.alias(val[0], val[1], val[3])
135
- }
136
- | kALIAS tGVAR tGVAR
137
- {
138
- result = @builder.alias(val[0],
139
- @builder.gvar(val[1]),
140
- @builder.gvar(val[2]))
141
- }
142
- | kALIAS tGVAR tBACK_REF
143
- {
144
- result = @builder.alias(val[0],
145
- @builder.gvar(val[1]),
146
- @builder.back_ref(val[2]))
147
- }
148
- | kALIAS tGVAR tNTH_REF
149
- {
150
- diagnostic :error, :nth_ref_alias, nil, val[2]
151
- }
152
- | kUNDEF undef_list
153
- {
154
- result = @builder.undef_method(val[0], val[1])
155
- }
156
- | stmt kIF_MOD expr_value
157
- {
158
- result = @builder.condition_mod(val[0], nil,
159
- val[1], val[2])
160
- }
161
- | stmt kUNLESS_MOD expr_value
162
- {
163
- result = @builder.condition_mod(nil, val[0],
164
- val[1], val[2])
165
- }
166
- | stmt kWHILE_MOD expr_value
167
- {
168
- result = @builder.loop_mod(:while, val[0], val[1], val[2])
169
- }
170
- | stmt kUNTIL_MOD expr_value
171
- {
172
- result = @builder.loop_mod(:until, val[0], val[1], val[2])
173
- }
174
- | stmt kRESCUE_MOD stmt
175
- {
176
- rescue_body = @builder.rescue_body(val[1],
177
- nil, nil, nil,
178
- nil, val[2])
179
-
180
- result = @builder.begin_body(val[0], [ rescue_body ])
181
- }
182
- | klEND tLCURLY compstmt tRCURLY
183
- {
184
- result = @builder.postexe(val[0], val[1], val[2], val[3])
185
- }
186
- | command_asgn
187
- | mlhs tEQL command_call
188
- {
189
- result = @builder.multi_assign(val[0], val[1], val[2])
190
- }
191
- | lhs tEQL mrhs
192
- {
193
- result = @builder.assign(val[0], val[1],
194
- @builder.array(nil, val[2], nil))
195
- }
196
- | mlhs tEQL mrhs_arg kRESCUE_MOD stmt
197
- {
198
- rescue_body = @builder.rescue_body(val[3],
199
- nil, nil, nil,
200
- nil, val[4])
201
- begin_body = @builder.begin_body(val[2], [ rescue_body ])
202
-
203
- result = @builder.multi_assign(val[0], val[1], begin_body)
204
- }
205
- | mlhs tEQL mrhs_arg
206
- {
207
- result = @builder.multi_assign(val[0], val[1], val[2])
208
- }
209
- | expr
210
-
211
- command_asgn: lhs tEQL command_rhs
212
- {
213
- result = @builder.assign(val[0], val[1], val[2])
214
- }
215
- | var_lhs tOP_ASGN command_rhs
216
- {
217
- result = @builder.op_assign(val[0], val[1], val[2])
218
- }
219
- | primary_value tLBRACK2 opt_call_args rbracket tOP_ASGN command_rhs
220
- {
221
- result = @builder.op_assign(
222
- @builder.index(
223
- val[0], val[1], val[2], val[3]),
224
- val[4], val[5])
225
- }
226
- | primary_value call_op tIDENTIFIER tOP_ASGN command_rhs
227
- {
228
- result = @builder.op_assign(
229
- @builder.call_method(
230
- val[0], val[1], val[2]),
231
- val[3], val[4])
232
- }
233
- | primary_value call_op tCONSTANT tOP_ASGN command_rhs
234
- {
235
- result = @builder.op_assign(
236
- @builder.call_method(
237
- val[0], val[1], val[2]),
238
- val[3], val[4])
239
- }
240
- | primary_value tCOLON2 tCONSTANT tOP_ASGN command_rhs
241
- {
242
- const = @builder.const_op_assignable(
243
- @builder.const_fetch(val[0], val[1], val[2]))
244
- result = @builder.op_assign(const, val[3], val[4])
245
- }
246
- | primary_value tCOLON2 tIDENTIFIER tOP_ASGN command_rhs
247
- {
248
- result = @builder.op_assign(
249
- @builder.call_method(
250
- val[0], val[1], val[2]),
251
- val[3], val[4])
252
- }
253
- | backref tOP_ASGN command_rhs
254
- {
255
- @builder.op_assign(val[0], val[1], val[2])
256
- }
257
-
258
- command_rhs: command_call =tOP_ASGN
259
- | command_call kRESCUE_MOD stmt
260
- {
261
- rescue_body = @builder.rescue_body(val[1],
262
- nil, nil, nil,
263
- nil, val[2])
264
-
265
- result = @builder.begin_body(val[0], [ rescue_body ])
266
- }
267
- | command_asgn
268
-
269
- expr: command_call
270
- | expr kAND expr
271
- {
272
- result = @builder.logical_op(:and, val[0], val[1], val[2])
273
- }
274
- | expr kOR expr
275
- {
276
- result = @builder.logical_op(:or, val[0], val[1], val[2])
277
- }
278
- | kNOT opt_nl expr
279
- {
280
- result = @builder.not_op(val[0], nil, val[2], nil)
281
- }
282
- | tBANG command_call
283
- {
284
- result = @builder.not_op(val[0], nil, val[1], nil)
285
- }
286
- | arg kIN
287
- {
288
- @lexer.state = :expr_beg
289
- @lexer.command_start = false
290
- pattern_variables.push
291
-
292
- result = @lexer.in_kwarg
293
- @lexer.in_kwarg = true
294
- }
295
- p_expr
296
- {
297
- @lexer.in_kwarg = val[2]
298
- result = @builder.in_match(val[0], val[1], val[3])
299
- }
300
- | arg =tLBRACE_ARG
301
-
302
- expr_value: expr
303
-
304
- expr_value_do: {
305
- @lexer.cond.push(true)
306
- }
307
- expr_value do
308
- {
309
- @lexer.cond.pop
310
- result = [ val[1], val[2] ]
311
- }
312
-
313
- command_call: command
314
- | block_command
315
-
316
- block_command: block_call
317
- | block_call dot_or_colon operation2 command_args
318
- {
319
- result = @builder.call_method(val[0], val[1], val[2],
320
- nil, val[3], nil)
321
- }
322
-
323
- cmd_brace_block: tLBRACE_ARG
324
- {
325
- @context.push(:block)
326
- }
327
- brace_body tRCURLY
328
- {
329
- result = [ val[0], *val[2], val[3] ]
330
- @context.pop
331
- }
332
-
333
- fcall: operation
334
-
335
- command: fcall command_args =tLOWEST
336
- {
337
- result = @builder.call_method(nil, nil, val[0],
338
- nil, val[1], nil)
339
- }
340
- | fcall command_args cmd_brace_block
341
- {
342
- method_call = @builder.call_method(nil, nil, val[0],
343
- nil, val[1], nil)
344
-
345
- begin_t, args, body, end_t = val[2]
346
- result = @builder.block(method_call,
347
- begin_t, args, body, end_t)
348
- }
349
- | primary_value call_op operation2 command_args =tLOWEST
350
- {
351
- result = @builder.call_method(val[0], val[1], val[2],
352
- nil, val[3], nil)
353
- }
354
- | primary_value call_op operation2 command_args cmd_brace_block
355
- {
356
- method_call = @builder.call_method(val[0], val[1], val[2],
357
- nil, val[3], nil)
358
-
359
- begin_t, args, body, end_t = val[4]
360
- result = @builder.block(method_call,
361
- begin_t, args, body, end_t)
362
- }
363
- | primary_value tCOLON2 operation2 command_args =tLOWEST
364
- {
365
- result = @builder.call_method(val[0], val[1], val[2],
366
- nil, val[3], nil)
367
- }
368
- | primary_value tCOLON2 operation2 command_args cmd_brace_block
369
- {
370
- method_call = @builder.call_method(val[0], val[1], val[2],
371
- nil, val[3], nil)
372
-
373
- begin_t, args, body, end_t = val[4]
374
- result = @builder.block(method_call,
375
- begin_t, args, body, end_t)
376
- }
377
- | kSUPER command_args
378
- {
379
- result = @builder.keyword_cmd(:super, val[0],
380
- nil, val[1], nil)
381
- }
382
- | kYIELD command_args
383
- {
384
- result = @builder.keyword_cmd(:yield, val[0],
385
- nil, val[1], nil)
386
- }
387
- | k_return call_args
388
- {
389
- result = @builder.keyword_cmd(:return, val[0],
390
- nil, val[1], nil)
391
- }
392
- | kBREAK call_args
393
- {
394
- result = @builder.keyword_cmd(:break, val[0],
395
- nil, val[1], nil)
396
- }
397
- | kNEXT call_args
398
- {
399
- result = @builder.keyword_cmd(:next, val[0],
400
- nil, val[1], nil)
401
- }
402
-
403
- mlhs: mlhs_basic
404
- {
405
- result = @builder.multi_lhs(nil, val[0], nil)
406
- }
407
- | tLPAREN mlhs_inner rparen
408
- {
409
- result = @builder.begin(val[0], val[1], val[2])
410
- }
411
-
412
- mlhs_inner: mlhs_basic
413
- {
414
- result = @builder.multi_lhs(nil, val[0], nil)
415
- }
416
- | tLPAREN mlhs_inner rparen
417
- {
418
- result = @builder.multi_lhs(val[0], val[1], val[2])
419
- }
420
-
421
- mlhs_basic: mlhs_head
422
- | mlhs_head mlhs_item
423
- {
424
- result = val[0].
425
- push(val[1])
426
- }
427
- | mlhs_head tSTAR mlhs_node
428
- {
429
- result = val[0].
430
- push(@builder.splat(val[1], val[2]))
431
- }
432
- | mlhs_head tSTAR mlhs_node tCOMMA mlhs_post
433
- {
434
- result = val[0].
435
- push(@builder.splat(val[1], val[2])).
436
- concat(val[4])
437
- }
438
- | mlhs_head tSTAR
439
- {
440
- result = val[0].
441
- push(@builder.splat(val[1]))
442
- }
443
- | mlhs_head tSTAR tCOMMA mlhs_post
444
- {
445
- result = val[0].
446
- push(@builder.splat(val[1])).
447
- concat(val[3])
448
- }
449
- | tSTAR mlhs_node
450
- {
451
- result = [ @builder.splat(val[0], val[1]) ]
452
- }
453
- | tSTAR mlhs_node tCOMMA mlhs_post
454
- {
455
- result = [ @builder.splat(val[0], val[1]),
456
- *val[3] ]
457
- }
458
- | tSTAR
459
- {
460
- result = [ @builder.splat(val[0]) ]
461
- }
462
- | tSTAR tCOMMA mlhs_post
463
- {
464
- result = [ @builder.splat(val[0]),
465
- *val[2] ]
466
- }
467
-
468
- mlhs_item: mlhs_node
469
- | tLPAREN mlhs_inner rparen
470
- {
471
- result = @builder.begin(val[0], val[1], val[2])
472
- }
473
-
474
- mlhs_head: mlhs_item tCOMMA
475
- {
476
- result = [ val[0] ]
477
- }
478
- | mlhs_head mlhs_item tCOMMA
479
- {
480
- result = val[0] << val[1]
481
- }
482
-
483
- mlhs_post: mlhs_item
484
- {
485
- result = [ val[0] ]
486
- }
487
- | mlhs_post tCOMMA mlhs_item
488
- {
489
- result = val[0] << val[2]
490
- }
491
-
492
- mlhs_node: user_variable
493
- {
494
- result = @builder.assignable(val[0])
495
- }
496
- | keyword_variable
497
- {
498
- result = @builder.assignable(val[0])
499
- }
500
- | primary_value tLBRACK2 opt_call_args rbracket
501
- {
502
- result = @builder.index_asgn(val[0], val[1], val[2], val[3])
503
- }
504
- | primary_value call_op tIDENTIFIER
505
- {
506
- if (val[1][0] == :anddot)
507
- diagnostic :error, :csend_in_lhs_of_masgn, nil, val[1]
508
- end
509
-
510
- result = @builder.attr_asgn(val[0], val[1], val[2])
511
- }
512
- | primary_value tCOLON2 tIDENTIFIER
513
- {
514
- result = @builder.attr_asgn(val[0], val[1], val[2])
515
- }
516
- | primary_value call_op tCONSTANT
517
- {
518
- if (val[1][0] == :anddot)
519
- diagnostic :error, :csend_in_lhs_of_masgn, nil, val[1]
520
- end
521
-
522
- result = @builder.attr_asgn(val[0], val[1], val[2])
523
- }
524
- | primary_value tCOLON2 tCONSTANT
525
- {
526
- result = @builder.assignable(
527
- @builder.const_fetch(val[0], val[1], val[2]))
528
- }
529
- | tCOLON3 tCONSTANT
530
- {
531
- result = @builder.assignable(
532
- @builder.const_global(val[0], val[1]))
533
- }
534
- | backref
535
- {
536
- result = @builder.assignable(val[0])
537
- }
538
-
539
- lhs: user_variable
540
- {
541
- result = @builder.assignable(val[0])
542
- }
543
- | keyword_variable
544
- {
545
- result = @builder.assignable(val[0])
546
- }
547
- | primary_value tLBRACK2 opt_call_args rbracket
548
- {
549
- result = @builder.index_asgn(val[0], val[1], val[2], val[3])
550
- }
551
- | primary_value call_op tIDENTIFIER
552
- {
553
- result = @builder.attr_asgn(val[0], val[1], val[2])
554
- }
555
- | primary_value tCOLON2 tIDENTIFIER
556
- {
557
- result = @builder.attr_asgn(val[0], val[1], val[2])
558
- }
559
- | primary_value call_op tCONSTANT
560
- {
561
- result = @builder.attr_asgn(val[0], val[1], val[2])
562
- }
563
- | primary_value tCOLON2 tCONSTANT
564
- {
565
- result = @builder.assignable(
566
- @builder.const_fetch(val[0], val[1], val[2]))
567
- }
568
- | tCOLON3 tCONSTANT
569
- {
570
- result = @builder.assignable(
571
- @builder.const_global(val[0], val[1]))
572
- }
573
- | backref
574
- {
575
- result = @builder.assignable(val[0])
576
- }
577
-
578
- cname: tIDENTIFIER
579
- {
580
- diagnostic :error, :module_name_const, nil, val[0]
581
- }
582
- | tCONSTANT
583
-
584
- cpath: tCOLON3 cname
585
- {
586
- result = @builder.const_global(val[0], val[1])
587
- }
588
- | cname
589
- {
590
- result = @builder.const(val[0])
591
- }
592
- | primary_value tCOLON2 cname
593
- {
594
- result = @builder.const_fetch(val[0], val[1], val[2])
595
- }
596
-
597
- fname: tIDENTIFIER | tCONSTANT | tFID
598
- | op
599
- | reswords
600
-
601
- fitem: fname
602
- {
603
- result = @builder.symbol(val[0])
604
- }
605
- | symbol
606
-
607
- undef_list: fitem
608
- {
609
- result = [ val[0] ]
610
- }
611
- | undef_list tCOMMA
612
- {
613
- @lexer.state = :expr_fname
614
- }
615
- fitem
616
- {
617
- result = val[0] << val[3]
618
- }
619
-
620
- op: tPIPE | tCARET | tAMPER2 | tCMP | tEQ | tEQQ
621
- | tMATCH | tNMATCH | tGT | tGEQ | tLT | tLEQ
622
- | tNEQ | tLSHFT | tRSHFT | tPLUS | tMINUS | tSTAR2
623
- | tSTAR | tDIVIDE | tPERCENT | tPOW | tBANG | tTILDE
624
- | tUPLUS | tUMINUS | tAREF | tASET | tDSTAR | tBACK_REF2
625
-
626
- reswords: k__LINE__ | k__FILE__ | k__ENCODING__ | klBEGIN | klEND
627
- | kALIAS | kAND | kBEGIN | kBREAK | kCASE
628
- | kCLASS | kDEF | kDEFINED | kDO | kELSE
629
- | kELSIF | kEND | kENSURE | kFALSE | kFOR
630
- | kIN | kMODULE | kNEXT | kNIL | kNOT
631
- | kOR | kREDO | kRESCUE | kRETRY | kRETURN
632
- | kSELF | kSUPER | kTHEN | kTRUE | kUNDEF
633
- | kWHEN | kYIELD | kIF | kUNLESS | kWHILE
634
- | kUNTIL
635
-
636
- arg: lhs tEQL arg_rhs
637
- {
638
- result = @builder.assign(val[0], val[1], val[2])
639
- }
640
- | var_lhs tOP_ASGN arg_rhs
641
- {
642
- result = @builder.op_assign(val[0], val[1], val[2])
643
- }
644
- | primary_value tLBRACK2 opt_call_args rbracket tOP_ASGN arg_rhs
645
- {
646
- result = @builder.op_assign(
647
- @builder.index(
648
- val[0], val[1], val[2], val[3]),
649
- val[4], val[5])
650
- }
651
- | primary_value call_op tIDENTIFIER tOP_ASGN arg_rhs
652
- {
653
- result = @builder.op_assign(
654
- @builder.call_method(
655
- val[0], val[1], val[2]),
656
- val[3], val[4])
657
- }
658
- | primary_value call_op tCONSTANT tOP_ASGN arg_rhs
659
- {
660
- result = @builder.op_assign(
661
- @builder.call_method(
662
- val[0], val[1], val[2]),
663
- val[3], val[4])
664
- }
665
- | primary_value tCOLON2 tIDENTIFIER tOP_ASGN arg_rhs
666
- {
667
- result = @builder.op_assign(
668
- @builder.call_method(
669
- val[0], val[1], val[2]),
670
- val[3], val[4])
671
- }
672
- | primary_value tCOLON2 tCONSTANT tOP_ASGN arg_rhs
673
- {
674
- const = @builder.const_op_assignable(
675
- @builder.const_fetch(val[0], val[1], val[2]))
676
- result = @builder.op_assign(const, val[3], val[4])
677
- }
678
- | tCOLON3 tCONSTANT tOP_ASGN arg_rhs
679
- {
680
- const = @builder.const_op_assignable(
681
- @builder.const_global(val[0], val[1]))
682
- result = @builder.op_assign(const, val[2], val[3])
683
- }
684
- | backref tOP_ASGN arg_rhs
685
- {
686
- result = @builder.op_assign(val[0], val[1], val[2])
687
- }
688
- | arg tDOT2 arg
689
- {
690
- result = @builder.range_inclusive(val[0], val[1], val[2])
691
- }
692
- | arg tDOT3 arg
693
- {
694
- result = @builder.range_exclusive(val[0], val[1], val[2])
695
- }
696
- | arg tDOT2
697
- {
698
- result = @builder.range_inclusive(val[0], val[1], nil)
699
- }
700
- | arg tDOT3
701
- {
702
- result = @builder.range_exclusive(val[0], val[1], nil)
703
- }
704
- | tBDOT2 arg
705
- {
706
- result = @builder.range_inclusive(nil, val[0], val[1])
707
- }
708
- | tBDOT3 arg
709
- {
710
- result = @builder.range_exclusive(nil, val[0], val[1])
711
- }
712
- | arg tPLUS arg
713
- {
714
- result = @builder.binary_op(val[0], val[1], val[2])
715
- }
716
- | arg tMINUS arg
717
- {
718
- result = @builder.binary_op(val[0], val[1], val[2])
719
- }
720
- | arg tSTAR2 arg
721
- {
722
- result = @builder.binary_op(val[0], val[1], val[2])
723
- }
724
- | arg tDIVIDE arg
725
- {
726
- result = @builder.binary_op(val[0], val[1], val[2])
727
- }
728
- | arg tPERCENT arg
729
- {
730
- result = @builder.binary_op(val[0], val[1], val[2])
731
- }
732
- | arg tPOW arg
733
- {
734
- result = @builder.binary_op(val[0], val[1], val[2])
735
- }
736
- | tUNARY_NUM simple_numeric tPOW arg
737
- {
738
- result = @builder.unary_op(val[0],
739
- @builder.binary_op(
740
- val[1], val[2], val[3]))
741
- }
742
- | tUPLUS arg
743
- {
744
- result = @builder.unary_op(val[0], val[1])
745
- }
746
- | tUMINUS arg
747
- {
748
- result = @builder.unary_op(val[0], val[1])
749
- }
750
- | arg tPIPE arg
751
- {
752
- result = @builder.binary_op(val[0], val[1], val[2])
753
- }
754
- | arg tCARET arg
755
- {
756
- result = @builder.binary_op(val[0], val[1], val[2])
757
- }
758
- | arg tAMPER2 arg
759
- {
760
- result = @builder.binary_op(val[0], val[1], val[2])
761
- }
762
- | arg tCMP arg
763
- {
764
- result = @builder.binary_op(val[0], val[1], val[2])
765
- }
766
- | rel_expr =tCMP
767
- | arg tEQ arg
768
- {
769
- result = @builder.binary_op(val[0], val[1], val[2])
770
- }
771
- | arg tEQQ arg
772
- {
773
- result = @builder.binary_op(val[0], val[1], val[2])
774
- }
775
- | arg tNEQ arg
776
- {
777
- result = @builder.binary_op(val[0], val[1], val[2])
778
- }
779
- | arg tMATCH arg
780
- {
781
- result = @builder.match_op(val[0], val[1], val[2])
782
- }
783
- | arg tNMATCH arg
784
- {
785
- result = @builder.binary_op(val[0], val[1], val[2])
786
- }
787
- | tBANG arg
788
- {
789
- result = @builder.not_op(val[0], nil, val[1], nil)
790
- }
791
- | tTILDE arg
792
- {
793
- result = @builder.unary_op(val[0], val[1])
794
- }
795
- | arg tLSHFT arg
796
- {
797
- result = @builder.binary_op(val[0], val[1], val[2])
798
- }
799
- | arg tRSHFT arg
800
- {
801
- result = @builder.binary_op(val[0], val[1], val[2])
802
- }
803
- | arg tANDOP arg
804
- {
805
- result = @builder.logical_op(:and, val[0], val[1], val[2])
806
- }
807
- | arg tOROP arg
808
- {
809
- result = @builder.logical_op(:or, val[0], val[1], val[2])
810
- }
811
- | kDEFINED opt_nl arg
812
- {
813
- result = @builder.keyword_cmd(:defined?, val[0], nil, [ val[2] ], nil)
814
- }
815
- | arg tEH arg opt_nl tCOLON arg
816
- {
817
- result = @builder.ternary(val[0], val[1],
818
- val[2], val[4], val[5])
819
- }
820
- | primary
821
-
822
- relop: tGT | tLT | tGEQ | tLEQ
823
-
824
- rel_expr: arg relop arg =tGT
825
- {
826
- result = @builder.binary_op(val[0], val[1], val[2])
827
- }
828
- | rel_expr relop arg =tGT
829
- {
830
- result = @builder.binary_op(val[0], val[1], val[2])
831
- }
832
-
833
- arg_value: arg
834
-
835
- aref_args: none
836
- | args trailer
837
- | args tCOMMA assocs trailer
838
- {
839
- result = val[0] << @builder.associate(nil, val[2], nil)
840
- }
841
- | assocs trailer
842
- {
843
- result = [ @builder.associate(nil, val[0], nil) ]
844
- }
845
-
846
- arg_rhs: arg =tOP_ASGN
847
- | arg kRESCUE_MOD arg
848
- {
849
- rescue_body = @builder.rescue_body(val[1],
850
- nil, nil, nil,
851
- nil, val[2])
852
-
853
- result = @builder.begin_body(val[0], [ rescue_body ])
854
- }
855
-
856
- paren_args: tLPAREN2 opt_call_args rparen
857
- {
858
- result = val
859
- }
860
- | tLPAREN2 args_forward rparen
861
- {
862
- unless @static_env.declared_forward_args?
863
- diagnostic :error, :unexpected_token, { :token => 'tBDOT3' } , val[1]
864
- end
865
-
866
- result = [val[0], [@builder.forwarded_args(val[1])], val[2]]
867
- }
868
-
869
- opt_paren_args: # nothing
870
- {
871
- result = [ nil, [], nil ]
872
- }
873
- | paren_args
874
-
875
- opt_call_args: # nothing
876
- {
877
- result = []
878
- }
879
- | call_args
880
- | args tCOMMA
881
- | args tCOMMA assocs tCOMMA
882
- {
883
- result = val[0] << @builder.associate(nil, val[2], nil)
884
- }
885
- | assocs tCOMMA
886
- {
887
- result = [ @builder.associate(nil, val[0], nil) ]
888
- }
889
-
890
- call_args: command
891
- {
892
- result = [ val[0] ]
893
- }
894
- | args opt_block_arg
895
- {
896
- result = val[0].concat(val[1])
897
- }
898
- | assocs opt_block_arg
899
- {
900
- result = [ @builder.associate(nil, val[0], nil) ]
901
- result.concat(val[1])
902
- }
903
- | args tCOMMA assocs opt_block_arg
904
- {
905
- assocs = @builder.associate(nil, val[2], nil)
906
- result = val[0] << assocs
907
- result.concat(val[3])
908
- }
909
- | block_arg
910
- {
911
- result = [ val[0] ]
912
- }
913
-
914
- command_args: {
915
- # When branch gets invoked by RACC's lookahead
916
- # and command args start with '[' or '('
917
- # we need to put `true` to the cmdarg stack
918
- # **before** `false` pushed by lexer
919
- # m [], n
920
- # ^
921
- # Right here we have cmdarg [...0] because
922
- # lexer pushed it on '['
923
- # We need to modify cmdarg stack to [...10]
924
- #
925
- # For all other cases (like `m n` or `m n, []`) we simply put 1 to the stack
926
- # and later lexer pushes corresponding bits on top of it.
927
- last_token = @last_token[0]
928
- lookahead = last_token == :tLBRACK || last_token == :tLPAREN_ARG
929
-
930
- if lookahead
931
- top = @lexer.cmdarg.pop
932
- @lexer.cmdarg.push(true)
933
- @lexer.cmdarg.push(top)
934
- else
935
- @lexer.cmdarg.push(true)
936
- end
937
- }
938
- call_args
939
- {
940
- # call_args can be followed by tLBRACE_ARG (that does cmdarg.push(0) in the lexer)
941
- # but the push must be done after cmdarg.pop() in the parser.
942
- # So this code does cmdarg.pop() to pop 0 pushed by tLBRACE_ARG,
943
- # cmdarg.pop() to pop 1 pushed by command_args,
944
- # and cmdarg.push(0) to restore back the flag set by tLBRACE_ARG.
945
- last_token = @last_token[0]
946
- lookahead = last_token == :tLBRACE_ARG
947
- if lookahead
948
- top = @lexer.cmdarg.pop
949
- @lexer.cmdarg.pop
950
- @lexer.cmdarg.push(top)
951
- else
952
- @lexer.cmdarg.pop
953
- end
954
-
955
- result = val[1]
956
- }
957
-
958
- block_arg: tAMPER arg_value
959
- {
960
- result = @builder.block_pass(val[0], val[1])
961
- }
962
-
963
- opt_block_arg: tCOMMA block_arg
964
- {
965
- result = [ val[1] ]
966
- }
967
- | # nothing
968
- {
969
- result = []
970
- }
971
-
972
- args: arg_value
973
- {
974
- result = [ val[0] ]
975
- }
976
- | tSTAR arg_value
977
- {
978
- result = [ @builder.splat(val[0], val[1]) ]
979
- }
980
- | args tCOMMA arg_value
981
- {
982
- result = val[0] << val[2]
983
- }
984
- | args tCOMMA tSTAR arg_value
985
- {
986
- result = val[0] << @builder.splat(val[2], val[3])
987
- }
988
-
989
- mrhs_arg: mrhs
990
- {
991
- result = @builder.array(nil, val[0], nil)
992
- }
993
- | arg_value
994
-
995
- mrhs: args tCOMMA arg_value
996
- {
997
- result = val[0] << val[2]
998
- }
999
- | args tCOMMA tSTAR arg_value
1000
- {
1001
- result = val[0] << @builder.splat(val[2], val[3])
1002
- }
1003
- | tSTAR arg_value
1004
- {
1005
- result = [ @builder.splat(val[0], val[1]) ]
1006
- }
1007
-
1008
- primary: literal
1009
- | strings
1010
- | xstring
1011
- | regexp
1012
- | words
1013
- | qwords
1014
- | symbols
1015
- | qsymbols
1016
- | var_ref
1017
- | backref
1018
- | tFID
1019
- {
1020
- result = @builder.call_method(nil, nil, val[0])
1021
- }
1022
- | kBEGIN
1023
- {
1024
- @lexer.cmdarg.push(false)
1025
- }
1026
- bodystmt kEND
1027
- {
1028
- @lexer.cmdarg.pop
1029
-
1030
- result = @builder.begin_keyword(val[0], val[2], val[3])
1031
- }
1032
- | tLPAREN_ARG stmt
1033
- {
1034
- @lexer.state = :expr_endarg
1035
- }
1036
- rparen
1037
- {
1038
- result = @builder.begin(val[0], val[1], val[3])
1039
- }
1040
- | tLPAREN_ARG
1041
- {
1042
- @lexer.state = :expr_endarg
1043
- }
1044
- opt_nl tRPAREN
1045
- {
1046
- result = @builder.begin(val[0], nil, val[3])
1047
- }
1048
- | tLPAREN compstmt tRPAREN
1049
- {
1050
- result = @builder.begin(val[0], val[1], val[2])
1051
- }
1052
- | primary_value tCOLON2 tCONSTANT
1053
- {
1054
- result = @builder.const_fetch(val[0], val[1], val[2])
1055
- }
1056
- | tCOLON3 tCONSTANT
1057
- {
1058
- result = @builder.const_global(val[0], val[1])
1059
- }
1060
- | tLBRACK aref_args tRBRACK
1061
- {
1062
- result = @builder.array(val[0], val[1], val[2])
1063
- }
1064
- | tLBRACE assoc_list tRCURLY
1065
- {
1066
- result = @builder.associate(val[0], val[1], val[2])
1067
- }
1068
- | k_return
1069
- {
1070
- result = @builder.keyword_cmd(:return, val[0])
1071
- }
1072
- | kYIELD tLPAREN2 call_args rparen
1073
- {
1074
- result = @builder.keyword_cmd(:yield, val[0], val[1], val[2], val[3])
1075
- }
1076
- | kYIELD tLPAREN2 rparen
1077
- {
1078
- result = @builder.keyword_cmd(:yield, val[0], val[1], [], val[2])
1079
- }
1080
- | kYIELD
1081
- {
1082
- result = @builder.keyword_cmd(:yield, val[0])
1083
- }
1084
- | kDEFINED opt_nl tLPAREN2 expr rparen
1085
- {
1086
- result = @builder.keyword_cmd(:defined?, val[0],
1087
- val[2], [ val[3] ], val[4])
1088
- }
1089
- | kNOT tLPAREN2 expr rparen
1090
- {
1091
- result = @builder.not_op(val[0], val[1], val[2], val[3])
1092
- }
1093
- | kNOT tLPAREN2 rparen
1094
- {
1095
- result = @builder.not_op(val[0], val[1], nil, val[2])
1096
- }
1097
- | fcall brace_block
1098
- {
1099
- method_call = @builder.call_method(nil, nil, val[0])
1100
-
1101
- begin_t, args, body, end_t = val[1]
1102
- result = @builder.block(method_call,
1103
- begin_t, args, body, end_t)
1104
- }
1105
- | method_call
1106
- | method_call brace_block
1107
- {
1108
- begin_t, args, body, end_t = val[1]
1109
- result = @builder.block(val[0],
1110
- begin_t, args, body, end_t)
1111
- }
1112
- | tLAMBDA
1113
- {
1114
- @context.push(:lambda)
1115
- }
1116
- lambda
1117
- {
1118
- lambda_call = @builder.call_lambda(val[0])
1119
-
1120
- args, (begin_t, body, end_t) = val[2]
1121
- result = @builder.block(lambda_call,
1122
- begin_t, args, body, end_t)
1123
- }
1124
- | kIF expr_value then compstmt if_tail kEND
1125
- {
1126
- else_t, else_ = val[4]
1127
- result = @builder.condition(val[0], val[1], val[2],
1128
- val[3], else_t,
1129
- else_, val[5])
1130
- }
1131
- | kUNLESS expr_value then compstmt opt_else kEND
1132
- {
1133
- else_t, else_ = val[4]
1134
- result = @builder.condition(val[0], val[1], val[2],
1135
- else_, else_t,
1136
- val[3], val[5])
1137
- }
1138
- | kWHILE expr_value_do compstmt kEND
1139
- {
1140
- result = @builder.loop(:while, val[0], *val[1], val[2], val[3])
1141
- }
1142
- | kUNTIL expr_value_do compstmt kEND
1143
- {
1144
- result = @builder.loop(:until, val[0], *val[1], val[2], val[3])
1145
- }
1146
- | kCASE expr_value opt_terms case_body kEND
1147
- {
1148
- *when_bodies, (else_t, else_body) = *val[3]
1149
-
1150
- result = @builder.case(val[0], val[1],
1151
- when_bodies, else_t, else_body,
1152
- val[4])
1153
- }
1154
- | kCASE opt_terms case_body kEND
1155
- {
1156
- *when_bodies, (else_t, else_body) = *val[2]
1157
-
1158
- result = @builder.case(val[0], nil,
1159
- when_bodies, else_t, else_body,
1160
- val[3])
1161
- }
1162
- | kCASE expr_value opt_terms p_case_body kEND
1163
- {
1164
- *in_bodies, (else_t, else_body) = *val[3]
1165
-
1166
- result = @builder.case_match(val[0], val[1],
1167
- in_bodies, else_t, else_body,
1168
- val[4])
1169
- }
1170
- | kFOR for_var kIN expr_value_do compstmt kEND
1171
- {
1172
- result = @builder.for(val[0], val[1], val[2], *val[3], val[4], val[5])
1173
- }
1174
- | kCLASS cpath superclass
1175
- {
1176
- @static_env.extend_static
1177
- @lexer.cmdarg.push(false)
1178
- @lexer.cond.push(false)
1179
- @context.push(:class)
1180
- }
1181
- bodystmt kEND
1182
- {
1183
- unless @context.class_definition_allowed?
1184
- diagnostic :error, :class_in_def, nil, val[0]
1185
- end
1186
-
1187
- lt_t, superclass = val[2]
1188
- result = @builder.def_class(val[0], val[1],
1189
- lt_t, superclass,
1190
- val[4], val[5])
1191
-
1192
- @lexer.cmdarg.pop
1193
- @lexer.cond.pop
1194
- @static_env.unextend
1195
- @context.pop
1196
- }
1197
- | kCLASS tLSHFT expr term
1198
- {
1199
- @static_env.extend_static
1200
- @lexer.cmdarg.push(false)
1201
- @lexer.cond.push(false)
1202
- @context.push(:sclass)
1203
- }
1204
- bodystmt kEND
1205
- {
1206
- result = @builder.def_sclass(val[0], val[1], val[2],
1207
- val[5], val[6])
1208
-
1209
- @lexer.cmdarg.pop
1210
- @lexer.cond.pop
1211
- @static_env.unextend
1212
- @context.pop
1213
- }
1214
- | kMODULE cpath
1215
- {
1216
- @static_env.extend_static
1217
- @lexer.cmdarg.push(false)
1218
- @context.push(:module)
1219
- }
1220
- bodystmt kEND
1221
- {
1222
- unless @context.module_definition_allowed?
1223
- diagnostic :error, :module_in_def, nil, val[0]
1224
- end
1225
-
1226
- result = @builder.def_module(val[0], val[1],
1227
- val[3], val[4])
1228
-
1229
- @lexer.cmdarg.pop
1230
- @static_env.unextend
1231
- @context.pop
1232
- }
1233
- | kDEF fname
1234
- {
1235
- @static_env.extend_static
1236
- @lexer.cmdarg.push(false)
1237
- @lexer.cond.push(false)
1238
- @context.push(:def)
1239
- @current_arg_stack.push(nil)
1240
- }
1241
- f_arglist bodystmt kEND
1242
- {
1243
- result = @builder.def_method(val[0], val[1],
1244
- val[3], val[4], val[5])
1245
-
1246
- @lexer.cmdarg.pop
1247
- @lexer.cond.pop
1248
- @static_env.unextend
1249
- @context.pop
1250
- @current_arg_stack.pop
1251
- }
1252
- | kDEF singleton dot_or_colon
1253
- {
1254
- @lexer.state = :expr_fname
1255
- }
1256
- fname
1257
- {
1258
- @static_env.extend_static
1259
- @lexer.cmdarg.push(false)
1260
- @lexer.cond.push(false)
1261
- @context.push(:defs)
1262
- @current_arg_stack.push(nil)
1263
- }
1264
- f_arglist bodystmt kEND
1265
- {
1266
- result = @builder.def_singleton(val[0], val[1], val[2],
1267
- val[4], val[6], val[7], val[8])
1268
-
1269
- @lexer.cmdarg.pop
1270
- @lexer.cond.pop
1271
- @static_env.unextend
1272
- @context.pop
1273
- @current_arg_stack.pop
1274
- }
1275
- | kBREAK
1276
- {
1277
- result = @builder.keyword_cmd(:break, val[0])
1278
- }
1279
- | kNEXT
1280
- {
1281
- result = @builder.keyword_cmd(:next, val[0])
1282
- }
1283
- | kREDO
1284
- {
1285
- result = @builder.keyword_cmd(:redo, val[0])
1286
- }
1287
- | kRETRY
1288
- {
1289
- result = @builder.keyword_cmd(:retry, val[0])
1290
- }
1291
-
1292
- primary_value: primary
1293
-
1294
- k_return: kRETURN
1295
- {
1296
- if @context.in_class?
1297
- diagnostic :error, :invalid_return, nil, val[0]
1298
- end
1299
- }
1300
-
1301
- then: term
1302
- | kTHEN
1303
- | term kTHEN
1304
- {
1305
- result = val[1]
1306
- }
1307
-
1308
- do: term
1309
- | kDO_COND
1310
-
1311
- if_tail: opt_else
1312
- | kELSIF expr_value then compstmt if_tail
1313
- {
1314
- else_t, else_ = val[4]
1315
- result = [ val[0],
1316
- @builder.condition(val[0], val[1], val[2],
1317
- val[3], else_t,
1318
- else_, nil),
1319
- ]
1320
- }
1321
-
1322
- opt_else: none
1323
- | kELSE compstmt
1324
- {
1325
- result = val
1326
- }
1327
-
1328
- for_var: lhs
1329
- | mlhs
1330
-
1331
- f_marg: f_norm_arg
1332
- {
1333
- result = @builder.arg(val[0])
1334
- }
1335
- | tLPAREN f_margs rparen
1336
- {
1337
- result = @builder.multi_lhs(val[0], val[1], val[2])
1338
- }
1339
-
1340
- f_marg_list: f_marg
1341
- {
1342
- result = [ val[0] ]
1343
- }
1344
- | f_marg_list tCOMMA f_marg
1345
- {
1346
- result = val[0] << val[2]
1347
- }
1348
-
1349
- f_margs: f_marg_list
1350
- | f_marg_list tCOMMA f_rest_marg
1351
- {
1352
- result = val[0].
1353
- push(val[2])
1354
- }
1355
- | f_marg_list tCOMMA f_rest_marg tCOMMA f_marg_list
1356
- {
1357
- result = val[0].
1358
- push(val[2]).
1359
- concat(val[4])
1360
- }
1361
- | f_rest_marg
1362
- {
1363
- result = [ val[0] ]
1364
- }
1365
- | f_rest_marg tCOMMA f_marg_list
1366
- {
1367
- result = [ val[0], *val[2] ]
1368
- }
1369
-
1370
- f_rest_marg: tSTAR f_norm_arg
1371
- {
1372
- result = @builder.restarg(val[0], val[1])
1373
- }
1374
- | tSTAR
1375
- {
1376
- result = @builder.restarg(val[0])
1377
- }
1378
-
1379
- block_args_tail: f_block_kwarg tCOMMA f_kwrest opt_f_block_arg
1380
- {
1381
- result = val[0].concat(val[2]).concat(val[3])
1382
- }
1383
- | f_block_kwarg opt_f_block_arg
1384
- {
1385
- result = val[0].concat(val[1])
1386
- }
1387
- | f_kwrest opt_f_block_arg
1388
- {
1389
- result = val[0].concat(val[1])
1390
- }
1391
- | f_no_kwarg opt_f_block_arg
1392
- {
1393
- result = val[0].concat(val[1])
1394
- }
1395
- | f_block_arg
1396
- {
1397
- result = [ val[0] ]
1398
- }
1399
-
1400
- opt_block_args_tail:
1401
- tCOMMA block_args_tail
1402
- {
1403
- result = val[1]
1404
- }
1405
- | # nothing
1406
- {
1407
- result = []
1408
- }
1409
-
1410
- block_param: f_arg tCOMMA f_block_optarg tCOMMA f_rest_arg opt_block_args_tail
1411
- {
1412
- result = val[0].
1413
- concat(val[2]).
1414
- concat(val[4]).
1415
- concat(val[5])
1416
- }
1417
- | f_arg tCOMMA f_block_optarg tCOMMA f_rest_arg tCOMMA f_arg opt_block_args_tail
1418
- {
1419
- result = val[0].
1420
- concat(val[2]).
1421
- concat(val[4]).
1422
- concat(val[6]).
1423
- concat(val[7])
1424
- }
1425
- | f_arg tCOMMA f_block_optarg opt_block_args_tail
1426
- {
1427
- result = val[0].
1428
- concat(val[2]).
1429
- concat(val[3])
1430
- }
1431
- | f_arg tCOMMA f_block_optarg tCOMMA f_arg opt_block_args_tail
1432
- {
1433
- result = val[0].
1434
- concat(val[2]).
1435
- concat(val[4]).
1436
- concat(val[5])
1437
- }
1438
- | f_arg tCOMMA f_rest_arg opt_block_args_tail
1439
- {
1440
- result = val[0].
1441
- concat(val[2]).
1442
- concat(val[3])
1443
- }
1444
- | f_arg tCOMMA
1445
- | f_arg tCOMMA f_rest_arg tCOMMA f_arg opt_block_args_tail
1446
- {
1447
- result = val[0].
1448
- concat(val[2]).
1449
- concat(val[4]).
1450
- concat(val[5])
1451
- }
1452
- | f_arg opt_block_args_tail
1453
- {
1454
- if val[1].empty? && val[0].size == 1
1455
- result = [@builder.procarg0(val[0][0])]
1456
- else
1457
- result = val[0].concat(val[1])
1458
- end
1459
- }
1460
- | f_block_optarg tCOMMA f_rest_arg opt_block_args_tail
1461
- {
1462
- result = val[0].
1463
- concat(val[2]).
1464
- concat(val[3])
1465
- }
1466
- | f_block_optarg tCOMMA f_rest_arg tCOMMA f_arg opt_block_args_tail
1467
- {
1468
- result = val[0].
1469
- concat(val[2]).
1470
- concat(val[4]).
1471
- concat(val[5])
1472
- }
1473
- | f_block_optarg opt_block_args_tail
1474
- {
1475
- result = val[0].
1476
- concat(val[1])
1477
- }
1478
- | f_block_optarg tCOMMA f_arg opt_block_args_tail
1479
- {
1480
- result = val[0].
1481
- concat(val[2]).
1482
- concat(val[3])
1483
- }
1484
- | f_rest_arg opt_block_args_tail
1485
- {
1486
- result = val[0].
1487
- concat(val[1])
1488
- }
1489
- | f_rest_arg tCOMMA f_arg opt_block_args_tail
1490
- {
1491
- result = val[0].
1492
- concat(val[2]).
1493
- concat(val[3])
1494
- }
1495
- | block_args_tail
1496
-
1497
- opt_block_param: # nothing
1498
- {
1499
- result = @builder.args(nil, [], nil)
1500
- }
1501
- | block_param_def
1502
- {
1503
- @lexer.state = :expr_value
1504
- }
1505
-
1506
- block_param_def: tPIPE opt_bv_decl tPIPE
1507
- {
1508
- @max_numparam_stack.has_ordinary_params!
1509
- @current_arg_stack.set(nil)
1510
- result = @builder.args(val[0], val[1], val[2])
1511
- }
1512
- | tPIPE block_param opt_bv_decl tPIPE
1513
- {
1514
- @max_numparam_stack.has_ordinary_params!
1515
- @current_arg_stack.set(nil)
1516
- result = @builder.args(val[0], val[1].concat(val[2]), val[3])
1517
- }
1518
-
1519
- opt_bv_decl: opt_nl
1520
- {
1521
- result = []
1522
- }
1523
- | opt_nl tSEMI bv_decls opt_nl
1524
- {
1525
- result = val[2]
1526
- }
1527
-
1528
- bv_decls: bvar
1529
- {
1530
- result = [ val[0] ]
1531
- }
1532
- | bv_decls tCOMMA bvar
1533
- {
1534
- result = val[0] << val[2]
1535
- }
1536
-
1537
- bvar: tIDENTIFIER
1538
- {
1539
- @static_env.declare val[0][0]
1540
- result = @builder.shadowarg(val[0])
1541
- }
1542
- | f_bad_arg
1543
-
1544
- lambda: {
1545
- @static_env.extend_dynamic
1546
- @max_numparam_stack.push
1547
- }
1548
- f_larglist
1549
- {
1550
- @context.pop
1551
- @lexer.cmdarg.push(false)
1552
- }
1553
- lambda_body
1554
- {
1555
- args = @max_numparam_stack.has_numparams? ? @builder.numargs(@max_numparam_stack.top) : val[1]
1556
- result = [ args, val[3] ]
1557
-
1558
- @max_numparam_stack.pop
1559
- @static_env.unextend
1560
- @lexer.cmdarg.pop
1561
- }
1562
-
1563
- f_larglist: tLPAREN2 f_args opt_bv_decl tRPAREN
1564
- {
1565
- @max_numparam_stack.has_ordinary_params!
1566
- result = @builder.args(val[0], val[1].concat(val[2]), val[3])
1567
- }
1568
- | f_args
1569
- {
1570
- if val[0].any?
1571
- @max_numparam_stack.has_ordinary_params!
1572
- end
1573
- result = @builder.args(nil, val[0], nil)
1574
- }
1575
-
1576
- lambda_body: tLAMBEG
1577
- {
1578
- @context.push(:lambda)
1579
- }
1580
- compstmt tRCURLY
1581
- {
1582
- result = [ val[0], val[2], val[3] ]
1583
- @context.pop
1584
- }
1585
- | kDO_LAMBDA
1586
- {
1587
- @context.push(:lambda)
1588
- }
1589
- bodystmt kEND
1590
- {
1591
- result = [ val[0], val[2], val[3] ]
1592
- @context.pop
1593
- }
1594
-
1595
- do_block: kDO_BLOCK
1596
- {
1597
- @context.push(:block)
1598
- }
1599
- do_body kEND
1600
- {
1601
- result = [ val[0], *val[2], val[3] ]
1602
- @context.pop
1603
- }
1604
-
1605
- block_call: command do_block
1606
- {
1607
- begin_t, block_args, body, end_t = val[1]
1608
- result = @builder.block(val[0],
1609
- begin_t, block_args, body, end_t)
1610
- }
1611
- | block_call dot_or_colon operation2 opt_paren_args
1612
- {
1613
- lparen_t, args, rparen_t = val[3]
1614
- result = @builder.call_method(val[0], val[1], val[2],
1615
- lparen_t, args, rparen_t)
1616
- }
1617
- | block_call dot_or_colon operation2 opt_paren_args brace_block
1618
- {
1619
- lparen_t, args, rparen_t = val[3]
1620
- method_call = @builder.call_method(val[0], val[1], val[2],
1621
- lparen_t, args, rparen_t)
1622
-
1623
- begin_t, args, body, end_t = val[4]
1624
- result = @builder.block(method_call,
1625
- begin_t, args, body, end_t)
1626
- }
1627
- | block_call dot_or_colon operation2 command_args do_block
1628
- {
1629
- method_call = @builder.call_method(val[0], val[1], val[2],
1630
- nil, val[3], nil)
1631
-
1632
- begin_t, args, body, end_t = val[4]
1633
- result = @builder.block(method_call,
1634
- begin_t, args, body, end_t)
1635
- }
1636
-
1637
- method_call: fcall paren_args
1638
- {
1639
- lparen_t, args, rparen_t = val[1]
1640
- result = @builder.call_method(nil, nil, val[0],
1641
- lparen_t, args, rparen_t)
1642
- }
1643
- | primary_value call_op operation2 opt_paren_args
1644
- {
1645
- lparen_t, args, rparen_t = val[3]
1646
- result = @builder.call_method(val[0], val[1], val[2],
1647
- lparen_t, args, rparen_t)
1648
- }
1649
- | primary_value tCOLON2 operation2 paren_args
1650
- {
1651
- lparen_t, args, rparen_t = val[3]
1652
- result = @builder.call_method(val[0], val[1], val[2],
1653
- lparen_t, args, rparen_t)
1654
- }
1655
- | primary_value tCOLON2 operation3
1656
- {
1657
- result = @builder.call_method(val[0], val[1], val[2])
1658
- }
1659
- | primary_value call_op paren_args
1660
- {
1661
- lparen_t, args, rparen_t = val[2]
1662
- result = @builder.call_method(val[0], val[1], nil,
1663
- lparen_t, args, rparen_t)
1664
- }
1665
- | primary_value tCOLON2 paren_args
1666
- {
1667
- lparen_t, args, rparen_t = val[2]
1668
- result = @builder.call_method(val[0], val[1], nil,
1669
- lparen_t, args, rparen_t)
1670
- }
1671
- | kSUPER paren_args
1672
- {
1673
- lparen_t, args, rparen_t = val[1]
1674
- result = @builder.keyword_cmd(:super, val[0],
1675
- lparen_t, args, rparen_t)
1676
- }
1677
- | kSUPER
1678
- {
1679
- result = @builder.keyword_cmd(:zsuper, val[0])
1680
- }
1681
- | primary_value tLBRACK2 opt_call_args rbracket
1682
- {
1683
- result = @builder.index(val[0], val[1], val[2], val[3])
1684
- }
1685
-
1686
- brace_block: tLCURLY
1687
- {
1688
- @context.push(:block)
1689
- }
1690
- brace_body tRCURLY
1691
- {
1692
- result = [ val[0], *val[2], val[3] ]
1693
- @context.pop
1694
- }
1695
- | kDO
1696
- {
1697
- @context.push(:block)
1698
- }
1699
- do_body kEND
1700
- {
1701
- result = [ val[0], *val[2], val[3] ]
1702
- @context.pop
1703
- }
1704
-
1705
- brace_body: {
1706
- @static_env.extend_dynamic
1707
- @max_numparam_stack.push
1708
- }
1709
- opt_block_param compstmt
1710
- {
1711
- args = @max_numparam_stack.has_numparams? ? @builder.numargs(@max_numparam_stack.top) : val[1]
1712
- result = [ args, val[2] ]
1713
-
1714
- @max_numparam_stack.pop
1715
- @static_env.unextend
1716
- }
1717
-
1718
- do_body: {
1719
- @static_env.extend_dynamic
1720
- @max_numparam_stack.push
1721
- }
1722
- {
1723
- @lexer.cmdarg.push(false)
1724
- }
1725
- opt_block_param bodystmt
1726
- {
1727
- args = @max_numparam_stack.has_numparams? ? @builder.numargs(@max_numparam_stack.top) : val[2]
1728
- result = [ args, val[3] ]
1729
-
1730
- @max_numparam_stack.pop
1731
- @static_env.unextend
1732
- @lexer.cmdarg.pop
1733
- }
1734
-
1735
- case_body: kWHEN args then compstmt cases
1736
- {
1737
- result = [ @builder.when(val[0], val[1], val[2], val[3]),
1738
- *val[4] ]
1739
- }
1740
-
1741
- cases: opt_else
1742
- {
1743
- result = [ val[0] ]
1744
- }
1745
- | case_body
1746
-
1747
- p_case_body: kIN
1748
- {
1749
- @lexer.state = :expr_beg
1750
- @lexer.command_start = false
1751
- @pattern_variables.push
1752
- @pattern_hash_keys.push
1753
-
1754
- result = @lexer.in_kwarg
1755
- @lexer.in_kwarg = true
1756
- }
1757
- p_top_expr then
1758
- {
1759
- @lexer.in_kwarg = val[1]
1760
- }
1761
- compstmt p_cases
1762
- {
1763
- result = [ @builder.in_pattern(val[0], *val[2], val[3], val[5]),
1764
- *val[6] ]
1765
- }
1766
-
1767
- p_cases: opt_else
1768
- {
1769
- result = [ val[0] ]
1770
- }
1771
- | p_case_body
1772
-
1773
- p_top_expr: p_top_expr_body
1774
- {
1775
- result = [ val[0], nil ]
1776
- }
1777
- | p_top_expr_body kIF_MOD expr_value
1778
- {
1779
- result = [ val[0], @builder.if_guard(val[1], val[2]) ]
1780
- }
1781
- | p_top_expr_body kUNLESS_MOD expr_value
1782
- {
1783
- result = [ val[0], @builder.unless_guard(val[1], val[2]) ]
1784
- }
1785
-
1786
- p_top_expr_body: p_expr
1787
- | p_expr tCOMMA
1788
- {
1789
- # array patterns that end with comma
1790
- # like 1, 2,
1791
- # must be emitted as `array_pattern_with_tail`
1792
- item = @builder.match_with_trailing_comma(val[0], val[1])
1793
- result = @builder.array_pattern(nil, [ item ], nil)
1794
- }
1795
- | p_expr tCOMMA p_args
1796
- {
1797
- result = @builder.array_pattern(nil, [val[0]].concat(val[2]), nil)
1798
- }
1799
- | p_args_tail
1800
- {
1801
- result = @builder.array_pattern(nil, val[0], nil)
1802
- }
1803
- | p_kwargs
1804
- {
1805
- result = @builder.hash_pattern(nil, val[0], nil)
1806
- }
1807
-
1808
- p_expr: p_as
1809
-
1810
- p_as: p_expr tASSOC p_variable
1811
- {
1812
- result = @builder.match_as(val[0], val[1], val[2])
1813
- }
1814
- | p_alt
1815
-
1816
- p_alt: p_alt tPIPE p_expr_basic
1817
- {
1818
- result = @builder.match_alt(val[0], val[1], val[2])
1819
- }
1820
- | p_expr_basic
1821
-
1822
- p_lparen: tLPAREN2
1823
- {
1824
- result = val[0]
1825
- @pattern_hash_keys.push
1826
- }
1827
-
1828
- p_lbracket: tLBRACK2
1829
- {
1830
- result = val[0]
1831
- @pattern_hash_keys.push
1832
- }
1833
-
1834
- p_expr_basic: p_value
1835
- | p_const p_lparen p_args rparen
1836
- {
1837
- @pattern_hash_keys.pop
1838
- pattern = @builder.array_pattern(nil, val[2], nil)
1839
- result = @builder.const_pattern(val[0], val[1], pattern, val[3])
1840
- }
1841
- | p_const p_lparen p_kwargs rparen
1842
- {
1843
- @pattern_hash_keys.pop
1844
- pattern = @builder.hash_pattern(nil, val[2], nil)
1845
- result = @builder.const_pattern(val[0], val[1], pattern, val[3])
1846
- }
1847
- | p_const tLPAREN2 rparen
1848
- {
1849
- pattern = @builder.array_pattern(val[1], nil, val[2])
1850
- result = @builder.const_pattern(val[0], val[1], pattern, val[2])
1851
- }
1852
- | p_const p_lbracket p_args rbracket
1853
- {
1854
- @pattern_hash_keys.pop
1855
- pattern = @builder.array_pattern(nil, val[2], nil)
1856
- result = @builder.const_pattern(val[0], val[1], pattern, val[3])
1857
- }
1858
- | p_const p_lbracket p_kwargs rbracket
1859
- {
1860
- @pattern_hash_keys.pop
1861
- pattern = @builder.hash_pattern(nil, val[2], nil)
1862
- result = @builder.const_pattern(val[0], val[1], pattern, val[3])
1863
- }
1864
- | p_const tLBRACK2 rbracket
1865
- {
1866
- pattern = @builder.array_pattern(val[1], nil, val[2])
1867
- result = @builder.const_pattern(val[0], val[1], pattern, val[2])
1868
- }
1869
- | tLBRACK
1870
- {
1871
- @pattern_hash_keys.push
1872
- }
1873
- p_args rbracket
1874
- {
1875
- @pattern_hash_keys.pop
1876
- result = @builder.array_pattern(val[0], val[2], val[3])
1877
- }
1878
- | tLBRACK rbracket
1879
- {
1880
- result = @builder.array_pattern(val[0], [], val[1])
1881
- }
1882
- | tLBRACE
1883
- {
1884
- @pattern_hash_keys.push
1885
- result = @lexer.in_kwarg
1886
- @lexer.in_kwarg = false
1887
- }
1888
- p_kwargs rbrace
1889
- {
1890
- @pattern_hash_keys.pop
1891
- @lexer.in_kwarg = val[1]
1892
- result = @builder.hash_pattern(val[0], val[2], val[3])
1893
- }
1894
- | tLBRACE rbrace
1895
- {
1896
- result = @builder.hash_pattern(val[0], [], val[1])
1897
- }
1898
- | tLPAREN
1899
- {
1900
- @pattern_hash_keys.push
1901
- }
1902
- p_expr rparen
1903
- {
1904
- @pattern_hash_keys.pop
1905
- result = @builder.begin(val[0], val[2], val[3])
1906
- }
1907
-
1908
- p_args: p_expr
1909
- {
1910
- result = [ val[0] ]
1911
- }
1912
- | p_args_head
1913
- {
1914
- result = val[0]
1915
- }
1916
- | p_args_head p_arg
1917
- {
1918
- result = [ *val[0], val[1] ]
1919
- }
1920
- | p_args_head tSTAR tIDENTIFIER
1921
- {
1922
- match_rest = @builder.match_rest(val[1], val[2])
1923
- result = [ *val[0], match_rest ]
1924
- }
1925
- | p_args_head tSTAR tIDENTIFIER tCOMMA p_args_post
1926
- {
1927
- match_rest = @builder.match_rest(val[1], val[2])
1928
- result = [ *val[0], match_rest, *val[4] ]
1929
- }
1930
- | p_args_head tSTAR
1931
- {
1932
- result = [ *val[0], @builder.match_rest(val[1]) ]
1933
- }
1934
- | p_args_head tSTAR tCOMMA p_args_post
1935
- {
1936
- result = [ *val[0], @builder.match_rest(val[1]), *val[3] ]
1937
- }
1938
- | p_args_tail
1939
-
1940
- p_args_head: p_arg tCOMMA
1941
- {
1942
- # array patterns that end with comma
1943
- # like [1, 2,]
1944
- # must be emitted as `array_pattern_with_tail`
1945
- item = @builder.match_with_trailing_comma(val[0], val[1])
1946
- result = [ item ]
1947
- }
1948
- | p_args_head p_arg tCOMMA
1949
- {
1950
- # array patterns that end with comma
1951
- # like [1, 2,]
1952
- # must be emitted as `array_pattern_with_tail`
1953
- last_item = @builder.match_with_trailing_comma(val[1], val[2])
1954
- result = [ *val[0], last_item ]
1955
- }
1956
-
1957
- p_args_tail: tSTAR tIDENTIFIER
1958
- {
1959
- match_rest = @builder.match_rest(val[0], val[1])
1960
- result = [ match_rest ]
1961
- }
1962
- | tSTAR tIDENTIFIER tCOMMA p_args_post
1963
- {
1964
- match_rest = @builder.match_rest(val[0], val[1])
1965
- result = [ match_rest, *val[3] ]
1966
- }
1967
- | tSTAR
1968
- {
1969
- match_rest = @builder.match_rest(val[0])
1970
- result = [ match_rest ]
1971
- }
1972
- | tSTAR tCOMMA p_args_post
1973
- {
1974
- match_rest = @builder.match_rest(val[0])
1975
- result = [ match_rest, *val[2] ]
1976
- }
1977
-
1978
- p_args_post: p_arg
1979
- {
1980
- result = [ val[0] ]
1981
- }
1982
- | p_args_post tCOMMA p_arg
1983
- {
1984
- result = [ *val[0], val[2] ]
1985
- }
1986
-
1987
- p_arg: p_expr
1988
-
1989
- p_kwargs: p_kwarg tCOMMA p_kwrest
1990
- {
1991
- result = [ *val[0], *val[2] ]
1992
- }
1993
- | p_kwarg
1994
- {
1995
- result = val[0]
1996
- }
1997
- | p_kwarg tCOMMA
1998
- {
1999
- result = val[0]
2000
- }
2001
- | p_kwrest
2002
- {
2003
- result = val[0]
2004
- }
2005
- | p_kwarg tCOMMA p_kwnorest
2006
- {
2007
- result = [ *val[0], *val[2] ]
2008
- }
2009
- | p_kwnorest
2010
- {
2011
- result = [ *val[0], *val[2] ]
2012
- }
2013
-
2014
- p_kwarg: p_kw
2015
- {
2016
- result = [ val[0] ]
2017
- }
2018
- | p_kwarg tCOMMA p_kw
2019
- {
2020
- result = [ *val[0], val[2] ]
2021
- }
2022
-
2023
- p_kw: p_kw_label p_expr
2024
- {
2025
- result = @builder.match_pair(*val[0], val[1])
2026
- }
2027
- | p_kw_label
2028
- {
2029
- result = @builder.match_label(*val[0])
2030
- }
2031
-
2032
- p_kw_label: tLABEL
2033
- {
2034
- check_kwarg_name(val[0])
2035
- result = [:label, val[0]]
2036
- }
2037
- | tSTRING_BEG string_contents tLABEL_END
2038
- {
2039
- result = [:quoted, [val[0], val[1], val[2]]]
2040
- }
2041
-
2042
- p_kwrest: kwrest_mark tIDENTIFIER
2043
- {
2044
- result = [ @builder.match_rest(val[0], val[1]) ]
2045
- }
2046
- | kwrest_mark
2047
- {
2048
- result = [ @builder.match_rest(val[0], nil) ]
2049
- }
2050
-
2051
- p_kwnorest: kwrest_mark kNIL
2052
- {
2053
- result = [ @builder.match_nil_pattern(val[0], val[1]) ]
2054
- }
2055
-
2056
- p_value: p_primitive
2057
- | p_primitive tDOT2 p_primitive
2058
- {
2059
- result = @builder.range_inclusive(val[0], val[1], val[2])
2060
- }
2061
- | p_primitive tDOT3 p_primitive
2062
- {
2063
- result = @builder.range_exclusive(val[0], val[1], val[2])
2064
- }
2065
- | p_primitive tDOT2
2066
- {
2067
- result = @builder.range_inclusive(val[0], val[1], nil)
2068
- }
2069
- | p_primitive tDOT3
2070
- {
2071
- result = @builder.range_exclusive(val[0], val[1], nil)
2072
- }
2073
- | p_variable
2074
- | p_var_ref
2075
- | p_const
2076
- | tBDOT2 p_primitive
2077
- {
2078
- result = @builder.range_inclusive(nil, val[0], val[1])
2079
- }
2080
- | tBDOT3 p_primitive
2081
- {
2082
- result = @builder.range_exclusive(nil, val[0], val[1])
2083
- }
2084
-
2085
- p_primitive: literal
2086
- | strings
2087
- | xstring
2088
- | regexp
2089
- | words
2090
- | qwords
2091
- | symbols
2092
- | qsymbols
2093
- | keyword_variable
2094
- {
2095
- result = @builder.accessible(val[0])
2096
- }
2097
- | tLAMBDA
2098
- {
2099
- @context.push(:lambda)
2100
- }
2101
- lambda
2102
- {
2103
- lambda_call = @builder.call_lambda(val[0])
2104
-
2105
- args, (begin_t, body, end_t) = val[2]
2106
- result = @builder.block(lambda_call,
2107
- begin_t, args, body, end_t)
2108
- }
2109
-
2110
- p_variable: tIDENTIFIER
2111
- {
2112
- result = @builder.match_var(val[0])
2113
- }
2114
-
2115
- p_var_ref: tCARET tIDENTIFIER
2116
- {
2117
- name = val[1][0]
2118
- unless static_env.declared?(name)
2119
- diagnostic :error, :undefined_lvar, { :name => name }, val[1]
2120
- end
2121
-
2122
- lvar = @builder.accessible(@builder.ident(val[1]))
2123
- result = @builder.pin(val[0], lvar)
2124
- }
2125
-
2126
- p_const: tCOLON3 cname
2127
- {
2128
- result = @builder.const_global(val[0], val[1])
2129
- }
2130
- | p_const tCOLON2 cname
2131
- {
2132
- result = @builder.const_fetch(val[0], val[1], val[2])
2133
- }
2134
- | tCONSTANT
2135
- {
2136
- result = @builder.const(val[0])
2137
- }
2138
-
2139
- opt_rescue: kRESCUE exc_list exc_var then compstmt opt_rescue
2140
- {
2141
- assoc_t, exc_var = val[2]
2142
-
2143
- if val[1]
2144
- exc_list = @builder.array(nil, val[1], nil)
2145
- end
2146
-
2147
- result = [ @builder.rescue_body(val[0],
2148
- exc_list, assoc_t, exc_var,
2149
- val[3], val[4]),
2150
- *val[5] ]
2151
- }
2152
- |
2153
- {
2154
- result = []
2155
- }
2156
-
2157
- exc_list: arg_value
2158
- {
2159
- result = [ val[0] ]
2160
- }
2161
- | mrhs
2162
- | none
2163
-
2164
- exc_var: tASSOC lhs
2165
- {
2166
- result = [ val[0], val[1] ]
2167
- }
2168
- | none
2169
-
2170
- opt_ensure: kENSURE compstmt
2171
- {
2172
- result = [ val[0], val[1] ]
2173
- }
2174
- | none
2175
-
2176
- literal: numeric
2177
- | symbol
2178
-
2179
- strings: string
2180
- {
2181
- result = @builder.string_compose(nil, val[0], nil)
2182
- }
2183
-
2184
- string: string1
2185
- {
2186
- result = [ val[0] ]
2187
- }
2188
- | string string1
2189
- {
2190
- result = val[0] << val[1]
2191
- }
2192
-
2193
- string1: tSTRING_BEG string_contents tSTRING_END
2194
- {
2195
- string = @builder.string_compose(val[0], val[1], val[2])
2196
- result = @builder.dedent_string(string, @lexer.dedent_level)
2197
- }
2198
- | tSTRING
2199
- {
2200
- string = @builder.string(val[0])
2201
- result = @builder.dedent_string(string, @lexer.dedent_level)
2202
- }
2203
- | tCHARACTER
2204
- {
2205
- result = @builder.character(val[0])
2206
- }
2207
-
2208
- xstring: tXSTRING_BEG xstring_contents tSTRING_END
2209
- {
2210
- string = @builder.xstring_compose(val[0], val[1], val[2])
2211
- result = @builder.dedent_string(string, @lexer.dedent_level)
2212
- }
2213
-
2214
- regexp: tREGEXP_BEG regexp_contents tSTRING_END tREGEXP_OPT
2215
- {
2216
- opts = @builder.regexp_options(val[3])
2217
- result = @builder.regexp_compose(val[0], val[1], val[2], opts)
2218
- }
2219
-
2220
- words: tWORDS_BEG word_list tSTRING_END
2221
- {
2222
- result = @builder.words_compose(val[0], val[1], val[2])
2223
- }
2224
-
2225
- word_list: # nothing
2226
- {
2227
- result = []
2228
- }
2229
- | word_list word tSPACE
2230
- {
2231
- result = val[0] << @builder.word(val[1])
2232
- }
2233
-
2234
- word: string_content
2235
- {
2236
- result = [ val[0] ]
2237
- }
2238
- | word string_content
2239
- {
2240
- result = val[0] << val[1]
2241
- }
2242
-
2243
- symbols: tSYMBOLS_BEG symbol_list tSTRING_END
2244
- {
2245
- result = @builder.symbols_compose(val[0], val[1], val[2])
2246
- }
2247
-
2248
- symbol_list: # nothing
2249
- {
2250
- result = []
2251
- }
2252
- | symbol_list word tSPACE
2253
- {
2254
- result = val[0] << @builder.word(val[1])
2255
- }
2256
-
2257
- qwords: tQWORDS_BEG qword_list tSTRING_END
2258
- {
2259
- result = @builder.words_compose(val[0], val[1], val[2])
2260
- }
2261
-
2262
- qsymbols: tQSYMBOLS_BEG qsym_list tSTRING_END
2263
- {
2264
- result = @builder.symbols_compose(val[0], val[1], val[2])
2265
- }
2266
-
2267
- qword_list: # nothing
2268
- {
2269
- result = []
2270
- }
2271
- | qword_list tSTRING_CONTENT tSPACE
2272
- {
2273
- result = val[0] << @builder.string_internal(val[1])
2274
- }
2275
-
2276
- qsym_list: # nothing
2277
- {
2278
- result = []
2279
- }
2280
- | qsym_list tSTRING_CONTENT tSPACE
2281
- {
2282
- result = val[0] << @builder.symbol_internal(val[1])
2283
- }
2284
-
2285
- string_contents: # nothing
2286
- {
2287
- result = []
2288
- }
2289
- | string_contents string_content
2290
- {
2291
- result = val[0] << val[1]
2292
- }
2293
-
2294
- xstring_contents: # nothing
2295
- {
2296
- result = []
2297
- }
2298
- | xstring_contents string_content
2299
- {
2300
- result = val[0] << val[1]
2301
- }
2302
-
2303
- regexp_contents: # nothing
2304
- {
2305
- result = []
2306
- }
2307
- | regexp_contents string_content
2308
- {
2309
- result = val[0] << val[1]
2310
- }
2311
-
2312
- string_content: tSTRING_CONTENT
2313
- {
2314
- result = @builder.string_internal(val[0])
2315
- }
2316
- | tSTRING_DVAR string_dvar
2317
- {
2318
- result = val[1]
2319
- }
2320
- | tSTRING_DBEG
2321
- {
2322
- @lexer.cmdarg.push(false)
2323
- @lexer.cond.push(false)
2324
- }
2325
- compstmt tSTRING_DEND
2326
- {
2327
- @lexer.cmdarg.pop
2328
- @lexer.cond.pop
2329
-
2330
- result = @builder.begin(val[0], val[2], val[3])
2331
- }
2332
-
2333
- string_dvar: tGVAR
2334
- {
2335
- result = @builder.gvar(val[0])
2336
- }
2337
- | tIVAR
2338
- {
2339
- result = @builder.ivar(val[0])
2340
- }
2341
- | tCVAR
2342
- {
2343
- result = @builder.cvar(val[0])
2344
- }
2345
- | backref
2346
-
2347
- symbol: ssym
2348
- | dsym
2349
-
2350
- ssym: tSYMBOL
2351
- {
2352
- @lexer.state = :expr_end
2353
- result = @builder.symbol(val[0])
2354
- }
2355
-
2356
- dsym: tSYMBEG string_contents tSTRING_END
2357
- {
2358
- @lexer.state = :expr_end
2359
- result = @builder.symbol_compose(val[0], val[1], val[2])
2360
- }
2361
-
2362
- numeric: simple_numeric
2363
- {
2364
- result = val[0]
2365
- }
2366
- | tUNARY_NUM simple_numeric =tLOWEST
2367
- {
2368
- if @builder.respond_to? :negate
2369
- # AST builder interface compatibility
2370
- result = @builder.negate(val[0], val[1])
2371
- else
2372
- result = @builder.unary_num(val[0], val[1])
2373
- end
2374
- }
2375
-
2376
- simple_numeric: tINTEGER
2377
- {
2378
- @lexer.state = :expr_end
2379
- result = @builder.integer(val[0])
2380
- }
2381
- | tFLOAT
2382
- {
2383
- @lexer.state = :expr_end
2384
- result = @builder.float(val[0])
2385
- }
2386
- | tRATIONAL
2387
- {
2388
- @lexer.state = :expr_end
2389
- result = @builder.rational(val[0])
2390
- }
2391
- | tIMAGINARY
2392
- {
2393
- @lexer.state = :expr_end
2394
- result = @builder.complex(val[0])
2395
- }
2396
-
2397
- user_variable: tIDENTIFIER
2398
- {
2399
- result = @builder.ident(val[0])
2400
- }
2401
- | tIVAR
2402
- {
2403
- result = @builder.ivar(val[0])
2404
- }
2405
- | tGVAR
2406
- {
2407
- result = @builder.gvar(val[0])
2408
- }
2409
- | tCONSTANT
2410
- {
2411
- result = @builder.const(val[0])
2412
- }
2413
- | tCVAR
2414
- {
2415
- result = @builder.cvar(val[0])
2416
- }
2417
-
2418
- keyword_variable: kNIL
2419
- {
2420
- result = @builder.nil(val[0])
2421
- }
2422
- | kSELF
2423
- {
2424
- result = @builder.self(val[0])
2425
- }
2426
- | kTRUE
2427
- {
2428
- result = @builder.true(val[0])
2429
- }
2430
- | kFALSE
2431
- {
2432
- result = @builder.false(val[0])
2433
- }
2434
- | k__FILE__
2435
- {
2436
- result = @builder.__FILE__(val[0])
2437
- }
2438
- | k__LINE__
2439
- {
2440
- result = @builder.__LINE__(val[0])
2441
- }
2442
- | k__ENCODING__
2443
- {
2444
- result = @builder.__ENCODING__(val[0])
2445
- }
2446
-
2447
- var_ref: user_variable
2448
- {
2449
- if (node = val[0]) && node.type == :ident
2450
- name = node.children[0]
2451
-
2452
- if name =~ /\A_[1-9]\z/ && !static_env.declared?(name) && context.in_dynamic_block?
2453
- # definitely an implicit param
2454
- location = node.loc.expression
2455
-
2456
- if max_numparam_stack.has_ordinary_params?
2457
- diagnostic :error, :ordinary_param_defined, nil, [nil, location]
2458
- end
2459
-
2460
- raw_context = context.stack.dup
2461
- raw_max_numparam_stack = max_numparam_stack.stack.dup
2462
-
2463
- # ignore current block scope
2464
- raw_context.pop
2465
- raw_max_numparam_stack.pop
2466
-
2467
- raw_context.reverse_each do |outer_scope|
2468
- if outer_scope == :block || outer_scope == :lambda
2469
- outer_scope_has_numparams = raw_max_numparam_stack.pop > 0
2470
-
2471
- if outer_scope_has_numparams
2472
- diagnostic :error, :numparam_used_in_outer_scope, nil, [nil, location]
2473
- else
2474
- # for now it's ok, but an outer scope can also be a block
2475
- # with numparams, so we need to continue
2476
- end
2477
- else
2478
- # found an outer scope that can't have numparams
2479
- # like def/class/etc
2480
- break
2481
- end
2482
- end
2483
-
2484
- static_env.declare(name)
2485
- max_numparam_stack.register(name[1].to_i)
2486
- end
2487
- end
2488
-
2489
- result = @builder.accessible(val[0])
2490
- }
2491
- | keyword_variable
2492
- {
2493
- result = @builder.accessible(val[0])
2494
- }
2495
-
2496
- var_lhs: user_variable
2497
- {
2498
- result = @builder.assignable(val[0])
2499
- }
2500
- | keyword_variable
2501
- {
2502
- result = @builder.assignable(val[0])
2503
- }
2504
-
2505
- backref: tNTH_REF
2506
- {
2507
- result = @builder.nth_ref(val[0])
2508
- }
2509
- | tBACK_REF
2510
- {
2511
- result = @builder.back_ref(val[0])
2512
- }
2513
-
2514
- superclass: tLT
2515
- {
2516
- @lexer.state = :expr_value
2517
- }
2518
- expr_value term
2519
- {
2520
- result = [ val[0], val[2] ]
2521
- }
2522
- | # nothing
2523
- {
2524
- result = nil
2525
- }
2526
-
2527
- f_arglist: tLPAREN2 f_args rparen
2528
- {
2529
- result = @builder.args(val[0], val[1], val[2])
2530
-
2531
- @lexer.state = :expr_value
2532
- }
2533
- | tLPAREN2 args_forward rparen
2534
- {
2535
- result = @builder.forward_only_args(val[0], val[1], val[2])
2536
- @static_env.declare_forward_args
2537
-
2538
- @lexer.state = :expr_value
2539
- }
2540
- | {
2541
- result = @lexer.in_kwarg
2542
- @lexer.in_kwarg = true
2543
- }
2544
- f_args term
2545
- {
2546
- @lexer.in_kwarg = val[0]
2547
- result = @builder.args(nil, val[1], nil)
2548
- }
2549
-
2550
- args_tail: f_kwarg tCOMMA f_kwrest opt_f_block_arg
2551
- {
2552
- result = val[0].concat(val[2]).concat(val[3])
2553
- }
2554
- | f_kwarg opt_f_block_arg
2555
- {
2556
- result = val[0].concat(val[1])
2557
- }
2558
- | f_kwrest opt_f_block_arg
2559
- {
2560
- result = val[0].concat(val[1])
2561
- }
2562
- | f_no_kwarg opt_f_block_arg
2563
- {
2564
- result = val[0].concat(val[1])
2565
- }
2566
- | f_block_arg
2567
- {
2568
- result = [ val[0] ]
2569
- }
2570
-
2571
- opt_args_tail: tCOMMA args_tail
2572
- {
2573
- result = val[1]
2574
- }
2575
- | # nothing
2576
- {
2577
- result = []
2578
- }
2579
-
2580
- f_args: f_arg tCOMMA f_optarg tCOMMA f_rest_arg opt_args_tail
2581
- {
2582
- result = val[0].
2583
- concat(val[2]).
2584
- concat(val[4]).
2585
- concat(val[5])
2586
- }
2587
- | f_arg tCOMMA f_optarg tCOMMA f_rest_arg tCOMMA f_arg opt_args_tail
2588
- {
2589
- result = val[0].
2590
- concat(val[2]).
2591
- concat(val[4]).
2592
- concat(val[6]).
2593
- concat(val[7])
2594
- }
2595
- | f_arg tCOMMA f_optarg opt_args_tail
2596
- {
2597
- result = val[0].
2598
- concat(val[2]).
2599
- concat(val[3])
2600
- }
2601
- | f_arg tCOMMA f_optarg tCOMMA f_arg opt_args_tail
2602
- {
2603
- result = val[0].
2604
- concat(val[2]).
2605
- concat(val[4]).
2606
- concat(val[5])
2607
- }
2608
- | f_arg tCOMMA f_rest_arg opt_args_tail
2609
- {
2610
- result = val[0].
2611
- concat(val[2]).
2612
- concat(val[3])
2613
- }
2614
- | f_arg tCOMMA f_rest_arg tCOMMA f_arg opt_args_tail
2615
- {
2616
- result = val[0].
2617
- concat(val[2]).
2618
- concat(val[4]).
2619
- concat(val[5])
2620
- }
2621
- | f_arg opt_args_tail
2622
- {
2623
- result = val[0].
2624
- concat(val[1])
2625
- }
2626
- | f_optarg tCOMMA f_rest_arg opt_args_tail
2627
- {
2628
- result = val[0].
2629
- concat(val[2]).
2630
- concat(val[3])
2631
- }
2632
- | f_optarg tCOMMA f_rest_arg tCOMMA f_arg opt_args_tail
2633
- {
2634
- result = val[0].
2635
- concat(val[2]).
2636
- concat(val[4]).
2637
- concat(val[5])
2638
- }
2639
- | f_optarg opt_args_tail
2640
- {
2641
- result = val[0].
2642
- concat(val[1])
2643
- }
2644
- | f_optarg tCOMMA f_arg opt_args_tail
2645
- {
2646
- result = val[0].
2647
- concat(val[2]).
2648
- concat(val[3])
2649
- }
2650
- | f_rest_arg opt_args_tail
2651
- {
2652
- result = val[0].
2653
- concat(val[1])
2654
- }
2655
- | f_rest_arg tCOMMA f_arg opt_args_tail
2656
- {
2657
- result = val[0].
2658
- concat(val[2]).
2659
- concat(val[3])
2660
- }
2661
- | args_tail
2662
- {
2663
- result = val[0]
2664
- }
2665
- | # nothing
2666
- {
2667
- result = []
2668
- }
2669
-
2670
- args_forward: tBDOT3
2671
- {
2672
- result = val[0]
2673
- }
2674
-
2675
- f_bad_arg: tCONSTANT
2676
- {
2677
- diagnostic :error, :argument_const, nil, val[0]
2678
- }
2679
- | tIVAR
2680
- {
2681
- diagnostic :error, :argument_ivar, nil, val[0]
2682
- }
2683
- | tGVAR
2684
- {
2685
- diagnostic :error, :argument_gvar, nil, val[0]
2686
- }
2687
- | tCVAR
2688
- {
2689
- diagnostic :error, :argument_cvar, nil, val[0]
2690
- }
2691
-
2692
- f_norm_arg: f_bad_arg
2693
- | tIDENTIFIER
2694
- {
2695
- @static_env.declare val[0][0]
2696
-
2697
- @max_numparam_stack.has_ordinary_params!
2698
-
2699
- result = val[0]
2700
- }
2701
-
2702
- f_arg_asgn: f_norm_arg
2703
- {
2704
- @current_arg_stack.set(val[0][0])
2705
- result = val[0]
2706
- }
2707
-
2708
- f_arg_item: f_arg_asgn
2709
- {
2710
- @current_arg_stack.set(0)
2711
- result = @builder.arg(val[0])
2712
- }
2713
- | tLPAREN f_margs rparen
2714
- {
2715
- result = @builder.multi_lhs(val[0], val[1], val[2])
2716
- }
2717
-
2718
- f_arg: f_arg_item
2719
- {
2720
- result = [ val[0] ]
2721
- }
2722
- | f_arg tCOMMA f_arg_item
2723
- {
2724
- result = val[0] << val[2]
2725
- }
2726
-
2727
- f_label: tLABEL
2728
- {
2729
- check_kwarg_name(val[0])
2730
-
2731
- @static_env.declare val[0][0]
2732
-
2733
- @max_numparam_stack.has_ordinary_params!
2734
-
2735
- @current_arg_stack.set(val[0][0])
2736
-
2737
- result = val[0]
2738
- }
2739
-
2740
- f_kw: f_label arg_value
2741
- {
2742
- @current_arg_stack.set(nil)
2743
- result = @builder.kwoptarg(val[0], val[1])
2744
- }
2745
- | f_label
2746
- {
2747
- @current_arg_stack.set(nil)
2748
- result = @builder.kwarg(val[0])
2749
- }
2750
-
2751
- f_block_kw: f_label primary_value
2752
- {
2753
- result = @builder.kwoptarg(val[0], val[1])
2754
- }
2755
- | f_label
2756
- {
2757
- result = @builder.kwarg(val[0])
2758
- }
2759
-
2760
- f_block_kwarg: f_block_kw
2761
- {
2762
- result = [ val[0] ]
2763
- }
2764
- | f_block_kwarg tCOMMA f_block_kw
2765
- {
2766
- result = val[0] << val[2]
2767
- }
2768
-
2769
- f_kwarg: f_kw
2770
- {
2771
- result = [ val[0] ]
2772
- }
2773
- | f_kwarg tCOMMA f_kw
2774
- {
2775
- result = val[0] << val[2]
2776
- }
2777
-
2778
- kwrest_mark: tPOW | tDSTAR
2779
-
2780
- f_no_kwarg: kwrest_mark kNIL
2781
- {
2782
- result = [ @builder.kwnilarg(val[0], val[1]) ]
2783
- }
2784
-
2785
- f_kwrest: kwrest_mark tIDENTIFIER
2786
- {
2787
- @static_env.declare val[1][0]
2788
-
2789
- result = [ @builder.kwrestarg(val[0], val[1]) ]
2790
- }
2791
- | kwrest_mark
2792
- {
2793
- result = [ @builder.kwrestarg(val[0]) ]
2794
- }
2795
-
2796
- f_opt: f_arg_asgn tEQL arg_value
2797
- {
2798
- @current_arg_stack.set(0)
2799
- result = @builder.optarg(val[0], val[1], val[2])
2800
- }
2801
-
2802
- f_block_opt: f_arg_asgn tEQL primary_value
2803
- {
2804
- @current_arg_stack.set(0)
2805
- result = @builder.optarg(val[0], val[1], val[2])
2806
- }
2807
-
2808
- f_block_optarg: f_block_opt
2809
- {
2810
- result = [ val[0] ]
2811
- }
2812
- | f_block_optarg tCOMMA f_block_opt
2813
- {
2814
- result = val[0] << val[2]
2815
- }
2816
-
2817
- f_optarg: f_opt
2818
- {
2819
- result = [ val[0] ]
2820
- }
2821
- | f_optarg tCOMMA f_opt
2822
- {
2823
- result = val[0] << val[2]
2824
- }
2825
-
2826
- restarg_mark: tSTAR2 | tSTAR
2827
-
2828
- f_rest_arg: restarg_mark tIDENTIFIER
2829
- {
2830
- @static_env.declare val[1][0]
2831
-
2832
- result = [ @builder.restarg(val[0], val[1]) ]
2833
- }
2834
- | restarg_mark
2835
- {
2836
- result = [ @builder.restarg(val[0]) ]
2837
- }
2838
-
2839
- blkarg_mark: tAMPER2 | tAMPER
2840
-
2841
- f_block_arg: blkarg_mark tIDENTIFIER
2842
- {
2843
- @static_env.declare val[1][0]
2844
-
2845
- result = @builder.blockarg(val[0], val[1])
2846
- }
2847
-
2848
- opt_f_block_arg: tCOMMA f_block_arg
2849
- {
2850
- result = [ val[1] ]
2851
- }
2852
- |
2853
- {
2854
- result = []
2855
- }
2856
-
2857
- singleton: var_ref
2858
- | tLPAREN2 expr rparen
2859
- {
2860
- result = val[1]
2861
- }
2862
-
2863
- assoc_list: # nothing
2864
- {
2865
- result = []
2866
- }
2867
- | assocs trailer
2868
-
2869
- assocs: assoc
2870
- {
2871
- result = [ val[0] ]
2872
- }
2873
- | assocs tCOMMA assoc
2874
- {
2875
- result = val[0] << val[2]
2876
- }
2877
-
2878
- assoc: arg_value tASSOC arg_value
2879
- {
2880
- result = @builder.pair(val[0], val[1], val[2])
2881
- }
2882
- | tLABEL arg_value
2883
- {
2884
- result = @builder.pair_keyword(val[0], val[1])
2885
- }
2886
- | tSTRING_BEG string_contents tLABEL_END arg_value
2887
- {
2888
- result = @builder.pair_quoted(val[0], val[1], val[2], val[3])
2889
- }
2890
- | tDSTAR arg_value
2891
- {
2892
- result = @builder.kwsplat(val[0], val[1])
2893
- }
2894
-
2895
- operation: tIDENTIFIER | tCONSTANT | tFID
2896
- operation2: tIDENTIFIER | tCONSTANT | tFID | op
2897
- operation3: tIDENTIFIER | tFID | op
2898
- dot_or_colon: call_op | tCOLON2
2899
- call_op: tDOT
2900
- {
2901
- result = [:dot, val[0][1]]
2902
- }
2903
- | tANDDOT
2904
- {
2905
- result = [:anddot, val[0][1]]
2906
- }
2907
- opt_terms: | terms
2908
- opt_nl: | tNL
2909
- rparen: opt_nl tRPAREN
2910
- {
2911
- result = val[1]
2912
- }
2913
- rbracket: opt_nl tRBRACK
2914
- {
2915
- result = val[1]
2916
- }
2917
- rbrace: opt_nl tRCURLY
2918
- {
2919
- result = val[1]
2920
- }
2921
- trailer: | tNL | tCOMMA
2922
-
2923
- term: tSEMI
2924
- {
2925
- yyerrok
2926
- }
2927
- | tNL
2928
-
2929
- terms: term
2930
- | terms tSEMI
2931
-
2932
- none: # nothing
2933
- {
2934
- result = nil
2935
- }
2936
- end
2937
-
2938
- ---- header
2939
-
2940
- require 'parser'
2941
-
2942
- ---- inner
2943
-
2944
- def version
2945
- 27
2946
- end
2947
-
2948
- def default_encoding
2949
- Encoding::UTF_8
2950
- end