ruby_parser 3.0.0 → 3.19.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 (58) hide show
  1. checksums.yaml +7 -0
  2. checksums.yaml.gz.sig +0 -0
  3. data/.autotest +36 -19
  4. data/History.rdoc +1297 -0
  5. data/Manifest.txt +35 -7
  6. data/{README.txt → README.rdoc} +44 -14
  7. data/Rakefile +308 -110
  8. data/bin/ruby_parse +3 -1
  9. data/bin/ruby_parse_extract_error +36 -16
  10. data/compare/normalize.rb +218 -0
  11. data/debugging.md +190 -0
  12. data/gauntlet.md +107 -0
  13. data/lib/.document +1 -0
  14. data/lib/rp_extensions.rb +53 -0
  15. data/lib/rp_stringscanner.rb +33 -0
  16. data/lib/ruby20_parser.rb +10973 -0
  17. data/lib/ruby20_parser.y +2683 -0
  18. data/lib/ruby21_parser.rb +10980 -0
  19. data/lib/ruby21_parser.y +2700 -0
  20. data/lib/ruby22_parser.rb +11123 -0
  21. data/lib/ruby22_parser.y +2711 -0
  22. data/lib/ruby23_parser.rb +11132 -0
  23. data/lib/ruby23_parser.y +2713 -0
  24. data/lib/ruby24_parser.rb +11231 -0
  25. data/lib/ruby24_parser.y +2721 -0
  26. data/lib/ruby25_parser.rb +11231 -0
  27. data/lib/ruby25_parser.y +2721 -0
  28. data/lib/ruby26_parser.rb +11253 -0
  29. data/lib/ruby26_parser.y +2736 -0
  30. data/lib/ruby27_parser.rb +12980 -0
  31. data/lib/ruby27_parser.y +3324 -0
  32. data/lib/ruby30_parser.rb +13242 -0
  33. data/lib/ruby30_parser.y +3447 -0
  34. data/lib/ruby31_parser.rb +13622 -0
  35. data/lib/ruby31_parser.y +3481 -0
  36. data/lib/ruby3_parser.yy +3536 -0
  37. data/lib/ruby_lexer.rb +933 -1232
  38. data/lib/ruby_lexer.rex +185 -0
  39. data/lib/ruby_lexer.rex.rb +399 -0
  40. data/lib/ruby_lexer_strings.rb +638 -0
  41. data/lib/ruby_parser.rb +97 -3
  42. data/lib/ruby_parser.yy +3465 -0
  43. data/lib/ruby_parser_extras.rb +1216 -687
  44. data/test/test_ruby_lexer.rb +2249 -1092
  45. data/test/test_ruby_parser.rb +5156 -975
  46. data/test/test_ruby_parser_extras.rb +47 -77
  47. data/tools/munge.rb +250 -0
  48. data/tools/ripper.rb +44 -0
  49. data.tar.gz.sig +1 -1
  50. metadata +200 -155
  51. metadata.gz.sig +0 -0
  52. data/.gemtest +0 -0
  53. data/History.txt +0 -482
  54. data/lib/gauntlet_rubyparser.rb +0 -120
  55. data/lib/ruby18_parser.rb +0 -5747
  56. data/lib/ruby18_parser.y +0 -1873
  57. data/lib/ruby19_parser.rb +0 -6110
  58. data/lib/ruby19_parser.y +0 -2078
