parser 2.7.1.4 → 3.0.1.1

Sign up to get free protection for your applications and to get access to all the features.
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