data/lib/ruby19_parser.y DELETED
@@ -1,2078 +0,0 @@
1
- # -*- racc -*-
2
-
3
- class Ruby19Parser
4
-
5
- token kCLASS kMODULE kDEF kUNDEF kBEGIN kRESCUE kENSURE kEND kIF kUNLESS
6
- kTHEN kELSIF kELSE kCASE kWHEN kWHILE kUNTIL kFOR kBREAK kNEXT
7
- kREDO kRETRY kIN kDO kDO_COND kDO_BLOCK kDO_LAMBDA kRETURN kYIELD kSUPER
8
- kSELF kNIL kTRUE kFALSE kAND kOR kNOT kIF_MOD kUNLESS_MOD kWHILE_MOD
9
- kUNTIL_MOD kRESCUE_MOD kALIAS kDEFINED klBEGIN klEND k__LINE__
10
- k__FILE__ k__ENCODING__ tIDENTIFIER tFID tGVAR tIVAR tCONSTANT
11
- tLABEL tCVAR tNTH_REF tBACK_REF tSTRING_CONTENT tINTEGER tFLOAT
12
- tREGEXP_END tUPLUS tUMINUS tUMINUS_NUM tPOW tCMP tEQ tEQQ tNEQ
13
- tGEQ tLEQ tANDOP tOROP tMATCH tNMATCH tDOT tDOT2 tDOT3 tAREF
14
- tASET tLSHFT tRSHFT tCOLON2 tCOLON3 tOP_ASGN tASSOC tLPAREN
15
- tLPAREN2 tRPAREN tLPAREN_ARG tLBRACK tLBRACK2 tRBRACK tLBRACE
16
- tLBRACE_ARG tSTAR tSTAR2 tAMPER tAMPER2 tTILDE tPERCENT tDIVIDE
17
- tPLUS tMINUS tLT tGT tPIPE tBANG tCARET tLCURLY tRCURLY
18
- tBACK_REF2 tSYMBEG tSTRING_BEG tXSTRING_BEG tREGEXP_BEG
19
- tWORDS_BEG tQWORDS_BEG tSTRING_DBEG tSTRING_DVAR tSTRING_END
20
- tSTRING tSYMBOL tNL tEH tCOLON tCOMMA tSPACE tSEMI tLAST_TOKEN
21
- tLAMBDA tLAMBEG
22
-
23
- prechigh
24
- right tBANG tTILDE tUPLUS
25
- right tPOW
26
- right tUMINUS_NUM tUMINUS
27
- left tSTAR2 tDIVIDE tPERCENT
28
- left tPLUS tMINUS
29
- left tLSHFT tRSHFT
30
- left tAMPER2
31
- left tPIPE tCARET
32
- left tGT tGEQ tLT tLEQ
33
- nonassoc tCMP tEQ tEQQ tNEQ tMATCH tNMATCH
34
- left tANDOP
35
- left tOROP
36
- nonassoc tDOT2 tDOT3
37
- right tEH tCOLON
38
- left kRESCUE_MOD
39
- right tEQL tOP_ASGN
40
- nonassoc kDEFINED
41
- right kNOT
42
- left kOR kAND
43
- nonassoc kIF_MOD kUNLESS_MOD kWHILE_MOD kUNTIL_MOD
44
- nonassoc tLBRACE_ARG
45
- nonassoc tLOWEST
46
- preclow
47
-
48
- rule
49
-
50
- program: {
51
- self.lexer.lex_state = :expr_beg
52
- }
53
- top_compstmt
54
- {
55
- result = new_compstmt val
56
- }
57
-
58
- top_compstmt: top_stmts opt_terms
59
- {
60
- result = val[0]
61
- }
62
-
63
- top_stmts: none
64
- | top_stmt
65
- | top_stmts terms top_stmt
66
- {
67
- result = self.block_append val[0], val[2]
68
- }
69
- | error top_stmt
70
-
71
- top_stmt: stmt
72
- | klBEGIN
73
- {
74
- if (self.in_def || self.in_single > 0) then
75
- yyerror "BEGIN in method"
76
- end
77
- self.env.extend
78
- }
79
- tLCURLY top_compstmt tRCURLY
80
- {
81
- result = new_iter s(:preexe), nil, val[3] # TODO: add test?
82
- result = nil # TODO: since it isn't supposed to go in the AST
83
- }
84
-
85
- bodystmt: compstmt opt_rescue opt_else opt_ensure
86
- {
87
- result = new_body val
88
- }
89
-
90
- compstmt: stmts opt_terms
91
- {
92
- result = new_compstmt val
93
- }
94
-
95
- stmts: none
96
- | stmt
97
- | stmts terms stmt
98
- {
99
- result = self.block_append val[0], val[2]
100
- }
101
- | error stmt
102
- {
103
- result = val[1]
104
- }
105
-
106
- stmt: kALIAS fitem
107
- {
108
- lexer.lex_state = :expr_fname
109
- result = self.lexer.lineno
110
- }
111
- fitem
112
- {
113
- result = s(:alias, val[1], val[3]).line(val[2])
114
- }
115
- | kALIAS tGVAR tGVAR
116
- {
117
- result = s(:valias, val[1].to_sym, val[2].to_sym)
118
- }
119
- | kALIAS tGVAR tBACK_REF
120
- {
121
- result = s(:valias, val[1].to_sym, :"$#{val[2]}")
122
- }
123
- | kALIAS tGVAR tNTH_REF
124
- {
125
- yyerror "can't make alias for the number variables"
126
- }
127
- | kUNDEF undef_list
128
- {
129
- result = val[1]
130
- }
131
- | stmt kIF_MOD expr_value
132
- {
133
- result = new_if val[2], val[0], nil
134
- }
135
- | stmt kUNLESS_MOD expr_value
136
- {
137
- result = new_if val[2], nil, val[0]
138
- }
139
- | stmt kWHILE_MOD expr_value
140
- {
141
- result = new_while val[0], val[2], true
142
- }
143
- | stmt kUNTIL_MOD expr_value
144
- {
145
- result = new_until val[0], val[2], true
146
- }
147
- | stmt kRESCUE_MOD stmt
148
- {
149
- result = s(:rescue, val[0], new_resbody(s(:array), val[2]))
150
- }
151
- | klEND tLCURLY compstmt tRCURLY
152
- {
153
- if (self.in_def || self.in_single > 0) then
154
- yyerror "END in method; use at_exit"
155
- end
156
- result = new_iter s(:postexe), nil, val[2]
157
- }
158
- | command_asgn
159
- | mlhs tEQL command_call
160
- {
161
- result = new_masgn val[0], val[2], :wrap
162
- }
163
- | var_lhs tOP_ASGN command_call
164
- {
165
- result = new_op_asgn val
166
- }
167
- | primary_value tLBRACK2 opt_call_args rbracket tOP_ASGN command_call
168
- {
169
- result = s(:op_asgn1, val[0], val[2], val[4].to_sym, val[5])
170
- }
171
- | primary_value tDOT tIDENTIFIER tOP_ASGN command_call
172
- {
173
- result = s(:op_asgn, val[0], val[4], val[2], val[3])
174
- }
175
- | primary_value tDOT tCONSTANT tOP_ASGN command_call
176
- {
177
- result = s(:op_asgn, val[0], val[4], val[2], val[3])
178
- }
179
- | primary_value tCOLON2 tCONSTANT tOP_ASGN command_call
180
- {
181
- result = s(:op_asgn, val[0], val[4], val[2], val[3])
182
- }
183
- | primary_value tCOLON2 tIDENTIFIER tOP_ASGN command_call
184
- {
185
- result = s(:op_asgn, val[0], val[4], val[2], val[3])
186
- }
187
- | backref tOP_ASGN command_call
188
- {
189
- self.backref_assign_error val[0]
190
- }
191
- | lhs tEQL mrhs
192
- {
193
- result = self.node_assign val[0], s(:svalue, val[2])
194
- }
195
- | mlhs tEQL arg_value
196
- {
197
- result = new_masgn val[0], val[2], :wrap
198
- }
199
- | mlhs tEQL mrhs
200
- {
201
- result = new_masgn val[0], val[2]
202
- }
203
- | expr
204
-
205
- command_asgn: lhs tEQL command_call
206
- {
207
- result = self.node_assign val[0], val[2]
208
- }
209
- | lhs tEQL command_asgn
210
- {
211
- result = self.node_assign val[0], val[2]
212
- }
213
-
214
- expr: command_call
215
- | expr kAND expr
216
- {
217
- result = logop(:and, val[0], val[2])
218
- }
219
- | expr kOR expr
220
- {
221
- result = logop(:or, val[0], val[2])
222
- }
223
- | kNOT opt_nl expr
224
- {
225
- result = s(:call, val[2], :"!")
226
- }
227
- | tBANG command_call
228
- {
229
- result = s(:call, val[1], :"!")
230
- }
231
- | arg
232
-
233
- expr_value: expr
234
- {
235
- result = value_expr(val[0])
236
- }
237
-
238
- command_call: command
239
- | block_command
240
-
241
- block_command: block_call
242
- | block_call tDOT operation2 command_args # TODO: dot_or_colon
243
- {
244
- result = new_call val[0], val[2], val[3]
245
- }
246
- | block_call tCOLON2 operation2 command_args
247
- {
248
- result = new_call val[0], val[2], val[3]
249
- }
250
-
251
- cmd_brace_block: tLBRACE_ARG
252
- {
253
- self.env.extend(:dynamic)
254
- result = self.lexer.lineno
255
- }
256
- opt_block_param
257
- {
258
- result = self.env.dynamic.keys
259
- }
260
- compstmt tRCURLY
261
- {
262
- result = new_iter nil, val[2], val[4]
263
- result.line = val[1]
264
-
265
- self.env.unextend
266
- }
267
-
268
- command: operation command_args =tLOWEST
269
- {
270
- result = new_call nil, val[0].to_sym, val[1]
271
- }
272
- | operation command_args cmd_brace_block
273
- {
274
- result = new_call nil, val[0].to_sym, val[1]
275
- if val[2] then
276
- block_dup_check result, val[2]
277
-
278
- result, operation = val[2], result
279
- result.insert 1, operation
280
- end
281
- }
282
- | primary_value tDOT operation2 command_args =tLOWEST
283
- {
284
- result = new_call val[0], val[2].to_sym, val[3]
285
- }
286
- | primary_value tDOT operation2 command_args cmd_brace_block
287
- {
288
- recv, _, msg, args, block = val
289
- call = new_call recv, msg.to_sym, args
290
-
291
- block_dup_check call, block
292
-
293
- block.insert 1, call
294
- result = block
295
- }
296
- | primary_value tCOLON2 operation2 command_args =tLOWEST
297
- {
298
- result = new_call val[0], val[2].to_sym, val[3]
299
- }
300
- | primary_value tCOLON2 operation2 command_args cmd_brace_block
301
- {
302
- recv, _, msg, args, block = val
303
- call = new_call recv, msg.to_sym, args
304
-
305
- block_dup_check call, block
306
-
307
- block.insert 1, call
308
- result = block
309
- }
310
- | kSUPER command_args
311
- {
312
- result = new_super val[1]
313
- }
314
- | kYIELD command_args
315
- {
316
- result = new_yield val[1]
317
- }
318
- | kRETURN call_args
319
- {
320
- line = val[0].last
321
- result = s(:return, ret_args(val[1])).line(line)
322
- }
323
- | kBREAK call_args
324
- {
325
- line = val[0].last
326
- result = s(:break, ret_args(val[1])).line(line)
327
- }
328
- | kNEXT call_args
329
- {
330
- line = val[0].last
331
- result = s(:next, ret_args(val[1])).line(line)
332
- }
333
-
334
- mlhs: mlhs_basic
335
- | tLPAREN mlhs_inner rparen
336
- {
337
- result = val[1]
338
- }
339
-
340
- mlhs_inner: mlhs_basic
341
- | tLPAREN mlhs_inner rparen
342
- {
343
- result = s(:masgn, s(:array, val[1]))
344
- }
345
-
346
- mlhs_basic: mlhs_head
347
- {
348
- result = s(:masgn, val[0])
349
- }
350
- | mlhs_head mlhs_item
351
- {
352
- result = s(:masgn, val[0] << val[1].compact)
353
- }
354
- | mlhs_head tSTAR mlhs_node
355
- {
356
- result = s(:masgn, val[0] << s(:splat, val[2]))
357
- }
358
- | mlhs_head tSTAR mlhs_node tCOMMA mlhs_post
359
- {
360
- ary = list_append val[0], s(:splat, val[2])
361
- ary.concat val[4][1..-1]
362
- result = s(:masgn, ary)
363
- }
364
- | mlhs_head tSTAR
365
- {
366
- result = s(:masgn, val[0] << s(:splat))
367
- }
368
- | mlhs_head tSTAR tCOMMA mlhs_post
369
- {
370
- ary = list_append val[0], s(:splat)
371
- ary.concat val[3][1..-1]
372
- result = s(:masgn, ary)
373
- }
374
- | tSTAR mlhs_node
375
- {
376
- result = s(:masgn, s(:array, s(:splat, val[1])))
377
- }
378
- | tSTAR mlhs_node tCOMMA mlhs_post
379
- {
380
- ary = s(:array, s(:splat, val[1]))
381
- ary.concat val[3][1..-1]
382
- result = s(:masgn, ary)
383
- }
384
- | tSTAR
385
- {
386
- result = s(:masgn, s(:array, s(:splat)))
387
- }
388
- | tSTAR tCOMMA mlhs_post
389
- {
390
- ary = s(:array, s(:splat))
391
- ary.concat val[2][1..-1]
392
- result = s(:masgn, ary)
393
- }
394
-
395
- mlhs_item: mlhs_node
396
- | tLPAREN mlhs_inner rparen
397
- {
398
- result = val[1]
399
- }
400
-
401
- mlhs_head: mlhs_item tCOMMA
402
- {
403
- result = s(:array, val[0])
404
- }
405
- | mlhs_head mlhs_item tCOMMA
406
- {
407
- result = val[0] << val[1].compact
408
- }
409
-
410
- mlhs_post: mlhs_item
411
- {
412
- result = s(:array, val[0])
413
- }
414
- | mlhs_post tCOMMA mlhs_item
415
- {
416
- result = list_append val[0], val[2]
417
- }
418
-
419
- mlhs_node: user_variable
420
- {
421
- result = self.assignable val[0]
422
- }
423
- | keyword_variable
424
- {
425
- result = self.assignable val[0]
426
- }
427
- | primary_value tLBRACK2 opt_call_args rbracket
428
- {
429
- result = self.aryset val[0], val[2]
430
- }
431
- | primary_value tDOT tIDENTIFIER
432
- {
433
- result = s(:attrasgn, val[0], :"#{val[2]}=")
434
- }
435
- | primary_value tCOLON2 tIDENTIFIER
436
- {
437
- result = s(:attrasgn, val[0], :"#{val[2]}=")
438
- }
439
- | primary_value tDOT tCONSTANT
440
- {
441
- result = s(:attrasgn, val[0], :"#{val[2]}=")
442
- }
443
- | primary_value tCOLON2 tCONSTANT
444
- {
445
- if (self.in_def || self.in_single > 0) then
446
- yyerror "dynamic constant assignment"
447
- end
448
-
449
- result = s(:const, s(:colon2, val[0], val[2].to_sym), nil)
450
- }
451
- | tCOLON3 tCONSTANT
452
- {
453
- if (self.in_def || self.in_single > 0) then
454
- yyerror "dynamic constant assignment"
455
- end
456
-
457
- result = s(:const, nil, s(:colon3, val[1].to_sym))
458
- }
459
- | backref
460
- {
461
- self.backref_assign_error val[0]
462
- }
463
-
464
- lhs: user_variable
465
- {
466
- result = self.assignable val[0]
467
- }
468
- | keyword_variable
469
- {
470
- result = self.assignable val[0]
471
- }
472
- | primary_value tLBRACK2 opt_call_args rbracket
473
- {
474
- result = self.aryset val[0], val[2]
475
- }
476
- | primary_value tDOT tIDENTIFIER
477
- {
478
- result = s(:attrasgn, val[0], :"#{val[2]}=")
479
- }
480
- | primary_value tCOLON2 tIDENTIFIER
481
- {
482
- result = s(:attrasgn, val[0], :"#{val[2]}=")
483
- }
484
- | primary_value tDOT tCONSTANT
485
- {
486
- result = s(:attrasgn, val[0], :"#{val[2]}=")
487
- }
488
- | primary_value tCOLON2 tCONSTANT
489
- {
490
- if (self.in_def || self.in_single > 0) then
491
- yyerror "dynamic constant assignment"
492
- end
493
-
494
- result = s(:const, s(:colon2, val[0], val[2].to_sym))
495
- }
496
- | tCOLON3 tCONSTANT
497
- {
498
- if (self.in_def || self.in_single > 0) then
499
- yyerror "dynamic constant assignment"
500
- end
501
-
502
- result = s(:const, s(:colon3, val[1].to_sym))
503
- }
504
- | backref
505
- {
506
- self.backref_assign_error val[0]
507
- }
508
-
509
- cname: tIDENTIFIER
510
- {
511
- yyerror "class/module name must be CONSTANT"
512
- }
513
- | tCONSTANT
514
-
515
- cpath: tCOLON3 cname
516
- {
517
- result = s(:colon3, val[1].to_sym)
518
- }
519
- | cname
520
- {
521
- result = val[0].to_sym
522
- }
523
- | primary_value tCOLON2 cname
524
- {
525
- result = s(:colon2, val[0], val[2].to_sym)
526
- }
527
-
528
- fname: tIDENTIFIER | tCONSTANT | tFID
529
- | op
530
- {
531
- lexer.lex_state = :expr_end
532
- result = val[0]
533
- }
534
-
535
- | reswords
536
- {
537
- lexer.lex_state = :expr_end
538
- result = val[0]
539
- }
540
-
541
- fsym: fname | symbol
542
-
543
- fitem: fsym { result = s(:lit, val[0].to_sym) }
544
- | dsym
545
-
546
- undef_list: fitem
547
- {
548
- result = new_undef val[0]
549
- }
550
- |
551
- undef_list tCOMMA
552
- {
553
- lexer.lex_state = :expr_fname
554
- }
555
- fitem
556
- {
557
- result = new_undef val[0], val[3]
558
- }
559
-
560
- op: tPIPE | tCARET | tAMPER2 | tCMP | tEQ | tEQQ
561
- | tMATCH | tNMATCH | tGT | tGEQ | tLT | tLEQ
562
- | tNEQ | tLSHFT | tRSHFT | tPLUS | tMINUS | tSTAR2
563
- | tSTAR | tDIVIDE | tPERCENT | tPOW | tBANG | tTILDE
564
- | tUPLUS | tUMINUS | tAREF | tASET | tBACK_REF2
565
-
566
- reswords: k__LINE__ | k__FILE__ | k__ENCODING__ | klBEGIN | klEND
567
- | kALIAS | kAND | kBEGIN | kBREAK | kCASE
568
- | kCLASS | kDEF | kDEFINED | kDO | kELSE
569
- | kELSIF | kEND | kENSURE | kFALSE | kFOR
570
- | kIN | kMODULE | kNEXT | kNIL | kNOT
571
- | kOR | kREDO | kRESCUE | kRETRY | kRETURN
572
- | kSELF | kSUPER | kTHEN | kTRUE | kUNDEF
573
- | kWHEN | kYIELD | kIF | kUNLESS | kWHILE
574
- | kUNTIL
575
-
576
- arg: lhs tEQL arg
577
- {
578
- result = self.node_assign val[0], val[2]
579
- }
580
- | lhs tEQL arg kRESCUE_MOD arg
581
- {
582
- result = self.node_assign val[0], s(:rescue, val[2], new_resbody(s(:array), val[4]))
583
- }
584
- | var_lhs tOP_ASGN arg
585
- {
586
- result = new_op_asgn val
587
- }
588
- | var_lhs tOP_ASGN arg kRESCUE_MOD arg
589
- {
590
- result = new_op_asgn val
591
- result = s(:rescue, result, new_resbody(s(:array), val[4]))
592
- }
593
- | primary_value tLBRACK2 opt_call_args rbracket tOP_ASGN arg
594
- {
595
- val[2][0] = :arglist
596
- result = s(:op_asgn1, val[0], val[2], val[4].to_sym, val[5])
597
- }
598
- | primary_value tDOT tIDENTIFIER tOP_ASGN arg
599
- {
600
- result = s(:op_asgn2, val[0], :"#{val[2]}=", val[3].to_sym, val[4])
601
- }
602
- | primary_value tDOT tCONSTANT tOP_ASGN arg
603
- {
604
- result = s(:op_asgn2, val[0], :"#{val[2]}=", val[3].to_sym, val[4])
605
- }
606
- | primary_value tCOLON2 tIDENTIFIER tOP_ASGN arg
607
- {
608
- result = s(:op_asgn, val[0], val[4], val[2], val[3])
609
- }
610
- | primary_value tCOLON2 tCONSTANT tOP_ASGN arg
611
-
612
- {
613
- yyerror "constant re-assignment"
614
- }
615
- | tCOLON3 tCONSTANT tOP_ASGN arg
616
- {
617
- yyerror "constant re-assignment"
618
- }
619
- | backref tOP_ASGN arg
620
- {
621
- self.backref_assign_error val[0]
622
- }
623
- | arg tDOT2 arg
624
- {
625
- v1, v2 = val[0], val[2]
626
- if v1.node_type == :lit and v2.node_type == :lit and Fixnum === v1.last and Fixnum === v2.last then
627
- result = s(:lit, (v1.last)..(v2.last))
628
- else
629
- result = s(:dot2, v1, v2)
630
- end
631
- }
632
- | arg tDOT3 arg
633
- {
634
- v1, v2 = val[0], val[2]
635
- if v1.node_type == :lit and v2.node_type == :lit and Fixnum === v1.last and Fixnum === v2.last then
636
- result = s(:lit, (v1.last)...(v2.last))
637
- else
638
- result = s(:dot3, v1, v2)
639
- end
640
- }
641
- | arg tPLUS arg
642
- {
643
- result = new_call val[0], :+, argl(val[2])
644
- }
645
- | arg tMINUS arg
646
- {
647
- result = new_call val[0], :-, argl(val[2])
648
- }
649
- | arg tSTAR2 arg
650
- {
651
- result = new_call val[0], :*, argl(val[2])
652
- }
653
- | arg tDIVIDE arg
654
- {
655
- result = new_call val[0], :"/", argl(val[2])
656
- }
657
- | arg tPERCENT arg
658
- {
659
- result = new_call val[0], :"%", argl(val[2])
660
- }
661
- | arg tPOW arg
662
- {
663
- result = new_call val[0], :**, argl(val[2])
664
- }
665
- | tUMINUS_NUM tINTEGER tPOW arg
666
- {
667
- result = new_call(new_call(s(:lit, val[1]), :"**", argl(val[3])), :"-@")
668
- }
669
- | tUMINUS_NUM tFLOAT tPOW arg
670
- {
671
- result = new_call(new_call(s(:lit, val[1]), :"**", argl(val[3])), :"-@")
672
- }
673
- | tUPLUS arg
674
- {
675
- if val[1][0] == :lit then
676
- result = val[1]
677
- else
678
- result = new_call val[1], :"+@"
679
- end
680
- }
681
- | tUMINUS arg
682
- {
683
- result = new_call val[1], :"-@"
684
- }
685
- | arg tPIPE arg
686
- {
687
- result = new_call val[0], :"|", argl(val[2])
688
- }
689
- | arg tCARET arg
690
- {
691
- result = new_call val[0], :"^", argl(val[2])
692
- }
693
- | arg tAMPER2 arg
694
- {
695
- result = new_call val[0], :"&", argl(val[2])
696
- }
697
- | arg tCMP arg
698
- {
699
- result = new_call val[0], :"<=>", argl(val[2])
700
- }
701
- | arg tGT arg
702
- {
703
- result = new_call val[0], :">", argl(val[2])
704
- }
705
- | arg tGEQ arg
706
- {
707
- result = new_call val[0], :">=", argl(val[2])
708
- }
709
- | arg tLT arg
710
- {
711
- result = new_call val[0], :"<", argl(val[2])
712
- }
713
- | arg tLEQ arg
714
- {
715
- result = new_call val[0], :"<=", argl(val[2])
716
- }
717
- | arg tEQ arg
718
- {
719
- result = new_call val[0], :"==", argl(val[2])
720
- }
721
- | arg tEQQ arg
722
- {
723
- result = new_call val[0], :"===", argl(val[2])
724
- }
725
- | arg tNEQ arg
726
- {
727
- result = new_call val[0], :"!=", argl(val[2])
728
- }
729
- | arg tMATCH arg
730
- {
731
- result = self.get_match_node val[0], val[2]
732
- }
733
- | arg tNMATCH arg
734
- {
735
- result = s(:not, self.get_match_node(val[0], val[2]))
736
- }
737
- | tBANG arg
738
- {
739
- result = new_call val[1], :"!"
740
- }
741
- | tTILDE arg
742
- {
743
- val[2] = value_expr val[2]
744
- result = new_call val[1], :"~"
745
- }
746
- | arg tLSHFT arg
747
- {
748
- val[0] = value_expr val[0]
749
- val[2] = value_expr val[2]
750
- result = new_call val[0], :"\<\<", argl(val[2])
751
- }
752
- | arg tRSHFT arg
753
- {
754
- val[0] = value_expr val[0]
755
- val[2] = value_expr val[2]
756
- result = new_call val[0], :">>", argl(val[2])
757
- }
758
- | arg tANDOP arg
759
- {
760
- result = logop(:and, val[0], val[2])
761
- }
762
- | arg tOROP arg
763
- {
764
- result = logop(:or, val[0], val[2])
765
- }
766
- | kDEFINED opt_nl arg
767
- {
768
- result = s(:defined, val[2])
769
- }
770
- | arg tEH arg opt_nl tCOLON arg
771
- {
772
- lexer.tern.pop
773
- result = s(:if, val[0], val[2], val[5])
774
- }
775
- | primary
776
-
777
- arg_value: arg
778
- {
779
- result = value_expr(val[0])
780
- }
781
-
782
- aref_args: none
783
- | args trailer
784
- {
785
- result = val[0]
786
- }
787
- | args tCOMMA assocs trailer
788
- {
789
- result = val[0] << s(:hash, *val[2].values)
790
- }
791
- | assocs trailer
792
- {
793
- result = s(:array, s(:hash, *val[0].values))
794
- }
795
-
796
- paren_args: tLPAREN2 opt_call_args rparen
797
- {
798
- result = val[1]
799
- }
800
-
801
- opt_paren_args: none
802
- | paren_args
803
-
804
- opt_call_args: none
805
- {
806
- result = val[0]
807
- }
808
- | call_args
809
- {
810
- result = val[0]
811
- }
812
- | args tCOMMA
813
- {
814
- result = val[0]
815
- }
816
- | args tCOMMA assocs tCOMMA
817
- {
818
- result = val[0] << s(:hash, *val[2][1..-1])
819
- }
820
- | assocs tCOMMA
821
- {
822
- result = val[0]
823
- }
824
-
825
- call_args: command
826
- {
827
- warning "parenthesize argument(s) for future version"
828
- result = s(:array, val[0])
829
- }
830
- | args opt_block_arg
831
- {
832
- result = self.arg_blk_pass val[0], val[1]
833
- }
834
- | assocs opt_block_arg
835
- {
836
- result = s(:array, s(:hash, *val[0].values))
837
- result = self.arg_blk_pass result, val[1]
838
- }
839
- | args tCOMMA assocs opt_block_arg
840
- {
841
- result = val[0] << s(:hash, *val[2].values)
842
- result = self.arg_blk_pass result, val[3]
843
- }
844
- | block_arg
845
-
846
- command_args: {
847
- result = lexer.cmdarg.stack.dup # TODO: smell?
848
- lexer.cmdarg.push true
849
- }
850
- call_args
851
- {
852
- lexer.cmdarg.stack.replace val[0]
853
- result = val[1]
854
- }
855
-
856
- block_arg: tAMPER arg_value
857
- {
858
- result = s(:block_pass, val[1])
859
- }
860
-
861
- opt_block_arg: tCOMMA block_arg
862
- {
863
- result = val[1]
864
- }
865
- | none
866
-
867
- args: arg_value
868
- {
869
- result = s(:array, val[0])
870
- }
871
- | tSTAR arg_value
872
- {
873
- result = s(:array, s(:splat, val[1]))
874
- }
875
- | args tCOMMA arg_value
876
- {
877
- result = self.list_append val[0], val[2]
878
- }
879
- | args tCOMMA tSTAR arg_value
880
- {
881
- result = self.list_append val[0], s(:splat, val[3])
882
- }
883
-
884
- mrhs: args tCOMMA arg_value
885
- {
886
- result = val[0] << val[2]
887
- }
888
- | args tCOMMA tSTAR arg_value
889
- {
890
- result = self.arg_concat val[0], val[3]
891
- }
892
- | tSTAR arg_value
893
- {
894
- result = s(:splat, val[1])
895
- }
896
-
897
- primary: literal
898
- | strings
899
- | xstring
900
- | regexp
901
- | words
902
- | qwords
903
- | var_ref
904
- | backref
905
- | tFID
906
- {
907
- result = new_call nil, val[0].to_sym
908
- }
909
- | kBEGIN
910
- {
911
- result = self.lexer.lineno
912
- }
913
- bodystmt kEND
914
- {
915
- unless val[2] then
916
- result = s(:nil)
917
- else
918
- result = s(:begin, val[2])
919
- end
920
-
921
- result.line = val[1]
922
- }
923
- | tLPAREN_ARG expr
924
- {
925
- lexer.lex_state = :expr_endarg
926
- }
927
- rparen
928
- {
929
- warning "(...) interpreted as grouped expression"
930
- result = val[1]
931
- }
932
- | tLPAREN compstmt tRPAREN
933
- {
934
- result = val[1] || s(:nil)
935
- result.paren = true
936
- }
937
- | primary_value tCOLON2 tCONSTANT
938
- {
939
- result = s(:colon2, val[0], val[2].to_sym)
940
- }
941
- | tCOLON3 tCONSTANT
942
- {
943
- result = s(:colon3, val[1].to_sym)
944
- }
945
- | tLBRACK aref_args tRBRACK
946
- {
947
- result = val[1] || s(:array)
948
- }
949
- | tLBRACE assoc_list tRCURLY
950
- {
951
- result = s(:hash, *val[1].values)
952
- }
953
- | kRETURN
954
- {
955
- result = s(:return)
956
- }
957
- | kYIELD tLPAREN2 call_args rparen
958
- {
959
- result = new_yield val[2]
960
- }
961
- | kYIELD tLPAREN2 rparen
962
- {
963
- result = new_yield
964
- }
965
- | kYIELD
966
- {
967
- result = new_yield
968
- }
969
- | kDEFINED opt_nl tLPAREN2 expr rparen
970
- {
971
- result = s(:defined, val[3])
972
- }
973
- | kNOT tLPAREN2 expr rparen
974
- {
975
- result = s(:call, val[2], :"!")
976
- }
977
- | kNOT tLPAREN2 rparen
978
- {
979
- raise "no3\non#{val.inspect}"
980
- }
981
- | operation brace_block
982
- {
983
- oper, iter = val[0], val[1]
984
- call = new_call nil, oper.to_sym
985
- iter.insert 1, call
986
- result = iter
987
- call.line = iter.line
988
- }
989
- | method_call
990
- | method_call brace_block
991
- {
992
- call, iter = val[0], val[1]
993
- block_dup_check call, iter
994
- iter.insert 1, call # FIX
995
- result = iter
996
- }
997
- | tLAMBDA lambda
998
- {
999
- result = val[1] # TODO: fix lineno
1000
- }
1001
- | kIF expr_value then compstmt if_tail kEND
1002
- {
1003
- result = new_if val[1], val[3], val[4]
1004
- }
1005
- | kUNLESS expr_value then compstmt opt_else kEND
1006
- {
1007
- result = new_if val[1], val[4], val[3]
1008
- }
1009
- | kWHILE
1010
- {
1011
- lexer.cond.push true
1012
- }
1013
- expr_value do
1014
- {
1015
- lexer.cond.pop
1016
- }
1017
- compstmt kEND
1018
- {
1019
- result = new_while val[5], val[2], true
1020
- }
1021
- | kUNTIL
1022
- {
1023
- lexer.cond.push true
1024
- }
1025
- expr_value do
1026
- {
1027
- lexer.cond.pop
1028
- }
1029
- compstmt kEND
1030
- {
1031
- result = new_until val[5], val[2], true
1032
- }
1033
- | kCASE expr_value opt_terms case_body kEND
1034
- {
1035
- result = new_case val[1], val[3]
1036
- }
1037
- | kCASE opt_terms case_body kEND
1038
- {
1039
- result = new_case nil, val[2]
1040
- }
1041
- | kFOR for_var kIN
1042
- {
1043
- lexer.cond.push true
1044
- }
1045
- expr_value do
1046
- {
1047
- lexer.cond.pop
1048
- }
1049
- compstmt kEND
1050
- {
1051
- result = new_for val[4], val[1], val[7]
1052
- }
1053
- | kCLASS
1054
- {
1055
- result = self.lexer.lineno
1056
- }
1057
- cpath superclass
1058
- {
1059
- self.comments.push self.lexer.comments
1060
- if (self.in_def || self.in_single > 0) then
1061
- yyerror "class definition in method body"
1062
- end
1063
- self.env.extend
1064
- }
1065
- bodystmt kEND
1066
- {
1067
- result = new_class val
1068
- self.env.unextend
1069
- }
1070
- | kCLASS tLSHFT
1071
- {
1072
- result = self.lexer.lineno
1073
- }
1074
- expr
1075
- {
1076
- result = self.in_def
1077
- self.in_def = false
1078
- }
1079
- term
1080
- {
1081
- result = self.in_single
1082
- self.in_single = 0
1083
- self.env.extend
1084
- }
1085
- bodystmt kEND
1086
- {
1087
- result = new_sclass val
1088
- self.env.unextend
1089
- }
1090
- | kMODULE
1091
- {
1092
- result = self.lexer.lineno
1093
- }
1094
- cpath
1095
- {
1096
- self.comments.push self.lexer.comments
1097
- yyerror "module definition in method body" if
1098
- self.in_def or self.in_single > 0
1099
-
1100
- self.env.extend
1101
- }
1102
- bodystmt kEND
1103
- {
1104
- result = new_module val
1105
- self.env.unextend
1106
- }
1107
- | kDEF fname
1108
- {
1109
- self.comments.push self.lexer.comments
1110
- self.in_def = true
1111
- self.env.extend
1112
- result = lexer.lineno, lexer.src.beginning_of_line?
1113
- }
1114
- f_arglist bodystmt kEND
1115
- {
1116
- result = new_defn val
1117
- self.env.unextend
1118
- self.in_def = false
1119
- }
1120
- | kDEF singleton dot_or_colon
1121
- {
1122
- self.comments.push self.lexer.comments
1123
- lexer.lex_state = :expr_fname
1124
- }
1125
- fname
1126
- {
1127
- self.in_single += 1
1128
- self.env.extend
1129
- lexer.lex_state = :expr_end # force for args
1130
- }
1131
- f_arglist bodystmt kEND
1132
- {
1133
- result = new_defs val
1134
-
1135
- self.env.unextend
1136
- self.in_single -= 1
1137
- }
1138
- | kBREAK
1139
- {
1140
- result = s(:break)
1141
- }
1142
- | kNEXT
1143
- {
1144
- result = s(:next)
1145
- }
1146
- | kREDO
1147
- {
1148
- result = s(:redo)
1149
- }
1150
- | kRETRY
1151
- {
1152
- result = s(:retry)
1153
- }
1154
-
1155
- primary_value: primary
1156
- {
1157
- result = value_expr(val[0])
1158
- }
1159
-
1160
- # These are really stupid
1161
- k_begin: kBEGIN
1162
- k_if: kIF
1163
- k_unless: kUNLESS
1164
- k_while: kWHILE
1165
- k_until: kUNTIL
1166
- k_case: kCASE
1167
- k_for: kFOR
1168
- k_class: kCLASS
1169
- k_module: kMODULE
1170
- k_def: kDEF
1171
- k_end: kEND
1172
-
1173
- then: term
1174
- | kTHEN
1175
- | term kTHEN
1176
-
1177
- do: term
1178
- | kDO_COND
1179
-
1180
- if_tail: opt_else
1181
- | kELSIF expr_value then compstmt if_tail
1182
- {
1183
- result = s(:if, val[1], val[3], val[4])
1184
- }
1185
-
1186
- opt_else: none
1187
- | kELSE compstmt
1188
- {
1189
- result = val[1]
1190
- }
1191
-
1192
- for_var: lhs
1193
- | mlhs
1194
- {
1195
- val[0].delete_at 1 if val[0][1].nil? # HACK
1196
- }
1197
-
1198
- f_marg: f_norm_arg
1199
- | tLPAREN f_margs rparen
1200
- {
1201
- result = val[1]
1202
- }
1203
-
1204
- f_marg_list: f_marg
1205
- {
1206
- result = s(:array, val[0])
1207
- }
1208
- | f_marg_list tCOMMA f_marg
1209
- {
1210
- result = list_append val[0], val[2]
1211
- }
1212
-
1213
- f_margs: f_marg_list
1214
- {
1215
- args, = val
1216
-
1217
- result = block_var args
1218
- }
1219
- | f_marg_list tCOMMA tSTAR f_norm_arg
1220
- {
1221
- args, _, _, splat = val
1222
-
1223
- result = block_var args, "*#{splat}".to_sym
1224
- }
1225
- | f_marg_list tCOMMA tSTAR f_norm_arg tCOMMA f_marg_list
1226
- {
1227
- args, _, _, splat, _, args2 = val
1228
-
1229
- result = block_var args, "*#{splat}".to_sym, args2
1230
- }
1231
- | f_marg_list tCOMMA tSTAR
1232
- {
1233
- args, _, _ = val
1234
-
1235
- result = block_var args, :*
1236
- }
1237
- | f_marg_list tCOMMA tSTAR tCOMMA f_marg_list
1238
- {
1239
- args, _, _, _, args2 = val
1240
-
1241
- result = block_var args, :*, args2
1242
- }
1243
- | tSTAR f_norm_arg
1244
- {
1245
- _, splat = val
1246
-
1247
- result = block_var :"*#{splat}"
1248
- }
1249
- | tSTAR f_norm_arg tCOMMA f_marg_list
1250
- {
1251
- _, splat, _, args = val
1252
-
1253
- result = block_var :"*#{splat}", args
1254
- }
1255
- | tSTAR
1256
- {
1257
- result = block_var :*
1258
- }
1259
- | tSTAR tCOMMA f_marg_list
1260
- {
1261
- _, _, args = val
1262
-
1263
- result = block_var :*, args
1264
- }
1265
-
1266
- block_param: f_arg tCOMMA f_block_optarg tCOMMA f_rest_arg opt_f_block_arg
1267
- {
1268
- result = args val
1269
- }
1270
- | f_arg tCOMMA f_block_optarg tCOMMA f_rest_arg tCOMMA f_arg opt_f_block_arg
1271
- {
1272
- result = args val
1273
- }
1274
- | f_arg tCOMMA f_block_optarg opt_f_block_arg
1275
- {
1276
- result = args val
1277
- }
1278
- | f_arg tCOMMA f_block_optarg tCOMMA f_arg opt_f_block_arg
1279
- {
1280
- result = args val
1281
- }
1282
- | f_arg tCOMMA f_rest_arg opt_f_block_arg
1283
- {
1284
- result = args val
1285
- }
1286
- | f_arg tCOMMA
1287
- {
1288
- result = args val
1289
- }
1290
- | f_arg tCOMMA f_rest_arg tCOMMA f_arg opt_f_block_arg
1291
- {
1292
- result = args val
1293
- }
1294
- | f_arg opt_f_block_arg
1295
- {
1296
- result = args val
1297
- }
1298
- | f_block_optarg tCOMMA f_rest_arg opt_f_block_arg
1299
- {
1300
- result = args val
1301
- }
1302
- | f_block_optarg tCOMMA f_rest_arg tCOMMA f_arg opt_f_block_arg
1303
- {
1304
- result = args val
1305
- }
1306
- | f_block_optarg opt_f_block_arg
1307
- {
1308
- result = args val
1309
- }
1310
- | f_block_optarg tCOMMA f_arg opt_f_block_arg
1311
- {
1312
- result = args val
1313
- }
1314
- | f_rest_arg opt_f_block_arg
1315
- {
1316
- result = args val
1317
- }
1318
- | f_rest_arg tCOMMA f_arg opt_f_block_arg
1319
- {
1320
- result = args val
1321
- }
1322
- | f_block_arg
1323
- {
1324
- result = args val
1325
- }
1326
-
1327
- opt_block_param: none
1328
- | block_param_def
1329
-
1330
- block_param_def: tPIPE opt_bv_decl tPIPE
1331
- {
1332
- result = val[1] || 0
1333
- }
1334
- | tOROP
1335
- {
1336
- result = 0
1337
- self.lexer.command_start = true
1338
- }
1339
- | tPIPE block_param opt_bv_decl tPIPE
1340
- {
1341
- result = val[1]
1342
- result.concat val[2] if val[2]
1343
- }
1344
-
1345
- opt_bv_decl: none
1346
- | tSEMI bv_decls
1347
- {
1348
- result = val[1]
1349
- }
1350
-
1351
- bv_decls: bvar
1352
- {
1353
- result = [val[0]]
1354
- }
1355
- | bv_decls tCOMMA bvar
1356
- {
1357
- result = val[0].concat val[2]
1358
- raise "no18\non: #{val.inspect}"
1359
- }
1360
-
1361
- bvar: tIDENTIFIER
1362
- | f_bad_arg
1363
-
1364
- lambda: f_larglist lambda_body
1365
- {
1366
- args, body = val
1367
-
1368
- args = 0 if args == s(:args)
1369
-
1370
- call = new_call nil, :lambda
1371
- result = new_iter call, args, body
1372
- }
1373
-
1374
- f_larglist: tLPAREN2 f_args opt_bv_decl rparen
1375
- {
1376
- result = val[1]
1377
- raise "not yet: #{val.inspect}" if val[2]
1378
- }
1379
- | f_args
1380
- {
1381
- result = val[0]
1382
- }
1383
-
1384
- lambda_body: tLAMBEG compstmt tRCURLY
1385
- {
1386
- result = val[1]
1387
- }
1388
- | kDO_LAMBDA compstmt kEND
1389
- {
1390
- result = val[1]
1391
- }
1392
-
1393
- do_block: kDO_BLOCK
1394
- {
1395
- self.env.extend :dynamic
1396
- result = self.lexer.lineno
1397
- }
1398
- opt_block_param
1399
- {
1400
- result = self.env.dynamic.keys
1401
- }
1402
- compstmt kEND
1403
- {
1404
- args = val[2]
1405
- body = val[4]
1406
- result = new_iter nil, args, body
1407
- result.line = val[1]
1408
-
1409
- self.env.unextend
1410
- }
1411
-
1412
- block_call: command do_block
1413
- {
1414
- # TODO:
1415
- # if (nd_type($1) == NODE_YIELD) {
1416
- # compile_error(PARSER_ARG "block given to yield");
1417
-
1418
- syntax_error "Both block arg and actual block given." if
1419
- val[0].block_pass?
1420
-
1421
- result = val[1]
1422
- result.insert 1, val[0]
1423
- }
1424
- | block_call tDOT operation2 opt_paren_args
1425
- {
1426
- result = new_call val[0], val[2], val[3]
1427
- }
1428
- | block_call tCOLON2 operation2 opt_paren_args
1429
- {
1430
- result = new_call val[0], val[2], val[3]
1431
- }
1432
-
1433
- method_call: operation
1434
- {
1435
- result = self.lexer.lineno
1436
- }
1437
- paren_args
1438
- {
1439
- result = new_call nil, val[0].to_sym, val[2]
1440
- }
1441
- | primary_value tDOT operation2 opt_paren_args
1442
- {
1443
- result = new_call val[0], val[2].to_sym, val[3]
1444
- }
1445
- | primary_value tCOLON2 operation2 paren_args
1446
- {
1447
- result = new_call val[0], val[2].to_sym, val[3]
1448
- }
1449
- | primary_value tCOLON2 operation3
1450
- {
1451
- result = new_call val[0], val[2].to_sym
1452
- }
1453
- | primary_value tDOT paren_args
1454
- {
1455
- result = new_call val[0], :call
1456
- }
1457
- | primary_value tCOLON2 paren_args
1458
- {
1459
- result = new_call val[0], :call
1460
- }
1461
- | kSUPER paren_args
1462
- {
1463
- result = new_super val[1]
1464
- }
1465
- | kSUPER
1466
- {
1467
- result = s(:zsuper)
1468
- }
1469
- | primary_value tLBRACK2 opt_call_args rbracket
1470
- {
1471
- result = new_aref val
1472
- }
1473
-
1474
- brace_block: tLCURLY
1475
- {
1476
- self.env.extend :dynamic
1477
- result = self.lexer.lineno
1478
- }
1479
- opt_block_param
1480
- {
1481
- result = self.env.dynamic.keys
1482
- }
1483
- compstmt tRCURLY
1484
- {
1485
- _, line, args, _, body, _ = val
1486
-
1487
- result = new_iter nil, args, body
1488
- result.line = line
1489
-
1490
- self.env.unextend
1491
- }
1492
- | kDO
1493
- {
1494
- self.env.extend :dynamic
1495
- result = self.lexer.lineno
1496
- }
1497
- opt_block_param
1498
- {
1499
- result = self.env.dynamic.keys
1500
- }
1501
- compstmt kEND
1502
- {
1503
- _, line, args, _, body, _ = val
1504
-
1505
- result = new_iter nil, args, body
1506
- result.line = line
1507
-
1508
- self.env.unextend
1509
- }
1510
-
1511
- case_body: kWHEN
1512
- {
1513
- result = self.lexer.lineno
1514
- }
1515
- args then compstmt cases
1516
- {
1517
- result = new_when(val[2], val[4])
1518
- result.line = val[1]
1519
- result << val[5] if val[5]
1520
- }
1521
-
1522
- cases: opt_else | case_body
1523
-
1524
- opt_rescue: kRESCUE exc_list exc_var then compstmt opt_rescue
1525
- {
1526
- _, klasses, var, _, body, rest = val
1527
-
1528
- klasses ||= s(:array)
1529
- klasses << node_assign(var, s(:gvar, :"$!")) if var
1530
-
1531
- result = new_resbody(klasses, body)
1532
- result << rest if rest # UGH, rewritten above
1533
- }
1534
- |
1535
- {
1536
- result = nil
1537
- }
1538
-
1539
- exc_list: arg_value
1540
- {
1541
- result = s(:array, val[0])
1542
- }
1543
- | mrhs
1544
- | none
1545
-
1546
- exc_var: tASSOC lhs
1547
- {
1548
- result = val[1]
1549
- }
1550
- | none
1551
-
1552
- opt_ensure: kENSURE compstmt
1553
- {
1554
- _, body = val
1555
-
1556
- result = body || s(:nil)
1557
- }
1558
- | none
1559
-
1560
- literal: numeric { result = s(:lit, val[0]) }
1561
- | symbol { result = s(:lit, val[0]) }
1562
- | dsym
1563
-
1564
- strings: string
1565
- {
1566
- val[0] = s(:dstr, val[0].value) if val[0][0] == :evstr
1567
- result = val[0]
1568
- }
1569
-
1570
- string: string1
1571
- | string string1
1572
- {
1573
- result = self.literal_concat val[0], val[1]
1574
- }
1575
-
1576
- string1: tSTRING_BEG string_contents tSTRING_END
1577
- {
1578
- result = val[1]
1579
- }
1580
- | tSTRING
1581
- {
1582
- result = s(:str, val[0])
1583
- }
1584
-
1585
- xstring: tXSTRING_BEG xstring_contents tSTRING_END
1586
- {
1587
- result = new_xstring val[1]
1588
- }
1589
-
1590
- regexp: tREGEXP_BEG regexp_contents tREGEXP_END
1591
- {
1592
- result = new_regexp val
1593
- }
1594
-
1595
- words: tWORDS_BEG tSPACE tSTRING_END
1596
- {
1597
- result = s(:array)
1598
- }
1599
- | tWORDS_BEG word_list tSTRING_END
1600
- {
1601
- result = val[1]
1602
- }
1603
-
1604
- word_list: none
1605
- {
1606
- result = s(:array)
1607
- }
1608
- | word_list word tSPACE
1609
- {
1610
- word = val[1][0] == :evstr ? s(:dstr, "", val[1]) : val[1]
1611
- result = val[0] << word
1612
- }
1613
-
1614
- word: string_content
1615
- | word string_content
1616
- {
1617
- result = self.literal_concat val[0], val[1]
1618
- }
1619
-
1620
- qwords: tQWORDS_BEG tSPACE tSTRING_END
1621
- {
1622
- result = s(:array)
1623
- }
1624
- | tQWORDS_BEG qword_list tSTRING_END
1625
- {
1626
- result = val[1]
1627
- }
1628
-
1629
- qword_list: none
1630
- {
1631
- result = s(:array)
1632
- }
1633
- | qword_list tSTRING_CONTENT tSPACE
1634
- {
1635
- result = val[0] << s(:str, val[1])
1636
- }
1637
-
1638
- string_contents: none
1639
- {
1640
- result = s(:str, "")
1641
- }
1642
- | string_contents string_content
1643
- {
1644
- result = literal_concat(val[0], val[1])
1645
- }
1646
-
1647
- xstring_contents: none
1648
- {
1649
- result = nil
1650
- }
1651
- | xstring_contents string_content
1652
- {
1653
- result = literal_concat(val[0], val[1])
1654
- }
1655
-
1656
- regexp_contents: none
1657
- {
1658
- result = nil
1659
- }
1660
- | regexp_contents string_content
1661
- {
1662
- result = literal_concat(val[0], val[1])
1663
- }
1664
-
1665
- string_content: tSTRING_CONTENT
1666
- {
1667
- result = s(:str, val[0])
1668
- }
1669
- | tSTRING_DVAR
1670
- {
1671
- result = lexer.lex_strterm
1672
- lexer.lex_strterm = nil
1673
- lexer.lex_state = :expr_beg
1674
- }
1675
- string_dvar
1676
- {
1677
- lexer.lex_strterm = val[1]
1678
- result = s(:evstr, val[2])
1679
- }
1680
- | tSTRING_DBEG
1681
- {
1682
- result = lexer.lex_strterm
1683
- lexer.lex_strterm = nil
1684
- lexer.lex_state = :expr_beg
1685
- lexer.cond.push false
1686
- lexer.cmdarg.push false
1687
- }
1688
- compstmt tRCURLY
1689
- {
1690
- lexer.lex_strterm = val[1]
1691
- lexer.cond.lexpop
1692
- lexer.cmdarg.lexpop
1693
-
1694
- case val[2]
1695
- when Sexp then
1696
- case val[2][0]
1697
- when :str, :dstr, :evstr then
1698
- result = val[2]
1699
- else
1700
- result = s(:evstr, val[2])
1701
- end
1702
- when nil then
1703
- result = s(:evstr)
1704
- else
1705
- raise "unknown string body: #{val[2].inspect}"
1706
- end
1707
- }
1708
-
1709
- string_dvar: tGVAR { result = s(:gvar, val[0].to_sym) }
1710
- | tIVAR { result = s(:ivar, val[0].to_sym) }
1711
- | tCVAR { result = s(:cvar, val[0].to_sym) }
1712
- | backref
1713
-
1714
-
1715
- symbol: tSYMBEG sym
1716
- {
1717
- lexer.lex_state = :expr_end
1718
- result = val[1].to_sym
1719
- }
1720
- | tSYMBOL
1721
- {
1722
- result = val[0].to_sym
1723
- }
1724
-
1725
- sym: fname | tIVAR | tGVAR | tCVAR
1726
-
1727
- dsym: tSYMBEG xstring_contents tSTRING_END
1728
- {
1729
- lexer.lex_state = :expr_end
1730
- result = val[1]
1731
-
1732
- yyerror "empty symbol literal" if
1733
- result.nil? or result.empty?
1734
-
1735
- case result[0]
1736
- when :dstr then
1737
- result[0] = :dsym
1738
- when :str then
1739
- result = s(:lit, result.last.intern)
1740
- else
1741
- result = s(:dsym, "", result)
1742
- end
1743
- }
1744
-
1745
- numeric: tINTEGER
1746
- | tFLOAT
1747
- | tUMINUS_NUM tINTEGER =tLOWEST
1748
- {
1749
- result = -val[1] # TODO: pt_testcase
1750
- }
1751
- | tUMINUS_NUM tFLOAT =tLOWEST
1752
- {
1753
- result = -val[1] # TODO: pt_testcase
1754
- }
1755
-
1756
- user_variable: tIDENTIFIER
1757
- | tIVAR
1758
- | tGVAR
1759
- | tCONSTANT
1760
- | tCVAR
1761
-
1762
- keyword_variable: kNIL { result = s(:nil) }
1763
- | kSELF { result = s(:self) }
1764
- | kTRUE { result = s(:true) }
1765
- | kFALSE { result = s(:false) }
1766
- | k__FILE__ { result = s(:str, self.file) }
1767
- | k__LINE__ { result = s(:lit, lexer.src.current_line) }
1768
- | k__ENCODING__
1769
- {
1770
- result =
1771
- if defined? Encoding then
1772
- s(:const, Encoding::UTF_8)
1773
- else
1774
- s(:str, "Unsupported!")
1775
- end
1776
- }
1777
-
1778
- var_ref: user_variable
1779
- {
1780
- var = val[0]
1781
- result = Sexp === var ? var : self.gettable(var)
1782
- }
1783
- | keyword_variable
1784
- {
1785
- var = val[0]
1786
- result = Sexp === var ? var : self.gettable(var)
1787
- }
1788
-
1789
- var_lhs: user_variable
1790
- {
1791
- result = self.assignable val[0]
1792
- }
1793
- | keyword_variable
1794
- {
1795
- result = self.assignable val[0]
1796
- }
1797
-
1798
- backref: tNTH_REF { result = s(:nth_ref, val[0]) }
1799
- | tBACK_REF { result = s(:back_ref, val[0]) }
1800
-
1801
- superclass: term
1802
- {
1803
- result = nil
1804
- }
1805
- | tLT
1806
- {
1807
- lexer.lex_state = :expr_beg
1808
- }
1809
- expr_value term
1810
- {
1811
- result = val[2]
1812
- }
1813
- | error term
1814
- {
1815
- yyerrok
1816
- result = nil
1817
- }
1818
-
1819
- f_arglist: tLPAREN2 f_args rparen
1820
- {
1821
- result = val[1]
1822
- lexer.lex_state = :expr_beg
1823
- self.lexer.command_start = true
1824
- }
1825
- | f_args term
1826
- {
1827
- result = val[0]
1828
- }
1829
-
1830
- f_args: f_arg tCOMMA f_optarg tCOMMA f_rest_arg opt_f_block_arg
1831
- {
1832
- result = args val
1833
- }
1834
- | f_arg tCOMMA f_optarg tCOMMA f_rest_arg tCOMMA f_arg opt_f_block_arg
1835
- {
1836
- result = args val
1837
- }
1838
- | f_arg tCOMMA f_optarg opt_f_block_arg
1839
- {
1840
- result = args val
1841
- }
1842
- | f_arg tCOMMA f_optarg tCOMMA f_arg opt_f_block_arg
1843
- {
1844
- result = args val
1845
- }
1846
- | f_arg tCOMMA f_rest_arg opt_f_block_arg
1847
- {
1848
- result = args val
1849
- }
1850
- | f_arg tCOMMA f_rest_arg tCOMMA f_arg opt_f_block_arg
1851
- {
1852
- result = args val
1853
- }
1854
- | f_arg opt_f_block_arg
1855
- {
1856
- result = args val
1857
- }
1858
- | f_optarg tCOMMA f_rest_arg opt_f_block_arg
1859
- {
1860
- result = args val
1861
- }
1862
- | f_optarg tCOMMA f_rest_arg tCOMMA f_arg opt_f_block_arg
1863
- {
1864
- result = args val
1865
- }
1866
- | f_optarg opt_f_block_arg
1867
- {
1868
- result = args val
1869
- }
1870
- | f_optarg tCOMMA f_arg opt_f_block_arg
1871
- {
1872
- result = args val
1873
- }
1874
- | f_rest_arg opt_f_block_arg
1875
- {
1876
- result = args val
1877
- }
1878
- | f_rest_arg tCOMMA f_arg opt_f_block_arg
1879
- {
1880
- result = args val
1881
- }
1882
- | f_block_arg
1883
- {
1884
- result = args val
1885
- }
1886
- |
1887
- {
1888
- result = args val
1889
- }
1890
-
1891
- f_bad_arg: tCONSTANT
1892
- {
1893
- yyerror "formal argument cannot be a constant"
1894
- }
1895
- | tIVAR
1896
- {
1897
- yyerror "formal argument cannot be an instance variable"
1898
- }
1899
- | tGVAR
1900
- {
1901
- yyerror "formal argument cannot be a global variable"
1902
- }
1903
- | tCVAR
1904
- {
1905
- yyerror "formal argument cannot be a class variable"
1906
- }
1907
-
1908
- f_norm_arg: f_bad_arg
1909
- | tIDENTIFIER
1910
- {
1911
- identifier = val[0].to_sym
1912
- self.env[identifier] = :lvar
1913
-
1914
- result = identifier
1915
- }
1916
-
1917
- f_arg_item: f_norm_arg
1918
- | tLPAREN f_margs rparen
1919
- {
1920
- result = val[1]
1921
- }
1922
-
1923
- f_arg: f_arg_item
1924
- {
1925
- case val[0]
1926
- when Symbol then
1927
- result = s(:args)
1928
- result << val[0]
1929
- when Sexp then
1930
- result = val[0]
1931
- else
1932
- raise "Unknown f_arg type: #{val.inspect}"
1933
- end
1934
- }
1935
- | f_arg tCOMMA f_arg_item
1936
- {
1937
- list, _, item = val
1938
-
1939
- if list.sexp_type == :args then
1940
- result = list
1941
- else
1942
- result = s(:args, list)
1943
- end
1944
-
1945
- result << item
1946
- }
1947
-
1948
- f_opt: tIDENTIFIER tEQL arg_value
1949
- {
1950
- result = self.assignable val[0], val[2]
1951
- # TODO: detect duplicate names
1952
- }
1953
-
1954
- f_block_opt: tIDENTIFIER tEQL primary_value
1955
- {
1956
- result = self.assignable val[0], val[2]
1957
- }
1958
-
1959
- f_block_optarg: f_block_opt
1960
- {
1961
- result = s(:block, val[0])
1962
- }
1963
- | f_block_optarg tCOMMA f_block_opt
1964
- {
1965
- result = val[0]
1966
- result << val[2]
1967
- }
1968
-
1969
- f_optarg: f_opt
1970
- {
1971
- result = s(:block, val[0])
1972
- }
1973
- | f_optarg tCOMMA f_opt
1974
- {
1975
- result = self.block_append val[0], val[2]
1976
- }
1977
-
1978
- restarg_mark: tSTAR2 | tSTAR
1979
-
1980
- f_rest_arg: restarg_mark tIDENTIFIER
1981
- {
1982
- # TODO: differs from parse.y - needs tests
1983
- name = val[1].to_sym
1984
- self.assignable name
1985
- result = :"*#{name}"
1986
- }
1987
- | restarg_mark
1988
- {
1989
- name = :"*"
1990
- self.env[name] = :lvar
1991
- result = name
1992
- }
1993
-
1994
- blkarg_mark: tAMPER2 | tAMPER
1995
-
1996
- f_block_arg: blkarg_mark tIDENTIFIER
1997
- {
1998
- identifier = val[1].to_sym
1999
-
2000
- self.env[identifier] = :lvar
2001
- result = "&#{identifier}".to_sym
2002
- }
2003
-
2004
- opt_f_block_arg: tCOMMA f_block_arg
2005
- {
2006
- result = val[1]
2007
- }
2008
- |
2009
- {
2010
- result = nil
2011
- }
2012
-
2013
- singleton: var_ref
2014
- | tLPAREN2
2015
- {
2016
- lexer.lex_state = :expr_beg
2017
- }
2018
- expr rparen
2019
- {
2020
- result = val[2]
2021
- yyerror "Can't define single method for literals." if
2022
- result[0] == :lit
2023
- }
2024
-
2025
- assoc_list: none # [!nil]
2026
- {
2027
- result = s(:array)
2028
- }
2029
- | assocs trailer # [!nil]
2030
- {
2031
- result = val[0]
2032
- }
2033
-
2034
- assocs: assoc
2035
- | assocs tCOMMA assoc
2036
- {
2037
- list = val[0].dup
2038
- more = val[2][1..-1]
2039
- list.push(*more) unless more.empty?
2040
- result = list
2041
- }
2042
-
2043
- assoc: arg_value tASSOC arg_value
2044
- {
2045
- result = s(:array, val[0], val[2])
2046
- }
2047
- | tLABEL arg_value
2048
- {
2049
- result = s(:array, s(:lit, val[0][0].to_sym), val[1])
2050
- }
2051
-
2052
- operation: tIDENTIFIER | tCONSTANT | tFID
2053
- operation2: tIDENTIFIER | tCONSTANT | tFID | op
2054
- operation3: tIDENTIFIER | tFID | op
2055
- dot_or_colon: tDOT | tCOLON2
2056
- opt_terms: | terms
2057
- opt_nl: | tNL
2058
- rparen: opt_nl tRPAREN
2059
- rbracket: opt_nl tRBRACK
2060
- trailer: | tNL | tCOMMA
2061
-
2062
- term: tSEMI { yyerrok }
2063
- | tNL
2064
-
2065
- terms: term
2066
- | terms tSEMI { yyerrok }
2067
-
2068
- none: { result = nil }
2069
- end
2070
-
2071
- ---- inner
2072
-
2073
- require "ruby_lexer"
2074
- require "ruby_parser_extras"
2075
-
2076
- # Local Variables: **
2077
- # racc-token-length-max:14 **
2078
- # End: **