brakeman 0.8.1 → 0.8.2
Sign up to get free protection for your applications and to get access to all the features.
- data/README.md +10 -0
- data/bin/brakeman +4 -0
- data/lib/brakeman.rb +1 -0
- data/lib/checks.rb +62 -5
- data/lib/checks/base_check.rb +5 -6
- data/lib/checks/check_cross_site_scripting.rb +3 -1
- data/lib/processors/base_processor.rb +14 -0
- data/lib/ruby_parser/ruby_lexer.rb +1 -1
- data/lib/ruby_parser/ruby_parser.rb +1037 -1733
- data/lib/version.rb +1 -1
- metadata +13 -5
data/README.md
CHANGED
|
@@ -67,6 +67,16 @@ To only raise warnings only when untrusted data is being directly used:
|
|
|
67
67
|
|
|
68
68
|
brakeman -r
|
|
69
69
|
|
|
70
|
+
By default, each check will be run in a separate thread. To disable this behavior:
|
|
71
|
+
|
|
72
|
+
brakeman -n
|
|
73
|
+
|
|
74
|
+
Normally Brakeman will parse `routes.rb` and attempt to infer which controller methods are used as actions. However, this is not perfect (especially for Rails 3). To ignore the automatically inferred routes and assume all methods are actions:
|
|
75
|
+
|
|
76
|
+
brakeman -a
|
|
77
|
+
|
|
78
|
+
Note that this will be enabled automatically if Brakeman runs into an error while parsing the routes.
|
|
79
|
+
|
|
70
80
|
# Warning information
|
|
71
81
|
|
|
72
82
|
See WARNING_TYPES for more information on the warnings reported by this tool.
|
data/bin/brakeman
CHANGED
|
@@ -17,6 +17,10 @@ options = {}
|
|
|
17
17
|
|
|
18
18
|
OptionParser.new do |opts|
|
|
19
19
|
opts.banner = "Usage: brakeman [options] rails/root/path"
|
|
20
|
+
|
|
21
|
+
opts.on "-n", "--no-threads", "Run checks sequentially" do
|
|
22
|
+
options[:parallel_checks] = false
|
|
23
|
+
end
|
|
20
24
|
|
|
21
25
|
opts.on "-p", "--path PATH", "Specify path to Rails application" do |path|
|
|
22
26
|
options[:app_path] = File.expand_path path
|
data/lib/brakeman.rb
CHANGED
data/lib/checks.rb
CHANGED
|
@@ -1,3 +1,5 @@
|
|
|
1
|
+
require 'thread'
|
|
2
|
+
|
|
1
3
|
#Collects up results from running different checks.
|
|
2
4
|
#
|
|
3
5
|
#Checks can be added with +Check.add(check_class)+
|
|
@@ -6,7 +8,7 @@
|
|
|
6
8
|
class Checks
|
|
7
9
|
@checks = []
|
|
8
10
|
|
|
9
|
-
attr_reader :warnings, :controller_warnings, :model_warnings, :template_warnings, :checks_run
|
|
11
|
+
attr_reader :warnings, :controller_warnings, :model_warnings, :template_warnings, :checks_run, :check_results
|
|
10
12
|
|
|
11
13
|
#Add a check. This will call +_klass_.new+ when running tests
|
|
12
14
|
def self.add klass
|
|
@@ -24,6 +26,7 @@ class Checks
|
|
|
24
26
|
@model_warnings = []
|
|
25
27
|
@controller_warnings = []
|
|
26
28
|
@checks_run = []
|
|
29
|
+
@check_results = Queue.new
|
|
27
30
|
end
|
|
28
31
|
|
|
29
32
|
#Add Warning to list of warnings to report.
|
|
@@ -47,21 +50,75 @@ class Checks
|
|
|
47
50
|
#Run all the checks on the given Tracker.
|
|
48
51
|
#Returns a new instance of Checks with the results.
|
|
49
52
|
def self.run_checks tracker
|
|
50
|
-
|
|
53
|
+
if OPTIONS[:parallel_checks]
|
|
54
|
+
self.run_checks_parallel tracker
|
|
55
|
+
else
|
|
56
|
+
self.run_checks_sequential tracker
|
|
57
|
+
end
|
|
58
|
+
end
|
|
59
|
+
|
|
60
|
+
#Run checks sequentially
|
|
61
|
+
def self.run_checks_sequential tracker
|
|
62
|
+
check_runner = self.new
|
|
63
|
+
|
|
51
64
|
@checks.each do |c|
|
|
52
65
|
#Run or don't run check based on options
|
|
53
66
|
unless OPTIONS[:skip_checks].include? c.to_s or
|
|
54
67
|
(OPTIONS[:run_checks] and not OPTIONS[:run_checks].include? c.to_s)
|
|
55
68
|
|
|
56
69
|
warn " - #{c}"
|
|
57
|
-
|
|
70
|
+
|
|
71
|
+
check = c.new(tracker)
|
|
72
|
+
check.run_check
|
|
73
|
+
|
|
74
|
+
check.warnings.each do |w|
|
|
75
|
+
check_runner.add_warning w
|
|
76
|
+
end
|
|
58
77
|
|
|
59
78
|
#Maintain list of which checks were run
|
|
60
79
|
#mainly for reporting purposes
|
|
61
|
-
|
|
80
|
+
check_runner.checks_run << c.to_s[5..-1]
|
|
62
81
|
end
|
|
63
82
|
end
|
|
64
|
-
|
|
83
|
+
|
|
84
|
+
check_runner
|
|
85
|
+
end
|
|
86
|
+
|
|
87
|
+
#Run checks in parallel threads
|
|
88
|
+
def self.run_checks_parallel tracker
|
|
89
|
+
threads = []
|
|
90
|
+
|
|
91
|
+
check_runner = self.new
|
|
92
|
+
|
|
93
|
+
@checks.each do |c|
|
|
94
|
+
#Run or don't run check based on options
|
|
95
|
+
unless OPTIONS[:skip_checks].include? c.to_s or
|
|
96
|
+
(OPTIONS[:run_checks] and not OPTIONS[:run_checks].include? c.to_s)
|
|
97
|
+
|
|
98
|
+
warn " - #{c}"
|
|
99
|
+
|
|
100
|
+
threads << Thread.new do
|
|
101
|
+
check = c.new(tracker)
|
|
102
|
+
check.run_check
|
|
103
|
+
check_runner.check_results << check.warnings unless check.warnings.empty?
|
|
104
|
+
end
|
|
105
|
+
|
|
106
|
+
#Maintain list of which checks were run
|
|
107
|
+
#mainly for reporting purposes
|
|
108
|
+
check_runner.checks_run << c.to_s[5..-1]
|
|
109
|
+
end
|
|
110
|
+
end
|
|
111
|
+
|
|
112
|
+
threads.each { |t| t.join }
|
|
113
|
+
|
|
114
|
+
until check_runner.check_results.empty?
|
|
115
|
+
r = check_runner.check_results.pop
|
|
116
|
+
r.each do |w|
|
|
117
|
+
check_runner.add_warning w
|
|
118
|
+
end
|
|
119
|
+
end
|
|
120
|
+
|
|
121
|
+
check_runner
|
|
65
122
|
end
|
|
66
123
|
end
|
|
67
124
|
|
data/lib/checks/base_check.rb
CHANGED
|
@@ -8,15 +8,15 @@ require 'util'
|
|
|
8
8
|
class BaseCheck < SexpProcessor
|
|
9
9
|
include ProcessorHelper
|
|
10
10
|
include Util
|
|
11
|
-
attr_reader :
|
|
11
|
+
attr_reader :tracker, :warnings
|
|
12
12
|
|
|
13
13
|
CONFIDENCE = { :high => 0, :med => 1, :low => 2 }
|
|
14
14
|
|
|
15
15
|
#Initialize Check with Checks.
|
|
16
|
-
def initialize
|
|
16
|
+
def initialize tracker
|
|
17
17
|
super()
|
|
18
18
|
@results = [] #only to check for duplicates
|
|
19
|
-
@
|
|
19
|
+
@warnings = []
|
|
20
20
|
@tracker = tracker
|
|
21
21
|
@string_interp = false
|
|
22
22
|
@current_template = @current_module = @current_class = @current_method = nil
|
|
@@ -39,7 +39,6 @@ class BaseCheck < SexpProcessor
|
|
|
39
39
|
#Default Sexp processing. Iterates over each value in the Sexp
|
|
40
40
|
#and processes them if they are also Sexps.
|
|
41
41
|
def process_default exp
|
|
42
|
-
type = exp.shift
|
|
43
42
|
exp.each_with_index do |e, i|
|
|
44
43
|
if sexp? e
|
|
45
44
|
process e
|
|
@@ -48,7 +47,7 @@ class BaseCheck < SexpProcessor
|
|
|
48
47
|
end
|
|
49
48
|
end
|
|
50
49
|
|
|
51
|
-
exp
|
|
50
|
+
exp
|
|
52
51
|
end
|
|
53
52
|
|
|
54
53
|
#Process calls and check if they include user input
|
|
@@ -83,7 +82,7 @@ class BaseCheck < SexpProcessor
|
|
|
83
82
|
|
|
84
83
|
#Report a warning
|
|
85
84
|
def warn options
|
|
86
|
-
@
|
|
85
|
+
@warnings << Warning.new(options.merge({ :check => self.class.to_s }))
|
|
87
86
|
end
|
|
88
87
|
|
|
89
88
|
#Run _exp_ through OutputProcessor to get a nice String.
|
|
@@ -50,7 +50,9 @@ class CheckCrossSiteScripting < BaseCheck
|
|
|
50
50
|
@models = tracker.models.keys
|
|
51
51
|
@inspect_arguments = OPTIONS[:check_arguments]
|
|
52
52
|
|
|
53
|
-
CheckLinkTo.new(
|
|
53
|
+
link_to_check = CheckLinkTo.new(tracker)
|
|
54
|
+
link_to_check.run_check
|
|
55
|
+
warnings.concat link_to_check.warnings unless link_to_check.warnings.empty?
|
|
54
56
|
|
|
55
57
|
if version_between? "2.0.0", "3.0.5"
|
|
56
58
|
KNOWN_DANGEROUS << :auto_link
|
|
@@ -26,6 +26,7 @@ class BaseProcessor < SexpProcessor
|
|
|
26
26
|
|
|
27
27
|
#Process a new scope. Removes expressions that are set to nil.
|
|
28
28
|
def process_scope exp
|
|
29
|
+
exp = exp.dup
|
|
29
30
|
exp.shift
|
|
30
31
|
exp.map! do |e|
|
|
31
32
|
res = process e
|
|
@@ -40,6 +41,7 @@ class BaseProcessor < SexpProcessor
|
|
|
40
41
|
|
|
41
42
|
#Default processing.
|
|
42
43
|
def process_default exp
|
|
44
|
+
exp = exp.dup
|
|
43
45
|
type = exp.shift
|
|
44
46
|
exp.each_with_index do |e, i|
|
|
45
47
|
if sexp? e and not e.empty?
|
|
@@ -54,6 +56,7 @@ class BaseProcessor < SexpProcessor
|
|
|
54
56
|
|
|
55
57
|
#Process an if statement.
|
|
56
58
|
def process_if exp
|
|
59
|
+
exp = exp.dup
|
|
57
60
|
exp[1] = process exp[1]
|
|
58
61
|
exp[2] = process exp[2] if exp[2]
|
|
59
62
|
exp[3] = process exp[3] if exp[3]
|
|
@@ -64,6 +67,7 @@ class BaseProcessor < SexpProcessor
|
|
|
64
67
|
#
|
|
65
68
|
#s(:iter, CALL, {:lasgn|:masgn}, BLOCK)
|
|
66
69
|
def process_iter exp
|
|
70
|
+
exp = exp.dup
|
|
67
71
|
call = process exp[1]
|
|
68
72
|
#deal with assignments somehow
|
|
69
73
|
if exp[3]
|
|
@@ -80,6 +84,7 @@ class BaseProcessor < SexpProcessor
|
|
|
80
84
|
|
|
81
85
|
#String with interpolation. Changes Sexp node type to :string_interp
|
|
82
86
|
def process_dstr exp
|
|
87
|
+
exp = exp.dup
|
|
83
88
|
exp.shift
|
|
84
89
|
exp.map! do |e|
|
|
85
90
|
if e.is_a? String
|
|
@@ -101,6 +106,7 @@ class BaseProcessor < SexpProcessor
|
|
|
101
106
|
|
|
102
107
|
#Processes a block. Changes Sexp node type to :rlist
|
|
103
108
|
def process_block exp
|
|
109
|
+
exp = exp.dup
|
|
104
110
|
exp.shift
|
|
105
111
|
|
|
106
112
|
exp.map! do |e|
|
|
@@ -113,6 +119,7 @@ class BaseProcessor < SexpProcessor
|
|
|
113
119
|
#Processes the inside of an interpolated String.
|
|
114
120
|
#Changes Sexp node type to :string_eval
|
|
115
121
|
def process_evstr exp
|
|
122
|
+
exp = exp.dup
|
|
116
123
|
exp[0] = :string_eval
|
|
117
124
|
exp[1] = process exp[1]
|
|
118
125
|
exp
|
|
@@ -120,6 +127,7 @@ class BaseProcessor < SexpProcessor
|
|
|
120
127
|
|
|
121
128
|
#Processes an or keyword
|
|
122
129
|
def process_or exp
|
|
130
|
+
exp = exp.dup
|
|
123
131
|
exp[1] = process exp[1]
|
|
124
132
|
exp[2] = process exp[2]
|
|
125
133
|
exp
|
|
@@ -127,6 +135,7 @@ class BaseProcessor < SexpProcessor
|
|
|
127
135
|
|
|
128
136
|
#Processes an and keyword
|
|
129
137
|
def process_and exp
|
|
138
|
+
exp = exp.dup
|
|
130
139
|
exp[1] = process exp[1]
|
|
131
140
|
exp[2] = process exp[2]
|
|
132
141
|
exp
|
|
@@ -134,6 +143,7 @@ class BaseProcessor < SexpProcessor
|
|
|
134
143
|
|
|
135
144
|
#Processes a hash
|
|
136
145
|
def process_hash exp
|
|
146
|
+
exp = exp.dup
|
|
137
147
|
exp.shift
|
|
138
148
|
exp.map! do |e|
|
|
139
149
|
if sexp? e
|
|
@@ -148,6 +158,7 @@ class BaseProcessor < SexpProcessor
|
|
|
148
158
|
|
|
149
159
|
#Processes the values in an argument list
|
|
150
160
|
def process_arglist exp
|
|
161
|
+
exp = exp.dup
|
|
151
162
|
exp.shift
|
|
152
163
|
exp.map! do |e|
|
|
153
164
|
process e
|
|
@@ -158,18 +169,21 @@ class BaseProcessor < SexpProcessor
|
|
|
158
169
|
|
|
159
170
|
#Processes a local assignment
|
|
160
171
|
def process_lasgn exp
|
|
172
|
+
exp = exp.dup
|
|
161
173
|
exp[2] = process exp[2]
|
|
162
174
|
exp
|
|
163
175
|
end
|
|
164
176
|
|
|
165
177
|
#Processes an instance variable assignment
|
|
166
178
|
def process_iasgn exp
|
|
179
|
+
exp = exp.dup
|
|
167
180
|
exp[2] = process exp[2]
|
|
168
181
|
exp
|
|
169
182
|
end
|
|
170
183
|
|
|
171
184
|
#Processes an attribute assignment, which can be either x.y = 1 or x[:y] = 1
|
|
172
185
|
def process_attrasgn exp
|
|
186
|
+
exp = exp.dup
|
|
173
187
|
exp[1] = process exp[1]
|
|
174
188
|
exp[3] = process exp[3]
|
|
175
189
|
exp
|
|
@@ -727,7 +727,7 @@ class RubyLexer
|
|
|
727
727
|
# @comments << '=' << src.matched
|
|
728
728
|
@comments << src.matched
|
|
729
729
|
|
|
730
|
-
unless src.scan(/.*?\n=end( |\t|\f)*[
|
|
730
|
+
unless src.scan(/.*?\n=end( |\t|\f)*[^\n]*(\n|\z)/m) then
|
|
731
731
|
@comments.clear
|
|
732
732
|
rb_compile_error("embedded document meets end of file")
|
|
733
733
|
end
|
|
@@ -7,20 +7,13 @@
|
|
|
7
7
|
require 'racc/parser.rb'
|
|
8
8
|
class RubyParser < Racc::Parser
|
|
9
9
|
|
|
10
|
-
module_eval(<<'...end ruby_parser.y/module_eval...', 'ruby_parser.y', 1798)
|
|
11
10
|
|
|
12
|
-
|
|
13
|
-
$VERBOSE = nil
|
|
14
|
-
|
|
15
|
-
require "ruby_parser/ruby_lexer"
|
|
11
|
+
require "ruby_lexer"
|
|
16
12
|
require "ruby_parser_extras"
|
|
17
13
|
|
|
18
|
-
$VERBOSE = original_verbosity
|
|
19
|
-
|
|
20
14
|
# Local Variables: **
|
|
21
15
|
# racc-token-length-max:14 **
|
|
22
16
|
# End: **
|
|
23
|
-
...end ruby_parser.y/module_eval...
|
|
24
17
|
##### State transition tables begin ###
|
|
25
18
|
|
|
26
19
|
clist = [
|
|
@@ -2961,398 +2954,307 @@ Racc_debug_parser = false
|
|
|
2961
2954
|
|
|
2962
2955
|
# reduce 0 omitted
|
|
2963
2956
|
|
|
2964
|
-
|
|
2965
|
-
|
|
2966
|
-
self.lexer.lex_state = :expr_beg
|
|
2957
|
+
def _reduce_1(val, _values, result)
|
|
2958
|
+
self.lexer.lex_state = :expr_beg
|
|
2967
2959
|
|
|
2968
2960
|
result
|
|
2969
|
-
|
|
2970
|
-
.,.,
|
|
2961
|
+
end
|
|
2971
2962
|
|
|
2972
|
-
|
|
2973
|
-
|
|
2974
|
-
result = val[1]
|
|
2963
|
+
def _reduce_2(val, _values, result)
|
|
2964
|
+
result = val[1]
|
|
2975
2965
|
|
|
2976
2966
|
result
|
|
2977
|
-
|
|
2978
|
-
.,.,
|
|
2967
|
+
end
|
|
2979
2968
|
|
|
2980
|
-
|
|
2981
|
-
|
|
2982
|
-
result = new_body val
|
|
2969
|
+
def _reduce_3(val, _values, result)
|
|
2970
|
+
result = new_body val
|
|
2983
2971
|
|
|
2984
2972
|
result
|
|
2985
|
-
|
|
2986
|
-
.,.,
|
|
2973
|
+
end
|
|
2987
2974
|
|
|
2988
|
-
|
|
2989
|
-
|
|
2990
|
-
result = new_compstmt val
|
|
2975
|
+
def _reduce_4(val, _values, result)
|
|
2976
|
+
result = new_compstmt val
|
|
2991
2977
|
|
|
2992
2978
|
result
|
|
2993
|
-
|
|
2994
|
-
.,.,
|
|
2979
|
+
end
|
|
2995
2980
|
|
|
2996
2981
|
# reduce 5 omitted
|
|
2997
2982
|
|
|
2998
2983
|
# reduce 6 omitted
|
|
2999
2984
|
|
|
3000
|
-
|
|
3001
|
-
|
|
3002
|
-
result = self.block_append val[0], val[2]
|
|
2985
|
+
def _reduce_7(val, _values, result)
|
|
2986
|
+
result = self.block_append val[0], val[2]
|
|
3003
2987
|
|
|
3004
2988
|
result
|
|
3005
|
-
|
|
3006
|
-
.,.,
|
|
2989
|
+
end
|
|
3007
2990
|
|
|
3008
|
-
|
|
3009
|
-
|
|
3010
|
-
result = val[1]
|
|
2991
|
+
def _reduce_8(val, _values, result)
|
|
2992
|
+
result = val[1]
|
|
3011
2993
|
|
|
3012
2994
|
result
|
|
3013
|
-
|
|
3014
|
-
.,.,
|
|
2995
|
+
end
|
|
3015
2996
|
|
|
3016
|
-
|
|
3017
|
-
|
|
3018
|
-
lexer.lex_state = :expr_fname
|
|
2997
|
+
def _reduce_9(val, _values, result)
|
|
2998
|
+
lexer.lex_state = :expr_fname
|
|
3019
2999
|
result = self.lexer.lineno
|
|
3020
3000
|
|
|
3021
3001
|
result
|
|
3022
|
-
|
|
3023
|
-
.,.,
|
|
3002
|
+
end
|
|
3024
3003
|
|
|
3025
|
-
|
|
3026
|
-
|
|
3027
|
-
result = s(:alias, val[1], val[3]).line(val[2])
|
|
3004
|
+
def _reduce_10(val, _values, result)
|
|
3005
|
+
result = s(:alias, val[1], val[3]).line(val[2])
|
|
3028
3006
|
|
|
3029
3007
|
result
|
|
3030
|
-
|
|
3031
|
-
.,.,
|
|
3008
|
+
end
|
|
3032
3009
|
|
|
3033
|
-
|
|
3034
|
-
|
|
3035
|
-
result = s(:valias, val[1].to_sym, val[2].to_sym)
|
|
3010
|
+
def _reduce_11(val, _values, result)
|
|
3011
|
+
result = s(:valias, val[1].to_sym, val[2].to_sym)
|
|
3036
3012
|
|
|
3037
3013
|
result
|
|
3038
|
-
|
|
3039
|
-
.,.,
|
|
3014
|
+
end
|
|
3040
3015
|
|
|
3041
|
-
|
|
3042
|
-
|
|
3043
|
-
result = s(:valias, val[1].to_sym, :"$#{val[2]}")
|
|
3016
|
+
def _reduce_12(val, _values, result)
|
|
3017
|
+
result = s(:valias, val[1].to_sym, :"$#{val[2]}")
|
|
3044
3018
|
|
|
3045
3019
|
result
|
|
3046
|
-
|
|
3047
|
-
.,.,
|
|
3020
|
+
end
|
|
3048
3021
|
|
|
3049
|
-
|
|
3050
|
-
|
|
3051
|
-
yyerror "can't make alias for the number variables"
|
|
3022
|
+
def _reduce_13(val, _values, result)
|
|
3023
|
+
yyerror "can't make alias for the number variables"
|
|
3052
3024
|
|
|
3053
3025
|
result
|
|
3054
|
-
|
|
3055
|
-
.,.,
|
|
3026
|
+
end
|
|
3056
3027
|
|
|
3057
|
-
|
|
3058
|
-
|
|
3059
|
-
result = val[1]
|
|
3028
|
+
def _reduce_14(val, _values, result)
|
|
3029
|
+
result = val[1]
|
|
3060
3030
|
|
|
3061
3031
|
result
|
|
3062
|
-
|
|
3063
|
-
.,.,
|
|
3032
|
+
end
|
|
3064
3033
|
|
|
3065
|
-
|
|
3066
|
-
|
|
3067
|
-
result = new_if val[2], val[0], nil
|
|
3034
|
+
def _reduce_15(val, _values, result)
|
|
3035
|
+
result = new_if val[2], val[0], nil
|
|
3068
3036
|
|
|
3069
3037
|
result
|
|
3070
|
-
|
|
3071
|
-
.,.,
|
|
3038
|
+
end
|
|
3072
3039
|
|
|
3073
|
-
|
|
3074
|
-
|
|
3075
|
-
result = new_if val[2], nil, val[0]
|
|
3040
|
+
def _reduce_16(val, _values, result)
|
|
3041
|
+
result = new_if val[2], nil, val[0]
|
|
3076
3042
|
|
|
3077
3043
|
result
|
|
3078
|
-
|
|
3079
|
-
.,.,
|
|
3044
|
+
end
|
|
3080
3045
|
|
|
3081
|
-
|
|
3082
|
-
|
|
3083
|
-
result = new_while val[0], val[2], true
|
|
3046
|
+
def _reduce_17(val, _values, result)
|
|
3047
|
+
result = new_while val[0], val[2], true
|
|
3084
3048
|
|
|
3085
3049
|
result
|
|
3086
|
-
|
|
3087
|
-
.,.,
|
|
3050
|
+
end
|
|
3088
3051
|
|
|
3089
|
-
|
|
3090
|
-
|
|
3091
|
-
result = new_until val[0], val[2], true
|
|
3052
|
+
def _reduce_18(val, _values, result)
|
|
3053
|
+
result = new_until val[0], val[2], true
|
|
3092
3054
|
|
|
3093
3055
|
result
|
|
3094
|
-
|
|
3095
|
-
.,.,
|
|
3056
|
+
end
|
|
3096
3057
|
|
|
3097
|
-
|
|
3098
|
-
|
|
3099
|
-
result = s(:rescue, val[0], s(:resbody, s(:array), val[2]))
|
|
3058
|
+
def _reduce_19(val, _values, result)
|
|
3059
|
+
result = s(:rescue, val[0], s(:resbody, s(:array), val[2]))
|
|
3100
3060
|
|
|
3101
3061
|
result
|
|
3102
|
-
|
|
3103
|
-
.,.,
|
|
3062
|
+
end
|
|
3104
3063
|
|
|
3105
|
-
|
|
3106
|
-
|
|
3107
|
-
if (self.in_def || self.in_single > 0) then
|
|
3064
|
+
def _reduce_20(val, _values, result)
|
|
3065
|
+
if (self.in_def || self.in_single > 0) then
|
|
3108
3066
|
yyerror "BEGIN in method"
|
|
3109
3067
|
end
|
|
3110
3068
|
self.env.extend
|
|
3111
3069
|
|
|
3112
3070
|
result
|
|
3113
|
-
|
|
3114
|
-
.,.,
|
|
3071
|
+
end
|
|
3115
3072
|
|
|
3116
|
-
|
|
3117
|
-
|
|
3118
|
-
result = new_iter s(:preexe), nil, val[3] # TODO: add test?
|
|
3073
|
+
def _reduce_21(val, _values, result)
|
|
3074
|
+
result = new_iter s(:preexe), nil, val[3] # TODO: add test?
|
|
3119
3075
|
result = nil # TODO: since it isn't supposed to go in the AST
|
|
3120
3076
|
|
|
3121
3077
|
result
|
|
3122
|
-
|
|
3123
|
-
.,.,
|
|
3078
|
+
end
|
|
3124
3079
|
|
|
3125
|
-
|
|
3126
|
-
|
|
3127
|
-
if (self.in_def || self.in_single > 0) then
|
|
3080
|
+
def _reduce_22(val, _values, result)
|
|
3081
|
+
if (self.in_def || self.in_single > 0) then
|
|
3128
3082
|
yyerror "END in method; use at_exit"
|
|
3129
3083
|
end
|
|
3130
3084
|
result = new_iter s(:postexe), nil, val[2]
|
|
3131
3085
|
|
|
3132
3086
|
result
|
|
3133
|
-
|
|
3134
|
-
.,.,
|
|
3087
|
+
end
|
|
3135
3088
|
|
|
3136
|
-
|
|
3137
|
-
|
|
3138
|
-
result = self.node_assign val[0], val[2]
|
|
3089
|
+
def _reduce_23(val, _values, result)
|
|
3090
|
+
result = self.node_assign val[0], val[2]
|
|
3139
3091
|
|
|
3140
3092
|
result
|
|
3141
|
-
|
|
3142
|
-
.,.,
|
|
3093
|
+
end
|
|
3143
3094
|
|
|
3144
|
-
|
|
3145
|
-
|
|
3146
|
-
result = new_masgn val[0], val[2], :wrap
|
|
3095
|
+
def _reduce_24(val, _values, result)
|
|
3096
|
+
result = new_masgn val[0], val[2], :wrap
|
|
3147
3097
|
|
|
3148
3098
|
result
|
|
3149
|
-
|
|
3150
|
-
.,.,
|
|
3099
|
+
end
|
|
3151
3100
|
|
|
3152
|
-
|
|
3153
|
-
|
|
3154
|
-
result = new_op_asgn val
|
|
3101
|
+
def _reduce_25(val, _values, result)
|
|
3102
|
+
result = new_op_asgn val
|
|
3155
3103
|
|
|
3156
3104
|
result
|
|
3157
|
-
|
|
3158
|
-
.,.,
|
|
3105
|
+
end
|
|
3159
3106
|
|
|
3160
|
-
|
|
3161
|
-
|
|
3162
|
-
result = s(:op_asgn1, val[0], val[2], val[4].to_sym, val[5])
|
|
3107
|
+
def _reduce_26(val, _values, result)
|
|
3108
|
+
result = s(:op_asgn1, val[0], val[2], val[4].to_sym, val[5])
|
|
3163
3109
|
|
|
3164
3110
|
result
|
|
3165
|
-
|
|
3166
|
-
.,.,
|
|
3111
|
+
end
|
|
3167
3112
|
|
|
3168
|
-
|
|
3169
|
-
|
|
3170
|
-
result = s(:op_asgn, val[0], val[4], val[2], val[3])
|
|
3113
|
+
def _reduce_27(val, _values, result)
|
|
3114
|
+
result = s(:op_asgn, val[0], val[4], val[2], val[3])
|
|
3171
3115
|
|
|
3172
3116
|
result
|
|
3173
|
-
|
|
3174
|
-
.,.,
|
|
3117
|
+
end
|
|
3175
3118
|
|
|
3176
|
-
|
|
3177
|
-
|
|
3178
|
-
result = s(:op_asgn, val[0], val[4], val[2], val[3])
|
|
3119
|
+
def _reduce_28(val, _values, result)
|
|
3120
|
+
result = s(:op_asgn, val[0], val[4], val[2], val[3])
|
|
3179
3121
|
|
|
3180
3122
|
result
|
|
3181
|
-
|
|
3182
|
-
.,.,
|
|
3123
|
+
end
|
|
3183
3124
|
|
|
3184
|
-
|
|
3185
|
-
|
|
3186
|
-
result = s(:op_asgn, val[0], val[4], val[2], val[3])
|
|
3125
|
+
def _reduce_29(val, _values, result)
|
|
3126
|
+
result = s(:op_asgn, val[0], val[4], val[2], val[3])
|
|
3187
3127
|
|
|
3188
3128
|
result
|
|
3189
|
-
|
|
3190
|
-
.,.,
|
|
3129
|
+
end
|
|
3191
3130
|
|
|
3192
|
-
|
|
3193
|
-
|
|
3194
|
-
self.backref_assign_error val[0]
|
|
3131
|
+
def _reduce_30(val, _values, result)
|
|
3132
|
+
self.backref_assign_error val[0]
|
|
3195
3133
|
|
|
3196
3134
|
result
|
|
3197
|
-
|
|
3198
|
-
.,.,
|
|
3135
|
+
end
|
|
3199
3136
|
|
|
3200
|
-
|
|
3201
|
-
|
|
3202
|
-
result = self.node_assign val[0], s(:svalue, val[2])
|
|
3137
|
+
def _reduce_31(val, _values, result)
|
|
3138
|
+
result = self.node_assign val[0], s(:svalue, val[2])
|
|
3203
3139
|
|
|
3204
3140
|
result
|
|
3205
|
-
|
|
3206
|
-
.,.,
|
|
3141
|
+
end
|
|
3207
3142
|
|
|
3208
|
-
|
|
3209
|
-
|
|
3210
|
-
result = new_masgn val[0], val[2], :wrap
|
|
3143
|
+
def _reduce_32(val, _values, result)
|
|
3144
|
+
result = new_masgn val[0], val[2], :wrap
|
|
3211
3145
|
|
|
3212
3146
|
result
|
|
3213
|
-
|
|
3214
|
-
.,.,
|
|
3147
|
+
end
|
|
3215
3148
|
|
|
3216
|
-
|
|
3217
|
-
|
|
3218
|
-
result = new_masgn val[0], val[2]
|
|
3149
|
+
def _reduce_33(val, _values, result)
|
|
3150
|
+
result = new_masgn val[0], val[2]
|
|
3219
3151
|
|
|
3220
3152
|
result
|
|
3221
|
-
|
|
3222
|
-
.,.,
|
|
3153
|
+
end
|
|
3223
3154
|
|
|
3224
3155
|
# reduce 34 omitted
|
|
3225
3156
|
|
|
3226
3157
|
# reduce 35 omitted
|
|
3227
3158
|
|
|
3228
|
-
|
|
3229
|
-
|
|
3230
|
-
result = logop(:and, val[0], val[2])
|
|
3159
|
+
def _reduce_36(val, _values, result)
|
|
3160
|
+
result = logop(:and, val[0], val[2])
|
|
3231
3161
|
|
|
3232
3162
|
result
|
|
3233
|
-
|
|
3234
|
-
.,.,
|
|
3163
|
+
end
|
|
3235
3164
|
|
|
3236
|
-
|
|
3237
|
-
|
|
3238
|
-
result = logop(:or, val[0], val[2])
|
|
3165
|
+
def _reduce_37(val, _values, result)
|
|
3166
|
+
result = logop(:or, val[0], val[2])
|
|
3239
3167
|
|
|
3240
3168
|
result
|
|
3241
|
-
|
|
3242
|
-
.,.,
|
|
3169
|
+
end
|
|
3243
3170
|
|
|
3244
|
-
|
|
3245
|
-
|
|
3246
|
-
result = s(:not, val[1])
|
|
3171
|
+
def _reduce_38(val, _values, result)
|
|
3172
|
+
result = s(:not, val[1])
|
|
3247
3173
|
|
|
3248
3174
|
result
|
|
3249
|
-
|
|
3250
|
-
.,.,
|
|
3175
|
+
end
|
|
3251
3176
|
|
|
3252
|
-
|
|
3253
|
-
|
|
3254
|
-
result = s(:not, val[1])
|
|
3177
|
+
def _reduce_39(val, _values, result)
|
|
3178
|
+
result = s(:not, val[1])
|
|
3255
3179
|
|
|
3256
3180
|
result
|
|
3257
|
-
|
|
3258
|
-
.,.,
|
|
3181
|
+
end
|
|
3259
3182
|
|
|
3260
3183
|
# reduce 40 omitted
|
|
3261
3184
|
|
|
3262
|
-
|
|
3263
|
-
|
|
3264
|
-
result = value_expr(val[0])
|
|
3185
|
+
def _reduce_41(val, _values, result)
|
|
3186
|
+
result = value_expr(val[0])
|
|
3265
3187
|
|
|
3266
3188
|
result
|
|
3267
|
-
|
|
3268
|
-
.,.,
|
|
3189
|
+
end
|
|
3269
3190
|
|
|
3270
3191
|
# reduce 42 omitted
|
|
3271
3192
|
|
|
3272
3193
|
# reduce 43 omitted
|
|
3273
3194
|
|
|
3274
|
-
|
|
3275
|
-
|
|
3276
|
-
line = val[0].last
|
|
3195
|
+
def _reduce_44(val, _values, result)
|
|
3196
|
+
line = val[0].last
|
|
3277
3197
|
result = s(:return, ret_args(val[1])).line(line)
|
|
3278
3198
|
|
|
3279
3199
|
result
|
|
3280
|
-
|
|
3281
|
-
.,.,
|
|
3200
|
+
end
|
|
3282
3201
|
|
|
3283
|
-
|
|
3284
|
-
|
|
3285
|
-
line = val[0].last
|
|
3202
|
+
def _reduce_45(val, _values, result)
|
|
3203
|
+
line = val[0].last
|
|
3286
3204
|
result = s(:break, ret_args(val[1])).line(line)
|
|
3287
3205
|
|
|
3288
3206
|
result
|
|
3289
|
-
|
|
3290
|
-
.,.,
|
|
3207
|
+
end
|
|
3291
3208
|
|
|
3292
|
-
|
|
3293
|
-
|
|
3294
|
-
line = val[0].last
|
|
3209
|
+
def _reduce_46(val, _values, result)
|
|
3210
|
+
line = val[0].last
|
|
3295
3211
|
result = s(:next, ret_args(val[1])).line(line)
|
|
3296
3212
|
|
|
3297
3213
|
result
|
|
3298
|
-
|
|
3299
|
-
.,.,
|
|
3214
|
+
end
|
|
3300
3215
|
|
|
3301
3216
|
# reduce 47 omitted
|
|
3302
3217
|
|
|
3303
|
-
|
|
3304
|
-
|
|
3305
|
-
result = new_call val[0], val[2], val[3]
|
|
3218
|
+
def _reduce_48(val, _values, result)
|
|
3219
|
+
result = new_call val[0], val[2], val[3]
|
|
3306
3220
|
|
|
3307
3221
|
result
|
|
3308
|
-
|
|
3309
|
-
.,.,
|
|
3222
|
+
end
|
|
3310
3223
|
|
|
3311
|
-
|
|
3312
|
-
|
|
3313
|
-
result = new_call val[0], val[2], val[3]
|
|
3224
|
+
def _reduce_49(val, _values, result)
|
|
3225
|
+
result = new_call val[0], val[2], val[3]
|
|
3314
3226
|
|
|
3315
3227
|
result
|
|
3316
|
-
|
|
3317
|
-
.,.,
|
|
3228
|
+
end
|
|
3318
3229
|
|
|
3319
|
-
|
|
3320
|
-
|
|
3321
|
-
self.env.extend(:dynamic)
|
|
3230
|
+
def _reduce_50(val, _values, result)
|
|
3231
|
+
self.env.extend(:dynamic)
|
|
3322
3232
|
result = self.lexer.lineno
|
|
3323
3233
|
|
|
3324
3234
|
result
|
|
3325
|
-
|
|
3326
|
-
.,.,
|
|
3235
|
+
end
|
|
3327
3236
|
|
|
3328
|
-
|
|
3329
|
-
|
|
3330
|
-
result = self.env.dynamic.keys
|
|
3237
|
+
def _reduce_51(val, _values, result)
|
|
3238
|
+
result = self.env.dynamic.keys
|
|
3331
3239
|
|
|
3332
3240
|
result
|
|
3333
|
-
|
|
3334
|
-
.,.,
|
|
3241
|
+
end
|
|
3335
3242
|
|
|
3336
|
-
|
|
3337
|
-
|
|
3338
|
-
result = new_iter nil, val[2], val[4]
|
|
3243
|
+
def _reduce_52(val, _values, result)
|
|
3244
|
+
result = new_iter nil, val[2], val[4]
|
|
3339
3245
|
self.env.unextend
|
|
3340
3246
|
|
|
3341
3247
|
result
|
|
3342
|
-
|
|
3343
|
-
.,.,
|
|
3248
|
+
end
|
|
3344
3249
|
|
|
3345
|
-
|
|
3346
|
-
|
|
3347
|
-
result = new_call nil, val[0].to_sym, val[1]
|
|
3250
|
+
def _reduce_53(val, _values, result)
|
|
3251
|
+
result = new_call nil, val[0].to_sym, val[1]
|
|
3348
3252
|
|
|
3349
3253
|
result
|
|
3350
|
-
|
|
3351
|
-
.,.,
|
|
3254
|
+
end
|
|
3352
3255
|
|
|
3353
|
-
|
|
3354
|
-
|
|
3355
|
-
result = new_call nil, val[0].to_sym, val[1]
|
|
3256
|
+
def _reduce_54(val, _values, result)
|
|
3257
|
+
result = new_call nil, val[0].to_sym, val[1]
|
|
3356
3258
|
if val[2] then
|
|
3357
3259
|
if result[0] == :block_pass then
|
|
3358
3260
|
raise "both block arg and actual block given"
|
|
@@ -3362,36 +3264,28 @@ module_eval(<<'.,.,', 'ruby_parser.y', 259)
|
|
|
3362
3264
|
end
|
|
3363
3265
|
|
|
3364
3266
|
result
|
|
3365
|
-
|
|
3366
|
-
.,.,
|
|
3267
|
+
end
|
|
3367
3268
|
|
|
3368
|
-
|
|
3369
|
-
|
|
3370
|
-
result = new_call val[0], val[2].to_sym, val[3]
|
|
3269
|
+
def _reduce_55(val, _values, result)
|
|
3270
|
+
result = new_call val[0], val[2].to_sym, val[3]
|
|
3371
3271
|
|
|
3372
3272
|
result
|
|
3373
|
-
|
|
3374
|
-
.,.,
|
|
3273
|
+
end
|
|
3375
3274
|
|
|
3376
|
-
|
|
3377
|
-
|
|
3378
|
-
result = new_call val[0], val[2].to_sym, val[3]
|
|
3275
|
+
def _reduce_56(val, _values, result)
|
|
3276
|
+
result = new_call val[0], val[2].to_sym, val[3]
|
|
3379
3277
|
|
|
3380
3278
|
result
|
|
3381
|
-
|
|
3382
|
-
.,.,
|
|
3279
|
+
end
|
|
3383
3280
|
|
|
3384
|
-
|
|
3385
|
-
|
|
3386
|
-
result = new_call val[0], val[2].to_sym, val[3]
|
|
3281
|
+
def _reduce_57(val, _values, result)
|
|
3282
|
+
result = new_call val[0], val[2].to_sym, val[3]
|
|
3387
3283
|
|
|
3388
3284
|
result
|
|
3389
|
-
|
|
3390
|
-
.,.,
|
|
3285
|
+
end
|
|
3391
3286
|
|
|
3392
|
-
|
|
3393
|
-
|
|
3394
|
-
result = new_call val[0], val[2].to_sym, val[3]
|
|
3287
|
+
def _reduce_58(val, _values, result)
|
|
3288
|
+
result = new_call val[0], val[2].to_sym, val[3]
|
|
3395
3289
|
if val[4] then
|
|
3396
3290
|
if result[0] == :block_pass then # REFACTOR
|
|
3397
3291
|
raise "both block arg and actual block given"
|
|
@@ -3401,296 +3295,229 @@ module_eval(<<'.,.,', 'ruby_parser.y', 282)
|
|
|
3401
3295
|
end
|
|
3402
3296
|
|
|
3403
3297
|
result
|
|
3404
|
-
|
|
3405
|
-
.,.,
|
|
3298
|
+
end
|
|
3406
3299
|
|
|
3407
|
-
|
|
3408
|
-
|
|
3409
|
-
result = new_super val[1]
|
|
3300
|
+
def _reduce_59(val, _values, result)
|
|
3301
|
+
result = new_super val[1]
|
|
3410
3302
|
|
|
3411
3303
|
result
|
|
3412
|
-
|
|
3413
|
-
.,.,
|
|
3304
|
+
end
|
|
3414
3305
|
|
|
3415
|
-
|
|
3416
|
-
|
|
3417
|
-
result = new_yield val[1]
|
|
3306
|
+
def _reduce_60(val, _values, result)
|
|
3307
|
+
result = new_yield val[1]
|
|
3418
3308
|
|
|
3419
3309
|
result
|
|
3420
|
-
|
|
3421
|
-
.,.,
|
|
3310
|
+
end
|
|
3422
3311
|
|
|
3423
3312
|
# reduce 61 omitted
|
|
3424
3313
|
|
|
3425
|
-
|
|
3426
|
-
|
|
3427
|
-
result = val[1]
|
|
3314
|
+
def _reduce_62(val, _values, result)
|
|
3315
|
+
result = val[1]
|
|
3428
3316
|
|
|
3429
3317
|
result
|
|
3430
|
-
|
|
3431
|
-
.,.,
|
|
3318
|
+
end
|
|
3432
3319
|
|
|
3433
3320
|
# reduce 63 omitted
|
|
3434
3321
|
|
|
3435
|
-
|
|
3436
|
-
|
|
3437
|
-
result = s(:masgn, s(:array, val[1]))
|
|
3322
|
+
def _reduce_64(val, _values, result)
|
|
3323
|
+
result = s(:masgn, s(:array, val[1]))
|
|
3438
3324
|
|
|
3439
3325
|
result
|
|
3440
|
-
|
|
3441
|
-
.,.,
|
|
3326
|
+
end
|
|
3442
3327
|
|
|
3443
|
-
|
|
3444
|
-
|
|
3445
|
-
result = s(:masgn, val[0])
|
|
3328
|
+
def _reduce_65(val, _values, result)
|
|
3329
|
+
result = s(:masgn, val[0])
|
|
3446
3330
|
|
|
3447
3331
|
result
|
|
3448
|
-
|
|
3449
|
-
.,.,
|
|
3332
|
+
end
|
|
3450
3333
|
|
|
3451
|
-
|
|
3452
|
-
|
|
3453
|
-
result = s(:masgn, val[0] << val[1].compact)
|
|
3334
|
+
def _reduce_66(val, _values, result)
|
|
3335
|
+
result = s(:masgn, val[0] << val[1].compact)
|
|
3454
3336
|
|
|
3455
3337
|
result
|
|
3456
|
-
|
|
3457
|
-
.,.,
|
|
3338
|
+
end
|
|
3458
3339
|
|
|
3459
|
-
|
|
3460
|
-
|
|
3461
|
-
result = s(:masgn, val[0] << s(:splat, val[2]))
|
|
3340
|
+
def _reduce_67(val, _values, result)
|
|
3341
|
+
result = s(:masgn, val[0] << s(:splat, val[2]))
|
|
3462
3342
|
|
|
3463
3343
|
result
|
|
3464
|
-
|
|
3465
|
-
.,.,
|
|
3344
|
+
end
|
|
3466
3345
|
|
|
3467
|
-
|
|
3468
|
-
|
|
3469
|
-
result = s(:masgn, val[0] << s(:splat))
|
|
3346
|
+
def _reduce_68(val, _values, result)
|
|
3347
|
+
result = s(:masgn, val[0] << s(:splat))
|
|
3470
3348
|
|
|
3471
3349
|
result
|
|
3472
|
-
|
|
3473
|
-
.,.,
|
|
3350
|
+
end
|
|
3474
3351
|
|
|
3475
|
-
|
|
3476
|
-
|
|
3477
|
-
result = s(:masgn, s(:array, s(:splat, val[1])))
|
|
3352
|
+
def _reduce_69(val, _values, result)
|
|
3353
|
+
result = s(:masgn, s(:array, s(:splat, val[1])))
|
|
3478
3354
|
|
|
3479
3355
|
result
|
|
3480
|
-
|
|
3481
|
-
.,.,
|
|
3356
|
+
end
|
|
3482
3357
|
|
|
3483
|
-
|
|
3484
|
-
|
|
3485
|
-
result = s(:masgn, s(:array, s(:splat)))
|
|
3358
|
+
def _reduce_70(val, _values, result)
|
|
3359
|
+
result = s(:masgn, s(:array, s(:splat)))
|
|
3486
3360
|
|
|
3487
3361
|
result
|
|
3488
|
-
|
|
3489
|
-
.,.,
|
|
3362
|
+
end
|
|
3490
3363
|
|
|
3491
3364
|
# reduce 71 omitted
|
|
3492
3365
|
|
|
3493
|
-
|
|
3494
|
-
|
|
3495
|
-
result = val[1]
|
|
3366
|
+
def _reduce_72(val, _values, result)
|
|
3367
|
+
result = val[1]
|
|
3496
3368
|
|
|
3497
3369
|
result
|
|
3498
|
-
|
|
3499
|
-
.,.,
|
|
3370
|
+
end
|
|
3500
3371
|
|
|
3501
|
-
|
|
3502
|
-
|
|
3503
|
-
result = s(:array, val[0])
|
|
3372
|
+
def _reduce_73(val, _values, result)
|
|
3373
|
+
result = s(:array, val[0])
|
|
3504
3374
|
|
|
3505
3375
|
result
|
|
3506
|
-
|
|
3507
|
-
.,.,
|
|
3376
|
+
end
|
|
3508
3377
|
|
|
3509
|
-
|
|
3510
|
-
|
|
3511
|
-
result = val[0] << val[1].compact
|
|
3378
|
+
def _reduce_74(val, _values, result)
|
|
3379
|
+
result = val[0] << val[1].compact
|
|
3512
3380
|
|
|
3513
3381
|
result
|
|
3514
|
-
|
|
3515
|
-
.,.,
|
|
3382
|
+
end
|
|
3516
3383
|
|
|
3517
|
-
|
|
3518
|
-
|
|
3519
|
-
result = self.assignable val[0]
|
|
3384
|
+
def _reduce_75(val, _values, result)
|
|
3385
|
+
result = self.assignable val[0]
|
|
3520
3386
|
|
|
3521
3387
|
result
|
|
3522
|
-
|
|
3523
|
-
.,.,
|
|
3388
|
+
end
|
|
3524
3389
|
|
|
3525
|
-
|
|
3526
|
-
|
|
3527
|
-
result = self.aryset val[0], val[2]
|
|
3390
|
+
def _reduce_76(val, _values, result)
|
|
3391
|
+
result = self.aryset val[0], val[2]
|
|
3528
3392
|
|
|
3529
3393
|
result
|
|
3530
|
-
|
|
3531
|
-
.,.,
|
|
3394
|
+
end
|
|
3532
3395
|
|
|
3533
|
-
|
|
3534
|
-
|
|
3535
|
-
result = s(:attrasgn, val[0], :"#{val[2]}=", s(:arglist))
|
|
3396
|
+
def _reduce_77(val, _values, result)
|
|
3397
|
+
result = s(:attrasgn, val[0], :"#{val[2]}=", s(:arglist))
|
|
3536
3398
|
|
|
3537
3399
|
result
|
|
3538
|
-
|
|
3539
|
-
.,.,
|
|
3400
|
+
end
|
|
3540
3401
|
|
|
3541
|
-
|
|
3542
|
-
|
|
3543
|
-
result = s(:attrasgn, val[0], :"#{val[2]}=", s(:arglist))
|
|
3402
|
+
def _reduce_78(val, _values, result)
|
|
3403
|
+
result = s(:attrasgn, val[0], :"#{val[2]}=", s(:arglist))
|
|
3544
3404
|
|
|
3545
3405
|
result
|
|
3546
|
-
|
|
3547
|
-
.,.,
|
|
3406
|
+
end
|
|
3548
3407
|
|
|
3549
|
-
|
|
3550
|
-
|
|
3551
|
-
result = s(:attrasgn, val[0], :"#{val[2]}=", s(:arglist))
|
|
3408
|
+
def _reduce_79(val, _values, result)
|
|
3409
|
+
result = s(:attrasgn, val[0], :"#{val[2]}=", s(:arglist))
|
|
3552
3410
|
|
|
3553
3411
|
result
|
|
3554
|
-
|
|
3555
|
-
.,.,
|
|
3412
|
+
end
|
|
3556
3413
|
|
|
3557
|
-
|
|
3558
|
-
|
|
3559
|
-
if (self.in_def || self.in_single > 0) then
|
|
3414
|
+
def _reduce_80(val, _values, result)
|
|
3415
|
+
if (self.in_def || self.in_single > 0) then
|
|
3560
3416
|
yyerror "dynamic constant assignment"
|
|
3561
3417
|
end
|
|
3562
3418
|
|
|
3563
3419
|
result = s(:const, s(:colon2, val[0], val[2].to_sym), nil)
|
|
3564
3420
|
|
|
3565
3421
|
result
|
|
3566
|
-
|
|
3567
|
-
.,.,
|
|
3422
|
+
end
|
|
3568
3423
|
|
|
3569
|
-
|
|
3570
|
-
|
|
3571
|
-
if (self.in_def || self.in_single > 0) then
|
|
3424
|
+
def _reduce_81(val, _values, result)
|
|
3425
|
+
if (self.in_def || self.in_single > 0) then
|
|
3572
3426
|
yyerror "dynamic constant assignment"
|
|
3573
3427
|
end
|
|
3574
3428
|
|
|
3575
3429
|
result = s(:const, nil, s(:colon3, val[1].to_sym))
|
|
3576
3430
|
|
|
3577
3431
|
result
|
|
3578
|
-
|
|
3579
|
-
.,.,
|
|
3432
|
+
end
|
|
3580
3433
|
|
|
3581
|
-
|
|
3582
|
-
|
|
3583
|
-
self.backref_assign_error val[0]
|
|
3434
|
+
def _reduce_82(val, _values, result)
|
|
3435
|
+
self.backref_assign_error val[0]
|
|
3584
3436
|
|
|
3585
3437
|
result
|
|
3586
|
-
|
|
3587
|
-
.,.,
|
|
3438
|
+
end
|
|
3588
3439
|
|
|
3589
|
-
|
|
3590
|
-
|
|
3591
|
-
result = self.assignable val[0]
|
|
3440
|
+
def _reduce_83(val, _values, result)
|
|
3441
|
+
result = self.assignable val[0]
|
|
3592
3442
|
|
|
3593
3443
|
result
|
|
3594
|
-
|
|
3595
|
-
.,.,
|
|
3444
|
+
end
|
|
3596
3445
|
|
|
3597
|
-
|
|
3598
|
-
|
|
3599
|
-
result = self.aryset val[0], val[2]
|
|
3446
|
+
def _reduce_84(val, _values, result)
|
|
3447
|
+
result = self.aryset val[0], val[2]
|
|
3600
3448
|
|
|
3601
3449
|
result
|
|
3602
|
-
|
|
3603
|
-
.,.,
|
|
3450
|
+
end
|
|
3604
3451
|
|
|
3605
|
-
|
|
3606
|
-
|
|
3607
|
-
result = s(:attrasgn, val[0], :"#{val[2]}=")
|
|
3452
|
+
def _reduce_85(val, _values, result)
|
|
3453
|
+
result = s(:attrasgn, val[0], :"#{val[2]}=")
|
|
3608
3454
|
|
|
3609
3455
|
result
|
|
3610
|
-
|
|
3611
|
-
.,.,
|
|
3456
|
+
end
|
|
3612
3457
|
|
|
3613
|
-
|
|
3614
|
-
|
|
3615
|
-
result = s(:attrasgn, val[0], :"#{val[2]}=")
|
|
3458
|
+
def _reduce_86(val, _values, result)
|
|
3459
|
+
result = s(:attrasgn, val[0], :"#{val[2]}=")
|
|
3616
3460
|
|
|
3617
3461
|
result
|
|
3618
|
-
|
|
3619
|
-
.,.,
|
|
3462
|
+
end
|
|
3620
3463
|
|
|
3621
|
-
|
|
3622
|
-
|
|
3623
|
-
result = s(:attrasgn, val[0], :"#{val[2]}=")
|
|
3464
|
+
def _reduce_87(val, _values, result)
|
|
3465
|
+
result = s(:attrasgn, val[0], :"#{val[2]}=")
|
|
3624
3466
|
|
|
3625
3467
|
result
|
|
3626
|
-
|
|
3627
|
-
.,.,
|
|
3468
|
+
end
|
|
3628
3469
|
|
|
3629
|
-
|
|
3630
|
-
|
|
3631
|
-
if (self.in_def || self.in_single > 0) then
|
|
3470
|
+
def _reduce_88(val, _values, result)
|
|
3471
|
+
if (self.in_def || self.in_single > 0) then
|
|
3632
3472
|
yyerror "dynamic constant assignment"
|
|
3633
3473
|
end
|
|
3634
3474
|
|
|
3635
3475
|
result = s(:const, s(:colon2, val[0], val[2].to_sym))
|
|
3636
3476
|
|
|
3637
3477
|
result
|
|
3638
|
-
|
|
3639
|
-
.,.,
|
|
3478
|
+
end
|
|
3640
3479
|
|
|
3641
|
-
|
|
3642
|
-
|
|
3643
|
-
if (self.in_def || self.in_single > 0) then
|
|
3480
|
+
def _reduce_89(val, _values, result)
|
|
3481
|
+
if (self.in_def || self.in_single > 0) then
|
|
3644
3482
|
yyerror "dynamic constant assignment"
|
|
3645
3483
|
end
|
|
3646
3484
|
|
|
3647
3485
|
result = s(:const, s(:colon3, val[1].to_sym))
|
|
3648
3486
|
|
|
3649
3487
|
result
|
|
3650
|
-
|
|
3651
|
-
.,.,
|
|
3488
|
+
end
|
|
3652
3489
|
|
|
3653
|
-
|
|
3654
|
-
|
|
3655
|
-
self.backref_assign_error val[0]
|
|
3490
|
+
def _reduce_90(val, _values, result)
|
|
3491
|
+
self.backref_assign_error val[0]
|
|
3656
3492
|
|
|
3657
3493
|
result
|
|
3658
|
-
|
|
3659
|
-
.,.,
|
|
3494
|
+
end
|
|
3660
3495
|
|
|
3661
|
-
|
|
3662
|
-
|
|
3663
|
-
yyerror "class/module name must be CONSTANT"
|
|
3496
|
+
def _reduce_91(val, _values, result)
|
|
3497
|
+
yyerror "class/module name must be CONSTANT"
|
|
3664
3498
|
|
|
3665
3499
|
result
|
|
3666
|
-
|
|
3667
|
-
.,.,
|
|
3500
|
+
end
|
|
3668
3501
|
|
|
3669
3502
|
# reduce 92 omitted
|
|
3670
3503
|
|
|
3671
|
-
|
|
3672
|
-
|
|
3673
|
-
result = s(:colon3, val[1].to_sym)
|
|
3504
|
+
def _reduce_93(val, _values, result)
|
|
3505
|
+
result = s(:colon3, val[1].to_sym)
|
|
3674
3506
|
|
|
3675
3507
|
result
|
|
3676
|
-
|
|
3677
|
-
.,.,
|
|
3508
|
+
end
|
|
3678
3509
|
|
|
3679
|
-
|
|
3680
|
-
|
|
3681
|
-
result = val[0].to_sym
|
|
3510
|
+
def _reduce_94(val, _values, result)
|
|
3511
|
+
result = val[0].to_sym
|
|
3682
3512
|
|
|
3683
3513
|
result
|
|
3684
|
-
|
|
3685
|
-
.,.,
|
|
3514
|
+
end
|
|
3686
3515
|
|
|
3687
|
-
|
|
3688
|
-
|
|
3689
|
-
result = s(:colon2, val[0], val[2].to_sym)
|
|
3516
|
+
def _reduce_95(val, _values, result)
|
|
3517
|
+
result = s(:colon2, val[0], val[2].to_sym)
|
|
3690
3518
|
|
|
3691
3519
|
result
|
|
3692
|
-
|
|
3693
|
-
.,.,
|
|
3520
|
+
end
|
|
3694
3521
|
|
|
3695
3522
|
# reduce 96 omitted
|
|
3696
3523
|
|
|
@@ -3698,60 +3525,48 @@ module_eval(<<'.,.,', 'ruby_parser.y', 450)
|
|
|
3698
3525
|
|
|
3699
3526
|
# reduce 98 omitted
|
|
3700
3527
|
|
|
3701
|
-
|
|
3702
|
-
|
|
3703
|
-
lexer.lex_state = :expr_end
|
|
3528
|
+
def _reduce_99(val, _values, result)
|
|
3529
|
+
lexer.lex_state = :expr_end
|
|
3704
3530
|
result = val[0]
|
|
3705
3531
|
|
|
3706
3532
|
result
|
|
3707
|
-
|
|
3708
|
-
.,.,
|
|
3533
|
+
end
|
|
3709
3534
|
|
|
3710
|
-
|
|
3711
|
-
|
|
3712
|
-
lexer.lex_state = :expr_end
|
|
3535
|
+
def _reduce_100(val, _values, result)
|
|
3536
|
+
lexer.lex_state = :expr_end
|
|
3713
3537
|
result = val[0]
|
|
3714
3538
|
|
|
3715
3539
|
result
|
|
3716
|
-
|
|
3717
|
-
.,.,
|
|
3540
|
+
end
|
|
3718
3541
|
|
|
3719
3542
|
# reduce 101 omitted
|
|
3720
3543
|
|
|
3721
3544
|
# reduce 102 omitted
|
|
3722
3545
|
|
|
3723
|
-
|
|
3724
|
-
|
|
3725
|
-
result = s(:lit, val[0].to_sym)
|
|
3546
|
+
def _reduce_103(val, _values, result)
|
|
3547
|
+
result = s(:lit, val[0].to_sym)
|
|
3726
3548
|
result
|
|
3727
|
-
|
|
3728
|
-
.,.,
|
|
3549
|
+
end
|
|
3729
3550
|
|
|
3730
3551
|
# reduce 104 omitted
|
|
3731
3552
|
|
|
3732
|
-
|
|
3733
|
-
|
|
3734
|
-
result = new_undef val[0]
|
|
3553
|
+
def _reduce_105(val, _values, result)
|
|
3554
|
+
result = new_undef val[0]
|
|
3735
3555
|
|
|
3736
3556
|
result
|
|
3737
|
-
|
|
3738
|
-
.,.,
|
|
3557
|
+
end
|
|
3739
3558
|
|
|
3740
|
-
|
|
3741
|
-
|
|
3742
|
-
lexer.lex_state = :expr_fname
|
|
3559
|
+
def _reduce_106(val, _values, result)
|
|
3560
|
+
lexer.lex_state = :expr_fname
|
|
3743
3561
|
|
|
3744
3562
|
result
|
|
3745
|
-
|
|
3746
|
-
.,.,
|
|
3563
|
+
end
|
|
3747
3564
|
|
|
3748
|
-
|
|
3749
|
-
|
|
3750
|
-
result = new_undef val[0], val[3]
|
|
3565
|
+
def _reduce_107(val, _values, result)
|
|
3566
|
+
result = new_undef val[0], val[3]
|
|
3751
3567
|
|
|
3752
3568
|
result
|
|
3753
|
-
|
|
3754
|
-
.,.,
|
|
3569
|
+
end
|
|
3755
3570
|
|
|
3756
3571
|
# reduce 108 omitted
|
|
3757
3572
|
|
|
@@ -3887,91 +3702,70 @@ module_eval(<<'.,.,', 'ruby_parser.y', 482)
|
|
|
3887
3702
|
|
|
3888
3703
|
# reduce 174 omitted
|
|
3889
3704
|
|
|
3890
|
-
|
|
3891
|
-
|
|
3892
|
-
result = self.node_assign val[0], val[2]
|
|
3705
|
+
def _reduce_175(val, _values, result)
|
|
3706
|
+
result = self.node_assign val[0], val[2]
|
|
3893
3707
|
|
|
3894
3708
|
result
|
|
3895
|
-
|
|
3896
|
-
.,.,
|
|
3709
|
+
end
|
|
3897
3710
|
|
|
3898
|
-
|
|
3899
|
-
|
|
3900
|
-
result = self.node_assign val[0], s(:rescue, val[2], s(:resbody, s(:array), val[4]))
|
|
3711
|
+
def _reduce_176(val, _values, result)
|
|
3712
|
+
result = self.node_assign val[0], s(:rescue, val[2], s(:resbody, s(:array), val[4]))
|
|
3901
3713
|
# result.line = val[0].line
|
|
3902
3714
|
|
|
3903
3715
|
result
|
|
3904
|
-
|
|
3905
|
-
.,.,
|
|
3716
|
+
end
|
|
3906
3717
|
|
|
3907
|
-
|
|
3908
|
-
|
|
3909
|
-
result = new_op_asgn val
|
|
3718
|
+
def _reduce_177(val, _values, result)
|
|
3719
|
+
result = new_op_asgn val
|
|
3910
3720
|
|
|
3911
3721
|
result
|
|
3912
|
-
|
|
3913
|
-
.,.,
|
|
3722
|
+
end
|
|
3914
3723
|
|
|
3915
|
-
|
|
3916
|
-
|
|
3917
|
-
result = s(:op_asgn1, val[0], val[2], val[4].to_sym, val[5])
|
|
3724
|
+
def _reduce_178(val, _values, result)
|
|
3725
|
+
result = s(:op_asgn1, val[0], val[2], val[4].to_sym, val[5])
|
|
3918
3726
|
val[2][0] = :arglist
|
|
3919
3727
|
|
|
3920
3728
|
result
|
|
3921
|
-
|
|
3922
|
-
.,.,
|
|
3729
|
+
end
|
|
3923
3730
|
|
|
3924
|
-
|
|
3925
|
-
|
|
3926
|
-
result = s(:op_asgn2, val[0], :"#{val[2]}=", val[3].to_sym, val[4])
|
|
3731
|
+
def _reduce_179(val, _values, result)
|
|
3732
|
+
result = s(:op_asgn2, val[0], :"#{val[2]}=", val[3].to_sym, val[4])
|
|
3927
3733
|
|
|
3928
3734
|
result
|
|
3929
|
-
|
|
3930
|
-
.,.,
|
|
3735
|
+
end
|
|
3931
3736
|
|
|
3932
|
-
|
|
3933
|
-
|
|
3934
|
-
result = s(:op_asgn2, val[0], :"#{val[2]}=", val[3].to_sym, val[4])
|
|
3737
|
+
def _reduce_180(val, _values, result)
|
|
3738
|
+
result = s(:op_asgn2, val[0], :"#{val[2]}=", val[3].to_sym, val[4])
|
|
3935
3739
|
|
|
3936
3740
|
result
|
|
3937
|
-
|
|
3938
|
-
.,.,
|
|
3741
|
+
end
|
|
3939
3742
|
|
|
3940
|
-
|
|
3941
|
-
|
|
3942
|
-
result = s(:op_asgn, val[0], val[4], val[2], val[3])
|
|
3743
|
+
def _reduce_181(val, _values, result)
|
|
3744
|
+
result = s(:op_asgn, val[0], val[4], val[2], val[3])
|
|
3943
3745
|
|
|
3944
3746
|
result
|
|
3945
|
-
|
|
3946
|
-
.,.,
|
|
3747
|
+
end
|
|
3947
3748
|
|
|
3948
|
-
|
|
3949
|
-
|
|
3950
|
-
yyerror "constant re-assignment"
|
|
3749
|
+
def _reduce_182(val, _values, result)
|
|
3750
|
+
yyerror "constant re-assignment"
|
|
3951
3751
|
|
|
3952
3752
|
result
|
|
3953
|
-
|
|
3954
|
-
.,.,
|
|
3753
|
+
end
|
|
3955
3754
|
|
|
3956
|
-
|
|
3957
|
-
|
|
3958
|
-
yyerror "constant re-assignment"
|
|
3755
|
+
def _reduce_183(val, _values, result)
|
|
3756
|
+
yyerror "constant re-assignment"
|
|
3959
3757
|
|
|
3960
3758
|
result
|
|
3961
|
-
|
|
3962
|
-
.,.,
|
|
3759
|
+
end
|
|
3963
3760
|
|
|
3964
|
-
|
|
3965
|
-
|
|
3966
|
-
self.backref_assign_error val[0]
|
|
3761
|
+
def _reduce_184(val, _values, result)
|
|
3762
|
+
self.backref_assign_error val[0]
|
|
3967
3763
|
|
|
3968
3764
|
result
|
|
3969
|
-
|
|
3970
|
-
.,.,
|
|
3765
|
+
end
|
|
3971
3766
|
|
|
3972
|
-
|
|
3973
|
-
|
|
3974
|
-
v1, v2 = val[0], val[2]
|
|
3767
|
+
def _reduce_185(val, _values, result)
|
|
3768
|
+
v1, v2 = val[0], val[2]
|
|
3975
3769
|
if v1.node_type == :lit and v2.node_type == :lit and Fixnum === v1.last and Fixnum === v2.last then
|
|
3976
3770
|
result = s(:lit, (v1.last)..(v2.last))
|
|
3977
3771
|
else
|
|
@@ -3979,12 +3773,10 @@ module_eval(<<'.,.,', 'ruby_parser.y', 544)
|
|
|
3979
3773
|
end
|
|
3980
3774
|
|
|
3981
3775
|
result
|
|
3982
|
-
|
|
3983
|
-
.,.,
|
|
3776
|
+
end
|
|
3984
3777
|
|
|
3985
|
-
|
|
3986
|
-
|
|
3987
|
-
v1, v2 = val[0], val[2]
|
|
3778
|
+
def _reduce_186(val, _values, result)
|
|
3779
|
+
v1, v2 = val[0], val[2]
|
|
3988
3780
|
if v1.node_type == :lit and v2.node_type == :lit and Fixnum === v1.last and Fixnum === v2.last then
|
|
3989
3781
|
result = s(:lit, (v1.last)...(v2.last))
|
|
3990
3782
|
else
|
|
@@ -3992,642 +3784,495 @@ module_eval(<<'.,.,', 'ruby_parser.y', 553)
|
|
|
3992
3784
|
end
|
|
3993
3785
|
|
|
3994
3786
|
result
|
|
3995
|
-
|
|
3996
|
-
.,.,
|
|
3787
|
+
end
|
|
3997
3788
|
|
|
3998
|
-
|
|
3999
|
-
|
|
4000
|
-
result = new_call val[0], :+, s(:arglist, val[2])
|
|
3789
|
+
def _reduce_187(val, _values, result)
|
|
3790
|
+
result = new_call val[0], :+, s(:arglist, val[2])
|
|
4001
3791
|
|
|
4002
3792
|
result
|
|
4003
|
-
|
|
4004
|
-
.,.,
|
|
3793
|
+
end
|
|
4005
3794
|
|
|
4006
|
-
|
|
4007
|
-
|
|
4008
|
-
result = new_call val[0], :-, s(:arglist, val[2])
|
|
3795
|
+
def _reduce_188(val, _values, result)
|
|
3796
|
+
result = new_call val[0], :-, s(:arglist, val[2])
|
|
4009
3797
|
|
|
4010
3798
|
result
|
|
4011
|
-
|
|
4012
|
-
.,.,
|
|
3799
|
+
end
|
|
4013
3800
|
|
|
4014
|
-
|
|
4015
|
-
|
|
4016
|
-
result = new_call val[0], :*, s(:arglist, val[2])
|
|
3801
|
+
def _reduce_189(val, _values, result)
|
|
3802
|
+
result = new_call val[0], :*, s(:arglist, val[2])
|
|
4017
3803
|
|
|
4018
3804
|
result
|
|
4019
|
-
|
|
4020
|
-
.,.,
|
|
3805
|
+
end
|
|
4021
3806
|
|
|
4022
|
-
|
|
4023
|
-
|
|
4024
|
-
result = new_call val[0], :"/", s(:arglist, val[2])
|
|
3807
|
+
def _reduce_190(val, _values, result)
|
|
3808
|
+
result = new_call val[0], :"/", s(:arglist, val[2])
|
|
4025
3809
|
|
|
4026
3810
|
result
|
|
4027
|
-
|
|
4028
|
-
.,.,
|
|
3811
|
+
end
|
|
4029
3812
|
|
|
4030
|
-
|
|
4031
|
-
|
|
4032
|
-
result = new_call val[0], :%, s(:arglist, val[2])
|
|
3813
|
+
def _reduce_191(val, _values, result)
|
|
3814
|
+
result = new_call val[0], :%, s(:arglist, val[2])
|
|
4033
3815
|
|
|
4034
3816
|
result
|
|
4035
|
-
|
|
4036
|
-
.,.,
|
|
3817
|
+
end
|
|
4037
3818
|
|
|
4038
|
-
|
|
4039
|
-
|
|
4040
|
-
result = new_call val[0], :**, s(:arglist, val[2])
|
|
3819
|
+
def _reduce_192(val, _values, result)
|
|
3820
|
+
result = new_call val[0], :**, s(:arglist, val[2])
|
|
4041
3821
|
|
|
4042
3822
|
result
|
|
4043
|
-
|
|
4044
|
-
.,.,
|
|
3823
|
+
end
|
|
4045
3824
|
|
|
4046
|
-
|
|
4047
|
-
|
|
4048
|
-
result = new_call(new_call(s(:lit, val[1]), :"**", s(:arglist, val[3])), :"-@", s(:arglist))
|
|
3825
|
+
def _reduce_193(val, _values, result)
|
|
3826
|
+
result = new_call(new_call(s(:lit, val[1]), :"**", s(:arglist, val[3])), :"-@", s(:arglist))
|
|
4049
3827
|
|
|
4050
3828
|
result
|
|
4051
|
-
|
|
4052
|
-
.,.,
|
|
3829
|
+
end
|
|
4053
3830
|
|
|
4054
|
-
|
|
4055
|
-
|
|
4056
|
-
result = new_call(new_call(s(:lit, val[1]), :"**", s(:arglist, val[3])), :"-@", s(:arglist))
|
|
3831
|
+
def _reduce_194(val, _values, result)
|
|
3832
|
+
result = new_call(new_call(s(:lit, val[1]), :"**", s(:arglist, val[3])), :"-@", s(:arglist))
|
|
4057
3833
|
|
|
4058
3834
|
result
|
|
4059
|
-
|
|
4060
|
-
.,.,
|
|
3835
|
+
end
|
|
4061
3836
|
|
|
4062
|
-
|
|
4063
|
-
|
|
4064
|
-
if val[1][0] == :lit then
|
|
3837
|
+
def _reduce_195(val, _values, result)
|
|
3838
|
+
if val[1][0] == :lit then
|
|
4065
3839
|
result = val[1]
|
|
4066
3840
|
else
|
|
4067
3841
|
result = new_call val[1], :"+@", s(:arglist)
|
|
4068
3842
|
end
|
|
4069
3843
|
|
|
4070
3844
|
result
|
|
4071
|
-
|
|
4072
|
-
.,.,
|
|
3845
|
+
end
|
|
4073
3846
|
|
|
4074
|
-
|
|
4075
|
-
|
|
4076
|
-
result = new_call val[1], :"-@", s(:arglist)
|
|
3847
|
+
def _reduce_196(val, _values, result)
|
|
3848
|
+
result = new_call val[1], :"-@", s(:arglist)
|
|
4077
3849
|
|
|
4078
3850
|
result
|
|
4079
|
-
|
|
4080
|
-
.,.,
|
|
3851
|
+
end
|
|
4081
3852
|
|
|
4082
|
-
|
|
4083
|
-
|
|
4084
|
-
result = new_call val[0], :"|", s(:arglist, val[2])
|
|
3853
|
+
def _reduce_197(val, _values, result)
|
|
3854
|
+
result = new_call val[0], :"|", s(:arglist, val[2])
|
|
4085
3855
|
|
|
4086
3856
|
result
|
|
4087
|
-
|
|
4088
|
-
.,.,
|
|
3857
|
+
end
|
|
4089
3858
|
|
|
4090
|
-
|
|
4091
|
-
|
|
4092
|
-
result = new_call val[0], :"^", s(:arglist, val[2])
|
|
3859
|
+
def _reduce_198(val, _values, result)
|
|
3860
|
+
result = new_call val[0], :"^", s(:arglist, val[2])
|
|
4093
3861
|
|
|
4094
3862
|
result
|
|
4095
|
-
|
|
4096
|
-
.,.,
|
|
3863
|
+
end
|
|
4097
3864
|
|
|
4098
|
-
|
|
4099
|
-
|
|
4100
|
-
result = new_call val[0], :"&", s(:arglist, val[2])
|
|
3865
|
+
def _reduce_199(val, _values, result)
|
|
3866
|
+
result = new_call val[0], :"&", s(:arglist, val[2])
|
|
4101
3867
|
|
|
4102
3868
|
result
|
|
4103
|
-
|
|
4104
|
-
.,.,
|
|
3869
|
+
end
|
|
4105
3870
|
|
|
4106
|
-
|
|
4107
|
-
|
|
4108
|
-
result = new_call val[0], :"<=>", s(:arglist, val[2])
|
|
3871
|
+
def _reduce_200(val, _values, result)
|
|
3872
|
+
result = new_call val[0], :"<=>", s(:arglist, val[2])
|
|
4109
3873
|
|
|
4110
3874
|
result
|
|
4111
|
-
|
|
4112
|
-
.,.,
|
|
3875
|
+
end
|
|
4113
3876
|
|
|
4114
|
-
|
|
4115
|
-
|
|
4116
|
-
result = new_call val[0], :">", s(:arglist, val[2])
|
|
3877
|
+
def _reduce_201(val, _values, result)
|
|
3878
|
+
result = new_call val[0], :">", s(:arglist, val[2])
|
|
4117
3879
|
|
|
4118
3880
|
result
|
|
4119
|
-
|
|
4120
|
-
.,.,
|
|
3881
|
+
end
|
|
4121
3882
|
|
|
4122
|
-
|
|
4123
|
-
|
|
4124
|
-
result = new_call val[0], :">=", s(:arglist, val[2])
|
|
3883
|
+
def _reduce_202(val, _values, result)
|
|
3884
|
+
result = new_call val[0], :">=", s(:arglist, val[2])
|
|
4125
3885
|
|
|
4126
3886
|
result
|
|
4127
|
-
|
|
4128
|
-
.,.,
|
|
3887
|
+
end
|
|
4129
3888
|
|
|
4130
|
-
|
|
4131
|
-
|
|
4132
|
-
result = new_call val[0], :"<", s(:arglist, val[2])
|
|
3889
|
+
def _reduce_203(val, _values, result)
|
|
3890
|
+
result = new_call val[0], :"<", s(:arglist, val[2])
|
|
4133
3891
|
|
|
4134
3892
|
result
|
|
4135
|
-
|
|
4136
|
-
.,.,
|
|
3893
|
+
end
|
|
4137
3894
|
|
|
4138
|
-
|
|
4139
|
-
|
|
4140
|
-
result = new_call val[0], :"<=", s(:arglist, val[2])
|
|
3895
|
+
def _reduce_204(val, _values, result)
|
|
3896
|
+
result = new_call val[0], :"<=", s(:arglist, val[2])
|
|
4141
3897
|
|
|
4142
3898
|
result
|
|
4143
|
-
|
|
4144
|
-
.,.,
|
|
3899
|
+
end
|
|
4145
3900
|
|
|
4146
|
-
|
|
4147
|
-
|
|
4148
|
-
result = new_call val[0], :"==", s(:arglist, val[2])
|
|
3901
|
+
def _reduce_205(val, _values, result)
|
|
3902
|
+
result = new_call val[0], :"==", s(:arglist, val[2])
|
|
4149
3903
|
|
|
4150
3904
|
result
|
|
4151
|
-
|
|
4152
|
-
.,.,
|
|
3905
|
+
end
|
|
4153
3906
|
|
|
4154
|
-
|
|
4155
|
-
|
|
4156
|
-
result = new_call val[0], :"===", s(:arglist, val[2])
|
|
3907
|
+
def _reduce_206(val, _values, result)
|
|
3908
|
+
result = new_call val[0], :"===", s(:arglist, val[2])
|
|
4157
3909
|
|
|
4158
3910
|
result
|
|
4159
|
-
|
|
4160
|
-
.,.,
|
|
3911
|
+
end
|
|
4161
3912
|
|
|
4162
|
-
|
|
4163
|
-
|
|
4164
|
-
val[0] = value_expr val[0] # TODO: port call_op and clean these
|
|
3913
|
+
def _reduce_207(val, _values, result)
|
|
3914
|
+
val[0] = value_expr val[0] # TODO: port call_op and clean these
|
|
4165
3915
|
val[2] = value_expr val[2]
|
|
4166
3916
|
result = s(:not, new_call(val[0], :"==", s(:arglist, val[2])))
|
|
4167
3917
|
|
|
4168
3918
|
result
|
|
4169
|
-
|
|
4170
|
-
.,.,
|
|
3919
|
+
end
|
|
4171
3920
|
|
|
4172
|
-
|
|
4173
|
-
|
|
4174
|
-
result = self.get_match_node val[0], val[2]
|
|
3921
|
+
def _reduce_208(val, _values, result)
|
|
3922
|
+
result = self.get_match_node val[0], val[2]
|
|
4175
3923
|
|
|
4176
3924
|
result
|
|
4177
|
-
|
|
4178
|
-
.,.,
|
|
3925
|
+
end
|
|
4179
3926
|
|
|
4180
|
-
|
|
4181
|
-
|
|
4182
|
-
result = s(:not, self.get_match_node(val[0], val[2]))
|
|
3927
|
+
def _reduce_209(val, _values, result)
|
|
3928
|
+
result = s(:not, self.get_match_node(val[0], val[2]))
|
|
4183
3929
|
|
|
4184
3930
|
result
|
|
4185
|
-
|
|
4186
|
-
.,.,
|
|
3931
|
+
end
|
|
4187
3932
|
|
|
4188
|
-
|
|
4189
|
-
|
|
4190
|
-
result = s(:not, val[1])
|
|
3933
|
+
def _reduce_210(val, _values, result)
|
|
3934
|
+
result = s(:not, val[1])
|
|
4191
3935
|
|
|
4192
3936
|
result
|
|
4193
|
-
|
|
4194
|
-
.,.,
|
|
3937
|
+
end
|
|
4195
3938
|
|
|
4196
|
-
|
|
4197
|
-
|
|
4198
|
-
val[2] = value_expr val[2]
|
|
3939
|
+
def _reduce_211(val, _values, result)
|
|
3940
|
+
val[2] = value_expr val[2]
|
|
4199
3941
|
result = new_call val[1], :"~", s(:arglist)
|
|
4200
3942
|
|
|
4201
3943
|
result
|
|
4202
|
-
|
|
4203
|
-
.,.,
|
|
3944
|
+
end
|
|
4204
3945
|
|
|
4205
|
-
|
|
4206
|
-
|
|
4207
|
-
val[0] = value_expr val[0]
|
|
3946
|
+
def _reduce_212(val, _values, result)
|
|
3947
|
+
val[0] = value_expr val[0]
|
|
4208
3948
|
val[2] = value_expr val[2]
|
|
4209
3949
|
result = new_call val[0], :"\<\<", s(:arglist, val[2])
|
|
4210
3950
|
|
|
4211
3951
|
result
|
|
4212
|
-
|
|
4213
|
-
.,.,
|
|
3952
|
+
end
|
|
4214
3953
|
|
|
4215
|
-
|
|
4216
|
-
|
|
4217
|
-
val[0] = value_expr val[0]
|
|
3954
|
+
def _reduce_213(val, _values, result)
|
|
3955
|
+
val[0] = value_expr val[0]
|
|
4218
3956
|
val[2] = value_expr val[2]
|
|
4219
3957
|
result = new_call val[0], :">>", s(:arglist, val[2])
|
|
4220
3958
|
|
|
4221
3959
|
result
|
|
4222
|
-
|
|
4223
|
-
.,.,
|
|
3960
|
+
end
|
|
4224
3961
|
|
|
4225
|
-
|
|
4226
|
-
|
|
4227
|
-
result = logop(:and, val[0], val[2])
|
|
3962
|
+
def _reduce_214(val, _values, result)
|
|
3963
|
+
result = logop(:and, val[0], val[2])
|
|
4228
3964
|
|
|
4229
3965
|
result
|
|
4230
|
-
|
|
4231
|
-
.,.,
|
|
3966
|
+
end
|
|
4232
3967
|
|
|
4233
|
-
|
|
4234
|
-
|
|
4235
|
-
result = logop(:or, val[0], val[2])
|
|
3968
|
+
def _reduce_215(val, _values, result)
|
|
3969
|
+
result = logop(:or, val[0], val[2])
|
|
4236
3970
|
|
|
4237
3971
|
result
|
|
4238
|
-
|
|
4239
|
-
.,.,
|
|
3972
|
+
end
|
|
4240
3973
|
|
|
4241
|
-
|
|
4242
|
-
|
|
4243
|
-
result = s(:defined, val[2])
|
|
3974
|
+
def _reduce_216(val, _values, result)
|
|
3975
|
+
result = s(:defined, val[2])
|
|
4244
3976
|
|
|
4245
3977
|
result
|
|
4246
|
-
|
|
4247
|
-
.,.,
|
|
3978
|
+
end
|
|
4248
3979
|
|
|
4249
|
-
|
|
4250
|
-
|
|
4251
|
-
result = s(:if, val[0], val[2], val[4])
|
|
3980
|
+
def _reduce_217(val, _values, result)
|
|
3981
|
+
result = s(:if, val[0], val[2], val[4])
|
|
4252
3982
|
|
|
4253
3983
|
result
|
|
4254
|
-
|
|
4255
|
-
.,.,
|
|
3984
|
+
end
|
|
4256
3985
|
|
|
4257
3986
|
# reduce 218 omitted
|
|
4258
3987
|
|
|
4259
|
-
|
|
4260
|
-
|
|
4261
|
-
result = value_expr(val[0])
|
|
3988
|
+
def _reduce_219(val, _values, result)
|
|
3989
|
+
result = value_expr(val[0])
|
|
4262
3990
|
|
|
4263
3991
|
result
|
|
4264
|
-
|
|
4265
|
-
.,.,
|
|
3992
|
+
end
|
|
4266
3993
|
|
|
4267
3994
|
# reduce 220 omitted
|
|
4268
3995
|
|
|
4269
|
-
|
|
4270
|
-
|
|
4271
|
-
warning 'parenthesize argument(s) for future version'
|
|
3996
|
+
def _reduce_221(val, _values, result)
|
|
3997
|
+
warning 'parenthesize argument(s) for future version'
|
|
4272
3998
|
result = s(:array, val[0])
|
|
4273
3999
|
|
|
4274
4000
|
result
|
|
4275
|
-
|
|
4276
|
-
.,.,
|
|
4001
|
+
end
|
|
4277
4002
|
|
|
4278
|
-
|
|
4279
|
-
|
|
4280
|
-
result = val[0]
|
|
4003
|
+
def _reduce_222(val, _values, result)
|
|
4004
|
+
result = val[0]
|
|
4281
4005
|
|
|
4282
4006
|
result
|
|
4283
|
-
|
|
4284
|
-
.,.,
|
|
4007
|
+
end
|
|
4285
4008
|
|
|
4286
|
-
|
|
4287
|
-
|
|
4288
|
-
result = self.arg_concat val[0], val[3]
|
|
4009
|
+
def _reduce_223(val, _values, result)
|
|
4010
|
+
result = self.arg_concat val[0], val[3]
|
|
4289
4011
|
|
|
4290
4012
|
result
|
|
4291
|
-
|
|
4292
|
-
.,.,
|
|
4013
|
+
end
|
|
4293
4014
|
|
|
4294
|
-
|
|
4295
|
-
|
|
4296
|
-
result = s(:array, s(:hash, *val[0].values))
|
|
4015
|
+
def _reduce_224(val, _values, result)
|
|
4016
|
+
result = s(:array, s(:hash, *val[0].values))
|
|
4297
4017
|
|
|
4298
4018
|
result
|
|
4299
|
-
|
|
4300
|
-
.,.,
|
|
4019
|
+
end
|
|
4301
4020
|
|
|
4302
|
-
|
|
4303
|
-
|
|
4304
|
-
result = s(:array, s(:splat, val[1]))
|
|
4021
|
+
def _reduce_225(val, _values, result)
|
|
4022
|
+
result = s(:array, s(:splat, val[1]))
|
|
4305
4023
|
|
|
4306
4024
|
result
|
|
4307
|
-
|
|
4308
|
-
.,.,
|
|
4025
|
+
end
|
|
4309
4026
|
|
|
4310
|
-
|
|
4311
|
-
|
|
4312
|
-
result = val[1]
|
|
4027
|
+
def _reduce_226(val, _values, result)
|
|
4028
|
+
result = val[1]
|
|
4313
4029
|
|
|
4314
4030
|
result
|
|
4315
|
-
|
|
4316
|
-
.,.,
|
|
4031
|
+
end
|
|
4317
4032
|
|
|
4318
|
-
|
|
4319
|
-
|
|
4320
|
-
result = val[1]
|
|
4033
|
+
def _reduce_227(val, _values, result)
|
|
4034
|
+
result = val[1]
|
|
4321
4035
|
|
|
4322
4036
|
result
|
|
4323
|
-
|
|
4324
|
-
.,.,
|
|
4037
|
+
end
|
|
4325
4038
|
|
|
4326
|
-
|
|
4327
|
-
|
|
4328
|
-
warning "parenthesize argument(s) for future version"
|
|
4039
|
+
def _reduce_228(val, _values, result)
|
|
4040
|
+
warning "parenthesize argument(s) for future version"
|
|
4329
4041
|
result = s(:array, val[1])
|
|
4330
4042
|
|
|
4331
4043
|
result
|
|
4332
|
-
|
|
4333
|
-
.,.,
|
|
4044
|
+
end
|
|
4334
4045
|
|
|
4335
|
-
|
|
4336
|
-
|
|
4337
|
-
warning "parenthesize argument(s) for future version"
|
|
4046
|
+
def _reduce_229(val, _values, result)
|
|
4047
|
+
warning "parenthesize argument(s) for future version"
|
|
4338
4048
|
result = val[1].add val[3]
|
|
4339
4049
|
|
|
4340
4050
|
result
|
|
4341
|
-
|
|
4342
|
-
.,.,
|
|
4051
|
+
end
|
|
4343
4052
|
|
|
4344
4053
|
# reduce 230 omitted
|
|
4345
4054
|
|
|
4346
4055
|
# reduce 231 omitted
|
|
4347
4056
|
|
|
4348
|
-
|
|
4349
|
-
|
|
4350
|
-
warning "parenthesize argument(s) for future version"
|
|
4057
|
+
def _reduce_232(val, _values, result)
|
|
4058
|
+
warning "parenthesize argument(s) for future version"
|
|
4351
4059
|
result = s(:array, val[0])
|
|
4352
4060
|
|
|
4353
4061
|
result
|
|
4354
|
-
|
|
4355
|
-
.,.,
|
|
4062
|
+
end
|
|
4356
4063
|
|
|
4357
|
-
|
|
4358
|
-
|
|
4359
|
-
result = self.arg_blk_pass val[0], val[1]
|
|
4064
|
+
def _reduce_233(val, _values, result)
|
|
4065
|
+
result = self.arg_blk_pass val[0], val[1]
|
|
4360
4066
|
|
|
4361
4067
|
result
|
|
4362
|
-
|
|
4363
|
-
.,.,
|
|
4068
|
+
end
|
|
4364
4069
|
|
|
4365
|
-
|
|
4366
|
-
|
|
4367
|
-
result = self.arg_concat val[0], val[3]
|
|
4070
|
+
def _reduce_234(val, _values, result)
|
|
4071
|
+
result = self.arg_concat val[0], val[3]
|
|
4368
4072
|
result = self.arg_blk_pass result, val[4]
|
|
4369
4073
|
|
|
4370
4074
|
result
|
|
4371
|
-
|
|
4372
|
-
.,.,
|
|
4075
|
+
end
|
|
4373
4076
|
|
|
4374
|
-
|
|
4375
|
-
|
|
4376
|
-
result = s(:array, s(:hash, *val[0].values))
|
|
4077
|
+
def _reduce_235(val, _values, result)
|
|
4078
|
+
result = s(:array, s(:hash, *val[0].values))
|
|
4377
4079
|
result = self.arg_blk_pass result, val[1]
|
|
4378
4080
|
|
|
4379
4081
|
result
|
|
4380
|
-
|
|
4381
|
-
.,.,
|
|
4082
|
+
end
|
|
4382
4083
|
|
|
4383
|
-
|
|
4384
|
-
|
|
4385
|
-
result = self.arg_concat s(:array, s(:hash, *val[0].values)), val[3]
|
|
4084
|
+
def _reduce_236(val, _values, result)
|
|
4085
|
+
result = self.arg_concat s(:array, s(:hash, *val[0].values)), val[3]
|
|
4386
4086
|
result = self.arg_blk_pass result, val[4]
|
|
4387
4087
|
|
|
4388
4088
|
result
|
|
4389
|
-
|
|
4390
|
-
.,.,
|
|
4089
|
+
end
|
|
4391
4090
|
|
|
4392
|
-
|
|
4393
|
-
|
|
4394
|
-
result = val[0] << s(:hash, *val[2].values)
|
|
4091
|
+
def _reduce_237(val, _values, result)
|
|
4092
|
+
result = val[0] << s(:hash, *val[2].values)
|
|
4395
4093
|
result = self.arg_blk_pass result, val[3]
|
|
4396
4094
|
|
|
4397
4095
|
result
|
|
4398
|
-
|
|
4399
|
-
.,.,
|
|
4096
|
+
end
|
|
4400
4097
|
|
|
4401
|
-
|
|
4402
|
-
|
|
4403
|
-
val[0] << s(:hash, *val[2].values)
|
|
4098
|
+
def _reduce_238(val, _values, result)
|
|
4099
|
+
val[0] << s(:hash, *val[2].values)
|
|
4404
4100
|
result = self.arg_concat val[0], val[5]
|
|
4405
4101
|
result = self.arg_blk_pass result, val[6]
|
|
4406
4102
|
|
|
4407
4103
|
result
|
|
4408
|
-
|
|
4409
|
-
.,.,
|
|
4104
|
+
end
|
|
4410
4105
|
|
|
4411
|
-
|
|
4412
|
-
|
|
4413
|
-
result = self.arg_blk_pass s(:splat, val[1]), val[2]
|
|
4106
|
+
def _reduce_239(val, _values, result)
|
|
4107
|
+
result = self.arg_blk_pass s(:splat, val[1]), val[2]
|
|
4414
4108
|
|
|
4415
4109
|
result
|
|
4416
|
-
|
|
4417
|
-
.,.,
|
|
4110
|
+
end
|
|
4418
4111
|
|
|
4419
4112
|
# reduce 240 omitted
|
|
4420
4113
|
|
|
4421
|
-
|
|
4422
|
-
|
|
4423
|
-
args = self.list_prepend val[0], val[2]
|
|
4114
|
+
def _reduce_241(val, _values, result)
|
|
4115
|
+
args = self.list_prepend val[0], val[2]
|
|
4424
4116
|
result = self.arg_blk_pass args, val[3]
|
|
4425
4117
|
|
|
4426
4118
|
result
|
|
4427
|
-
|
|
4428
|
-
.,.,
|
|
4119
|
+
end
|
|
4429
4120
|
|
|
4430
|
-
|
|
4431
|
-
|
|
4432
|
-
result = self.arg_blk_pass val[0], val[2]
|
|
4121
|
+
def _reduce_242(val, _values, result)
|
|
4122
|
+
result = self.arg_blk_pass val[0], val[2]
|
|
4433
4123
|
|
|
4434
4124
|
result
|
|
4435
|
-
|
|
4436
|
-
.,.,
|
|
4125
|
+
end
|
|
4437
4126
|
|
|
4438
|
-
|
|
4439
|
-
|
|
4440
|
-
result = self.arg_concat s(:array, val[0]), val[3]
|
|
4127
|
+
def _reduce_243(val, _values, result)
|
|
4128
|
+
result = self.arg_concat s(:array, val[0]), val[3]
|
|
4441
4129
|
result = self.arg_blk_pass result, val[4]
|
|
4442
4130
|
|
|
4443
4131
|
result
|
|
4444
|
-
|
|
4445
|
-
.,.,
|
|
4132
|
+
end
|
|
4446
4133
|
|
|
4447
|
-
|
|
4448
|
-
|
|
4449
|
-
result = self.arg_concat s(:array, val[0], s(:hash, *val[2].values)), val[5]
|
|
4134
|
+
def _reduce_244(val, _values, result)
|
|
4135
|
+
result = self.arg_concat s(:array, val[0], s(:hash, *val[2].values)), val[5]
|
|
4450
4136
|
result = self.arg_blk_pass result, val[6]
|
|
4451
4137
|
|
|
4452
4138
|
result
|
|
4453
|
-
|
|
4454
|
-
.,.,
|
|
4139
|
+
end
|
|
4455
4140
|
|
|
4456
|
-
|
|
4457
|
-
|
|
4458
|
-
result = s(:array, s(:hash, *val[0].values))
|
|
4141
|
+
def _reduce_245(val, _values, result)
|
|
4142
|
+
result = s(:array, s(:hash, *val[0].values))
|
|
4459
4143
|
result = self.arg_blk_pass result, val[1]
|
|
4460
4144
|
|
|
4461
4145
|
result
|
|
4462
|
-
|
|
4463
|
-
.,.,
|
|
4146
|
+
end
|
|
4464
4147
|
|
|
4465
|
-
|
|
4466
|
-
|
|
4467
|
-
result = s(:array, s(:hash, *val[0].values), val[3])
|
|
4148
|
+
def _reduce_246(val, _values, result)
|
|
4149
|
+
result = s(:array, s(:hash, *val[0].values), val[3])
|
|
4468
4150
|
result = self.arg_blk_pass result, val[4]
|
|
4469
4151
|
|
|
4470
4152
|
result
|
|
4471
|
-
|
|
4472
|
-
.,.,
|
|
4153
|
+
end
|
|
4473
4154
|
|
|
4474
|
-
|
|
4475
|
-
|
|
4476
|
-
result = s(:array, val[0], s(:hash, *val[2].values))
|
|
4155
|
+
def _reduce_247(val, _values, result)
|
|
4156
|
+
result = s(:array, val[0], s(:hash, *val[2].values))
|
|
4477
4157
|
result = self.arg_blk_pass result, val[3]
|
|
4478
4158
|
|
|
4479
4159
|
result
|
|
4480
|
-
|
|
4481
|
-
.,.,
|
|
4160
|
+
end
|
|
4482
4161
|
|
|
4483
|
-
|
|
4484
|
-
|
|
4485
|
-
result = s(:array, val[0]).add_all(val[2]).add(s(:hash, *val[4].values))
|
|
4162
|
+
def _reduce_248(val, _values, result)
|
|
4163
|
+
result = s(:array, val[0]).add_all(val[2]).add(s(:hash, *val[4].values))
|
|
4486
4164
|
result = self.arg_blk_pass result, val[5]
|
|
4487
4165
|
|
|
4488
4166
|
result
|
|
4489
|
-
|
|
4490
|
-
.,.,
|
|
4167
|
+
end
|
|
4491
4168
|
|
|
4492
|
-
|
|
4493
|
-
|
|
4494
|
-
result = self.arg_concat s(:array, val[0]).add(s(:hash, *val[2].values)), val[5]
|
|
4169
|
+
def _reduce_249(val, _values, result)
|
|
4170
|
+
result = self.arg_concat s(:array, val[0]).add(s(:hash, *val[2].values)), val[5]
|
|
4495
4171
|
result = self.arg_blk_pass result, val[6]
|
|
4496
4172
|
|
|
4497
4173
|
result
|
|
4498
|
-
|
|
4499
|
-
.,.,
|
|
4174
|
+
end
|
|
4500
4175
|
|
|
4501
|
-
|
|
4502
|
-
|
|
4503
|
-
result = self.arg_concat s(:array, val[0]).add_all(val[2]).add(s(:hash, *val[4].values)), val[7]
|
|
4176
|
+
def _reduce_250(val, _values, result)
|
|
4177
|
+
result = self.arg_concat s(:array, val[0]).add_all(val[2]).add(s(:hash, *val[4].values)), val[7]
|
|
4504
4178
|
result = self.arg_blk_pass result, val[8]
|
|
4505
4179
|
|
|
4506
4180
|
result
|
|
4507
|
-
|
|
4508
|
-
.,.,
|
|
4181
|
+
end
|
|
4509
4182
|
|
|
4510
|
-
|
|
4511
|
-
|
|
4512
|
-
result = self.arg_blk_pass s(:splat, val[1]), val[2]
|
|
4183
|
+
def _reduce_251(val, _values, result)
|
|
4184
|
+
result = self.arg_blk_pass s(:splat, val[1]), val[2]
|
|
4513
4185
|
|
|
4514
4186
|
result
|
|
4515
|
-
|
|
4516
|
-
.,.,
|
|
4187
|
+
end
|
|
4517
4188
|
|
|
4518
4189
|
# reduce 252 omitted
|
|
4519
4190
|
|
|
4520
|
-
|
|
4521
|
-
|
|
4522
|
-
result = lexer.cmdarg.stack.dup
|
|
4191
|
+
def _reduce_253(val, _values, result)
|
|
4192
|
+
result = lexer.cmdarg.stack.dup
|
|
4523
4193
|
lexer.cmdarg.push true
|
|
4524
4194
|
|
|
4525
4195
|
result
|
|
4526
|
-
|
|
4527
|
-
.,.,
|
|
4196
|
+
end
|
|
4528
4197
|
|
|
4529
|
-
|
|
4530
|
-
|
|
4531
|
-
lexer.cmdarg.stack.replace val[0]
|
|
4198
|
+
def _reduce_254(val, _values, result)
|
|
4199
|
+
lexer.cmdarg.stack.replace val[0]
|
|
4532
4200
|
result = val[1]
|
|
4533
4201
|
|
|
4534
4202
|
result
|
|
4535
|
-
|
|
4536
|
-
.,.,
|
|
4203
|
+
end
|
|
4537
4204
|
|
|
4538
4205
|
# reduce 255 omitted
|
|
4539
4206
|
|
|
4540
|
-
|
|
4541
|
-
|
|
4542
|
-
lexer.lex_state = :expr_endarg
|
|
4207
|
+
def _reduce_256(val, _values, result)
|
|
4208
|
+
lexer.lex_state = :expr_endarg
|
|
4543
4209
|
|
|
4544
4210
|
result
|
|
4545
|
-
|
|
4546
|
-
.,.,
|
|
4211
|
+
end
|
|
4547
4212
|
|
|
4548
|
-
|
|
4549
|
-
|
|
4550
|
-
warning "don't put space before argument parentheses"
|
|
4213
|
+
def _reduce_257(val, _values, result)
|
|
4214
|
+
warning "don't put space before argument parentheses"
|
|
4551
4215
|
result = nil
|
|
4552
4216
|
|
|
4553
4217
|
result
|
|
4554
|
-
|
|
4555
|
-
.,.,
|
|
4218
|
+
end
|
|
4556
4219
|
|
|
4557
|
-
|
|
4558
|
-
|
|
4559
|
-
lexer.lex_state = :expr_endarg
|
|
4220
|
+
def _reduce_258(val, _values, result)
|
|
4221
|
+
lexer.lex_state = :expr_endarg
|
|
4560
4222
|
|
|
4561
4223
|
result
|
|
4562
|
-
|
|
4563
|
-
.,.,
|
|
4224
|
+
end
|
|
4564
4225
|
|
|
4565
|
-
|
|
4566
|
-
|
|
4567
|
-
warning "don't put space before argument parentheses"
|
|
4226
|
+
def _reduce_259(val, _values, result)
|
|
4227
|
+
warning "don't put space before argument parentheses"
|
|
4568
4228
|
result = val[1]
|
|
4569
4229
|
|
|
4570
4230
|
result
|
|
4571
|
-
|
|
4572
|
-
.,.,
|
|
4231
|
+
end
|
|
4573
4232
|
|
|
4574
|
-
|
|
4575
|
-
|
|
4576
|
-
result = s(:block_pass, val[1])
|
|
4233
|
+
def _reduce_260(val, _values, result)
|
|
4234
|
+
result = s(:block_pass, val[1])
|
|
4577
4235
|
|
|
4578
4236
|
result
|
|
4579
|
-
|
|
4580
|
-
.,.,
|
|
4237
|
+
end
|
|
4581
4238
|
|
|
4582
|
-
|
|
4583
|
-
|
|
4584
|
-
result = val[1]
|
|
4239
|
+
def _reduce_261(val, _values, result)
|
|
4240
|
+
result = val[1]
|
|
4585
4241
|
|
|
4586
4242
|
result
|
|
4587
|
-
|
|
4588
|
-
.,.,
|
|
4243
|
+
end
|
|
4589
4244
|
|
|
4590
4245
|
# reduce 262 omitted
|
|
4591
4246
|
|
|
4592
|
-
|
|
4593
|
-
|
|
4594
|
-
result = s(:array, val[0])
|
|
4247
|
+
def _reduce_263(val, _values, result)
|
|
4248
|
+
result = s(:array, val[0])
|
|
4595
4249
|
|
|
4596
4250
|
result
|
|
4597
|
-
|
|
4598
|
-
.,.,
|
|
4251
|
+
end
|
|
4599
4252
|
|
|
4600
|
-
|
|
4601
|
-
|
|
4602
|
-
result = self.list_append val[0], val[2]
|
|
4253
|
+
def _reduce_264(val, _values, result)
|
|
4254
|
+
result = self.list_append val[0], val[2]
|
|
4603
4255
|
|
|
4604
4256
|
result
|
|
4605
|
-
|
|
4606
|
-
.,.,
|
|
4257
|
+
end
|
|
4607
4258
|
|
|
4608
|
-
|
|
4609
|
-
|
|
4610
|
-
result = val[0] << val[2]
|
|
4259
|
+
def _reduce_265(val, _values, result)
|
|
4260
|
+
result = val[0] << val[2]
|
|
4611
4261
|
|
|
4612
4262
|
result
|
|
4613
|
-
|
|
4614
|
-
.,.,
|
|
4263
|
+
end
|
|
4615
4264
|
|
|
4616
|
-
|
|
4617
|
-
|
|
4618
|
-
result = self.arg_concat val[0], val[3]
|
|
4265
|
+
def _reduce_266(val, _values, result)
|
|
4266
|
+
result = self.arg_concat val[0], val[3]
|
|
4619
4267
|
|
|
4620
4268
|
result
|
|
4621
|
-
|
|
4622
|
-
.,.,
|
|
4269
|
+
end
|
|
4623
4270
|
|
|
4624
|
-
|
|
4625
|
-
|
|
4626
|
-
result = s(:splat, val[1])
|
|
4271
|
+
def _reduce_267(val, _values, result)
|
|
4272
|
+
result = s(:splat, val[1])
|
|
4627
4273
|
|
|
4628
4274
|
result
|
|
4629
|
-
|
|
4630
|
-
.,.,
|
|
4275
|
+
end
|
|
4631
4276
|
|
|
4632
4277
|
# reduce 268 omitted
|
|
4633
4278
|
|
|
@@ -4645,25 +4290,20 @@ module_eval(<<'.,.,', 'ruby_parser.y', 903)
|
|
|
4645
4290
|
|
|
4646
4291
|
# reduce 275 omitted
|
|
4647
4292
|
|
|
4648
|
-
|
|
4649
|
-
|
|
4650
|
-
result = new_call nil, val[0].to_sym
|
|
4293
|
+
def _reduce_276(val, _values, result)
|
|
4294
|
+
result = new_call nil, val[0].to_sym
|
|
4651
4295
|
|
|
4652
4296
|
result
|
|
4653
|
-
|
|
4654
|
-
.,.,
|
|
4297
|
+
end
|
|
4655
4298
|
|
|
4656
|
-
|
|
4657
|
-
|
|
4658
|
-
result = self.lexer.lineno
|
|
4299
|
+
def _reduce_277(val, _values, result)
|
|
4300
|
+
result = self.lexer.lineno
|
|
4659
4301
|
|
|
4660
4302
|
result
|
|
4661
|
-
|
|
4662
|
-
.,.,
|
|
4303
|
+
end
|
|
4663
4304
|
|
|
4664
|
-
|
|
4665
|
-
|
|
4666
|
-
unless val[2] then
|
|
4305
|
+
def _reduce_278(val, _values, result)
|
|
4306
|
+
unless val[2] then
|
|
4667
4307
|
result = s(:nil)
|
|
4668
4308
|
else
|
|
4669
4309
|
result = s(:begin, val[2])
|
|
@@ -4672,435 +4312,336 @@ module_eval(<<'.,.,', 'ruby_parser.y', 924)
|
|
|
4672
4312
|
result.line = val[1]
|
|
4673
4313
|
|
|
4674
4314
|
result
|
|
4675
|
-
|
|
4676
|
-
.,.,
|
|
4315
|
+
end
|
|
4677
4316
|
|
|
4678
|
-
|
|
4679
|
-
|
|
4680
|
-
lexer.lex_state = :expr_endarg
|
|
4317
|
+
def _reduce_279(val, _values, result)
|
|
4318
|
+
lexer.lex_state = :expr_endarg
|
|
4681
4319
|
|
|
4682
4320
|
result
|
|
4683
|
-
|
|
4684
|
-
.,.,
|
|
4321
|
+
end
|
|
4685
4322
|
|
|
4686
|
-
|
|
4687
|
-
|
|
4688
|
-
warning "(...) interpreted as grouped expression"
|
|
4323
|
+
def _reduce_280(val, _values, result)
|
|
4324
|
+
warning "(...) interpreted as grouped expression"
|
|
4689
4325
|
result = val[1]
|
|
4690
4326
|
|
|
4691
4327
|
result
|
|
4692
|
-
|
|
4693
|
-
.,.,
|
|
4328
|
+
end
|
|
4694
4329
|
|
|
4695
|
-
|
|
4696
|
-
|
|
4697
|
-
result = val[1] || s(:nil)
|
|
4330
|
+
def _reduce_281(val, _values, result)
|
|
4331
|
+
result = val[1] || s(:nil)
|
|
4698
4332
|
result.paren = true
|
|
4699
4333
|
|
|
4700
4334
|
result
|
|
4701
|
-
|
|
4702
|
-
.,.,
|
|
4335
|
+
end
|
|
4703
4336
|
|
|
4704
|
-
|
|
4705
|
-
|
|
4706
|
-
result = s(:colon2, val[0], val[2].to_sym)
|
|
4337
|
+
def _reduce_282(val, _values, result)
|
|
4338
|
+
result = s(:colon2, val[0], val[2].to_sym)
|
|
4707
4339
|
|
|
4708
4340
|
result
|
|
4709
|
-
|
|
4710
|
-
.,.,
|
|
4341
|
+
end
|
|
4711
4342
|
|
|
4712
|
-
|
|
4713
|
-
|
|
4714
|
-
result = s(:colon3, val[1].to_sym)
|
|
4343
|
+
def _reduce_283(val, _values, result)
|
|
4344
|
+
result = s(:colon3, val[1].to_sym)
|
|
4715
4345
|
|
|
4716
4346
|
result
|
|
4717
|
-
|
|
4718
|
-
.,.,
|
|
4347
|
+
end
|
|
4719
4348
|
|
|
4720
|
-
|
|
4721
|
-
|
|
4722
|
-
result = new_aref val
|
|
4349
|
+
def _reduce_284(val, _values, result)
|
|
4350
|
+
result = new_aref val
|
|
4723
4351
|
|
|
4724
4352
|
result
|
|
4725
|
-
|
|
4726
|
-
.,.,
|
|
4353
|
+
end
|
|
4727
4354
|
|
|
4728
|
-
|
|
4729
|
-
|
|
4730
|
-
result = val[1] || s(:array)
|
|
4355
|
+
def _reduce_285(val, _values, result)
|
|
4356
|
+
result = val[1] || s(:array)
|
|
4731
4357
|
|
|
4732
4358
|
result
|
|
4733
|
-
|
|
4734
|
-
.,.,
|
|
4359
|
+
end
|
|
4735
4360
|
|
|
4736
|
-
|
|
4737
|
-
|
|
4738
|
-
result = s(:hash, *val[1].values)
|
|
4361
|
+
def _reduce_286(val, _values, result)
|
|
4362
|
+
result = s(:hash, *val[1].values)
|
|
4739
4363
|
|
|
4740
4364
|
result
|
|
4741
|
-
|
|
4742
|
-
.,.,
|
|
4365
|
+
end
|
|
4743
4366
|
|
|
4744
|
-
|
|
4745
|
-
|
|
4746
|
-
result = s(:return)
|
|
4367
|
+
def _reduce_287(val, _values, result)
|
|
4368
|
+
result = s(:return)
|
|
4747
4369
|
|
|
4748
4370
|
result
|
|
4749
|
-
|
|
4750
|
-
.,.,
|
|
4371
|
+
end
|
|
4751
4372
|
|
|
4752
|
-
|
|
4753
|
-
|
|
4754
|
-
result = new_yield val[2]
|
|
4373
|
+
def _reduce_288(val, _values, result)
|
|
4374
|
+
result = new_yield val[2]
|
|
4755
4375
|
|
|
4756
4376
|
result
|
|
4757
|
-
|
|
4758
|
-
.,.,
|
|
4377
|
+
end
|
|
4759
4378
|
|
|
4760
|
-
|
|
4761
|
-
|
|
4762
|
-
result = new_yield
|
|
4379
|
+
def _reduce_289(val, _values, result)
|
|
4380
|
+
result = new_yield
|
|
4763
4381
|
|
|
4764
4382
|
result
|
|
4765
|
-
|
|
4766
|
-
.,.,
|
|
4383
|
+
end
|
|
4767
4384
|
|
|
4768
|
-
|
|
4769
|
-
|
|
4770
|
-
result = new_yield
|
|
4385
|
+
def _reduce_290(val, _values, result)
|
|
4386
|
+
result = new_yield
|
|
4771
4387
|
|
|
4772
4388
|
result
|
|
4773
|
-
|
|
4774
|
-
.,.,
|
|
4389
|
+
end
|
|
4775
4390
|
|
|
4776
|
-
|
|
4777
|
-
|
|
4778
|
-
result = s(:defined, val[3])
|
|
4391
|
+
def _reduce_291(val, _values, result)
|
|
4392
|
+
result = s(:defined, val[3])
|
|
4779
4393
|
|
|
4780
4394
|
result
|
|
4781
|
-
|
|
4782
|
-
.,.,
|
|
4395
|
+
end
|
|
4783
4396
|
|
|
4784
|
-
|
|
4785
|
-
|
|
4786
|
-
oper, iter = val[0], val[1]
|
|
4397
|
+
def _reduce_292(val, _values, result)
|
|
4398
|
+
oper, iter = val[0], val[1]
|
|
4787
4399
|
call = new_call(nil, oper.to_sym)
|
|
4788
4400
|
iter.insert 1, call
|
|
4789
4401
|
result = iter
|
|
4790
4402
|
call.line = iter.line
|
|
4791
4403
|
|
|
4792
4404
|
result
|
|
4793
|
-
|
|
4794
|
-
.,.,
|
|
4405
|
+
end
|
|
4795
4406
|
|
|
4796
4407
|
# reduce 293 omitted
|
|
4797
4408
|
|
|
4798
|
-
|
|
4799
|
-
|
|
4800
|
-
call, iter = val[0], val[1]
|
|
4409
|
+
def _reduce_294(val, _values, result)
|
|
4410
|
+
call, iter = val[0], val[1]
|
|
4801
4411
|
iter.insert 1, call
|
|
4802
4412
|
result = iter
|
|
4803
4413
|
|
|
4804
4414
|
result
|
|
4805
|
-
|
|
4806
|
-
.,.,
|
|
4415
|
+
end
|
|
4807
4416
|
|
|
4808
|
-
|
|
4809
|
-
|
|
4810
|
-
result = new_if val[1], val[3], val[4]
|
|
4417
|
+
def _reduce_295(val, _values, result)
|
|
4418
|
+
result = new_if val[1], val[3], val[4]
|
|
4811
4419
|
|
|
4812
4420
|
result
|
|
4813
|
-
|
|
4814
|
-
.,.,
|
|
4421
|
+
end
|
|
4815
4422
|
|
|
4816
|
-
|
|
4817
|
-
|
|
4818
|
-
result = new_if val[1], val[4], val[3]
|
|
4423
|
+
def _reduce_296(val, _values, result)
|
|
4424
|
+
result = new_if val[1], val[4], val[3]
|
|
4819
4425
|
|
|
4820
4426
|
result
|
|
4821
|
-
|
|
4822
|
-
.,.,
|
|
4427
|
+
end
|
|
4823
4428
|
|
|
4824
|
-
|
|
4825
|
-
|
|
4826
|
-
lexer.cond.push true
|
|
4429
|
+
def _reduce_297(val, _values, result)
|
|
4430
|
+
lexer.cond.push true
|
|
4827
4431
|
|
|
4828
4432
|
result
|
|
4829
|
-
|
|
4830
|
-
.,.,
|
|
4433
|
+
end
|
|
4831
4434
|
|
|
4832
|
-
|
|
4833
|
-
|
|
4834
|
-
lexer.cond.pop
|
|
4435
|
+
def _reduce_298(val, _values, result)
|
|
4436
|
+
lexer.cond.pop
|
|
4835
4437
|
|
|
4836
4438
|
result
|
|
4837
|
-
|
|
4838
|
-
.,.,
|
|
4439
|
+
end
|
|
4839
4440
|
|
|
4840
|
-
|
|
4841
|
-
|
|
4842
|
-
result = new_while val[5], val[2], true
|
|
4441
|
+
def _reduce_299(val, _values, result)
|
|
4442
|
+
result = new_while val[5], val[2], true
|
|
4843
4443
|
|
|
4844
4444
|
result
|
|
4845
|
-
|
|
4846
|
-
.,.,
|
|
4445
|
+
end
|
|
4847
4446
|
|
|
4848
|
-
|
|
4849
|
-
|
|
4850
|
-
lexer.cond.push true
|
|
4447
|
+
def _reduce_300(val, _values, result)
|
|
4448
|
+
lexer.cond.push true
|
|
4851
4449
|
|
|
4852
4450
|
result
|
|
4853
|
-
|
|
4854
|
-
.,.,
|
|
4451
|
+
end
|
|
4855
4452
|
|
|
4856
|
-
|
|
4857
|
-
|
|
4858
|
-
lexer.cond.pop
|
|
4453
|
+
def _reduce_301(val, _values, result)
|
|
4454
|
+
lexer.cond.pop
|
|
4859
4455
|
|
|
4860
4456
|
result
|
|
4861
|
-
|
|
4862
|
-
.,.,
|
|
4457
|
+
end
|
|
4863
4458
|
|
|
4864
|
-
|
|
4865
|
-
|
|
4866
|
-
result = new_until val[5], val[2], true
|
|
4459
|
+
def _reduce_302(val, _values, result)
|
|
4460
|
+
result = new_until val[5], val[2], true
|
|
4867
4461
|
|
|
4868
4462
|
result
|
|
4869
|
-
|
|
4870
|
-
.,.,
|
|
4463
|
+
end
|
|
4871
4464
|
|
|
4872
|
-
|
|
4873
|
-
|
|
4874
|
-
result = new_case val[1], val[3]
|
|
4465
|
+
def _reduce_303(val, _values, result)
|
|
4466
|
+
result = new_case val[1], val[3]
|
|
4875
4467
|
|
|
4876
4468
|
result
|
|
4877
|
-
|
|
4878
|
-
.,.,
|
|
4469
|
+
end
|
|
4879
4470
|
|
|
4880
|
-
|
|
4881
|
-
|
|
4882
|
-
result = new_case nil, val[2]
|
|
4471
|
+
def _reduce_304(val, _values, result)
|
|
4472
|
+
result = new_case nil, val[2]
|
|
4883
4473
|
|
|
4884
4474
|
result
|
|
4885
|
-
|
|
4886
|
-
.,.,
|
|
4475
|
+
end
|
|
4887
4476
|
|
|
4888
|
-
|
|
4889
|
-
|
|
4890
|
-
result = new_case nil, val[3]
|
|
4477
|
+
def _reduce_305(val, _values, result)
|
|
4478
|
+
result = new_case nil, val[3]
|
|
4891
4479
|
|
|
4892
4480
|
result
|
|
4893
|
-
|
|
4894
|
-
.,.,
|
|
4481
|
+
end
|
|
4895
4482
|
|
|
4896
|
-
|
|
4897
|
-
|
|
4898
|
-
lexer.cond.push true
|
|
4483
|
+
def _reduce_306(val, _values, result)
|
|
4484
|
+
lexer.cond.push true
|
|
4899
4485
|
|
|
4900
4486
|
result
|
|
4901
|
-
|
|
4902
|
-
.,.,
|
|
4487
|
+
end
|
|
4903
4488
|
|
|
4904
|
-
|
|
4905
|
-
|
|
4906
|
-
lexer.cond.pop
|
|
4489
|
+
def _reduce_307(val, _values, result)
|
|
4490
|
+
lexer.cond.pop
|
|
4907
4491
|
|
|
4908
4492
|
result
|
|
4909
|
-
|
|
4910
|
-
.,.,
|
|
4493
|
+
end
|
|
4911
4494
|
|
|
4912
|
-
|
|
4913
|
-
|
|
4914
|
-
result = new_for val[4], val[1], val[7]
|
|
4495
|
+
def _reduce_308(val, _values, result)
|
|
4496
|
+
result = new_for val[4], val[1], val[7]
|
|
4915
4497
|
|
|
4916
4498
|
result
|
|
4917
|
-
|
|
4918
|
-
.,.,
|
|
4499
|
+
end
|
|
4919
4500
|
|
|
4920
|
-
|
|
4921
|
-
|
|
4922
|
-
result = self.lexer.lineno
|
|
4501
|
+
def _reduce_309(val, _values, result)
|
|
4502
|
+
result = self.lexer.lineno
|
|
4923
4503
|
|
|
4924
4504
|
result
|
|
4925
|
-
|
|
4926
|
-
.,.,
|
|
4505
|
+
end
|
|
4927
4506
|
|
|
4928
|
-
|
|
4929
|
-
|
|
4930
|
-
self.comments.push self.lexer.comments
|
|
4507
|
+
def _reduce_310(val, _values, result)
|
|
4508
|
+
self.comments.push self.lexer.comments
|
|
4931
4509
|
if (self.in_def || self.in_single > 0) then
|
|
4932
4510
|
yyerror "class definition in method body"
|
|
4933
4511
|
end
|
|
4934
4512
|
self.env.extend
|
|
4935
4513
|
|
|
4936
4514
|
result
|
|
4937
|
-
|
|
4938
|
-
.,.,
|
|
4515
|
+
end
|
|
4939
4516
|
|
|
4940
|
-
|
|
4941
|
-
|
|
4942
|
-
result = new_class val
|
|
4517
|
+
def _reduce_311(val, _values, result)
|
|
4518
|
+
result = new_class val
|
|
4943
4519
|
self.env.unextend
|
|
4944
4520
|
|
|
4945
4521
|
result
|
|
4946
|
-
|
|
4947
|
-
.,.,
|
|
4522
|
+
end
|
|
4948
4523
|
|
|
4949
|
-
|
|
4950
|
-
|
|
4951
|
-
result = self.lexer.lineno
|
|
4524
|
+
def _reduce_312(val, _values, result)
|
|
4525
|
+
result = self.lexer.lineno
|
|
4952
4526
|
|
|
4953
4527
|
result
|
|
4954
|
-
|
|
4955
|
-
.,.,
|
|
4528
|
+
end
|
|
4956
4529
|
|
|
4957
|
-
|
|
4958
|
-
|
|
4959
|
-
result = self.in_def
|
|
4530
|
+
def _reduce_313(val, _values, result)
|
|
4531
|
+
result = self.in_def
|
|
4960
4532
|
self.in_def = false
|
|
4961
4533
|
|
|
4962
4534
|
result
|
|
4963
|
-
|
|
4964
|
-
.,.,
|
|
4535
|
+
end
|
|
4965
4536
|
|
|
4966
|
-
|
|
4967
|
-
|
|
4968
|
-
result = self.in_single
|
|
4537
|
+
def _reduce_314(val, _values, result)
|
|
4538
|
+
result = self.in_single
|
|
4969
4539
|
self.in_single = 0
|
|
4970
4540
|
self.env.extend
|
|
4971
4541
|
|
|
4972
4542
|
result
|
|
4973
|
-
|
|
4974
|
-
.,.,
|
|
4543
|
+
end
|
|
4975
4544
|
|
|
4976
|
-
|
|
4977
|
-
|
|
4978
|
-
result = new_sclass val
|
|
4545
|
+
def _reduce_315(val, _values, result)
|
|
4546
|
+
result = new_sclass val
|
|
4979
4547
|
self.env.unextend
|
|
4980
4548
|
|
|
4981
4549
|
result
|
|
4982
|
-
|
|
4983
|
-
.,.,
|
|
4550
|
+
end
|
|
4984
4551
|
|
|
4985
|
-
|
|
4986
|
-
|
|
4987
|
-
result = self.lexer.lineno
|
|
4552
|
+
def _reduce_316(val, _values, result)
|
|
4553
|
+
result = self.lexer.lineno
|
|
4988
4554
|
|
|
4989
4555
|
result
|
|
4990
|
-
|
|
4991
|
-
.,.,
|
|
4556
|
+
end
|
|
4992
4557
|
|
|
4993
|
-
|
|
4994
|
-
|
|
4995
|
-
self.comments.push self.lexer.comments
|
|
4558
|
+
def _reduce_317(val, _values, result)
|
|
4559
|
+
self.comments.push self.lexer.comments
|
|
4996
4560
|
yyerror "module definition in method body" if
|
|
4997
4561
|
self.in_def or self.in_single > 0
|
|
4998
4562
|
|
|
4999
4563
|
self.env.extend
|
|
5000
4564
|
|
|
5001
4565
|
result
|
|
5002
|
-
|
|
5003
|
-
.,.,
|
|
4566
|
+
end
|
|
5004
4567
|
|
|
5005
|
-
|
|
5006
|
-
|
|
5007
|
-
result = new_module val
|
|
4568
|
+
def _reduce_318(val, _values, result)
|
|
4569
|
+
result = new_module val
|
|
5008
4570
|
self.env.unextend
|
|
5009
4571
|
|
|
5010
4572
|
result
|
|
5011
|
-
|
|
5012
|
-
.,.,
|
|
4573
|
+
end
|
|
5013
4574
|
|
|
5014
|
-
|
|
5015
|
-
|
|
5016
|
-
self.comments.push self.lexer.comments
|
|
4575
|
+
def _reduce_319(val, _values, result)
|
|
4576
|
+
self.comments.push self.lexer.comments
|
|
5017
4577
|
self.in_def = true
|
|
5018
4578
|
self.env.extend
|
|
5019
4579
|
result = lexer.lineno, lexer.src.beginning_of_line?
|
|
5020
4580
|
|
|
5021
4581
|
result
|
|
5022
|
-
|
|
5023
|
-
.,.,
|
|
4582
|
+
end
|
|
5024
4583
|
|
|
5025
|
-
|
|
5026
|
-
|
|
5027
|
-
result = new_defn val
|
|
4584
|
+
def _reduce_320(val, _values, result)
|
|
4585
|
+
result = new_defn val
|
|
5028
4586
|
self.env.unextend
|
|
5029
4587
|
self.in_def = false
|
|
5030
4588
|
|
|
5031
4589
|
result
|
|
5032
|
-
|
|
5033
|
-
.,.,
|
|
4590
|
+
end
|
|
5034
4591
|
|
|
5035
|
-
|
|
5036
|
-
|
|
5037
|
-
self.comments.push self.lexer.comments
|
|
4592
|
+
def _reduce_321(val, _values, result)
|
|
4593
|
+
self.comments.push self.lexer.comments
|
|
5038
4594
|
lexer.lex_state = :expr_fname
|
|
5039
4595
|
|
|
5040
4596
|
result
|
|
5041
|
-
|
|
5042
|
-
.,.,
|
|
4597
|
+
end
|
|
5043
4598
|
|
|
5044
|
-
|
|
5045
|
-
|
|
5046
|
-
self.in_single += 1
|
|
4599
|
+
def _reduce_322(val, _values, result)
|
|
4600
|
+
self.in_single += 1
|
|
5047
4601
|
self.env.extend
|
|
5048
4602
|
lexer.lex_state = :expr_end # force for args
|
|
5049
4603
|
|
|
5050
4604
|
result
|
|
5051
|
-
|
|
5052
|
-
.,.,
|
|
4605
|
+
end
|
|
5053
4606
|
|
|
5054
|
-
|
|
5055
|
-
|
|
5056
|
-
result = new_defs val
|
|
4607
|
+
def _reduce_323(val, _values, result)
|
|
4608
|
+
result = new_defs val
|
|
5057
4609
|
|
|
5058
4610
|
self.env.unextend
|
|
5059
4611
|
self.in_single -= 1
|
|
5060
4612
|
|
|
5061
4613
|
result
|
|
5062
|
-
|
|
5063
|
-
.,.,
|
|
4614
|
+
end
|
|
5064
4615
|
|
|
5065
|
-
|
|
5066
|
-
|
|
5067
|
-
result = s(:break)
|
|
4616
|
+
def _reduce_324(val, _values, result)
|
|
4617
|
+
result = s(:break)
|
|
5068
4618
|
|
|
5069
4619
|
result
|
|
5070
|
-
|
|
5071
|
-
.,.,
|
|
4620
|
+
end
|
|
5072
4621
|
|
|
5073
|
-
|
|
5074
|
-
|
|
5075
|
-
result = s(:next)
|
|
4622
|
+
def _reduce_325(val, _values, result)
|
|
4623
|
+
result = s(:next)
|
|
5076
4624
|
|
|
5077
4625
|
result
|
|
5078
|
-
|
|
5079
|
-
.,.,
|
|
4626
|
+
end
|
|
5080
4627
|
|
|
5081
|
-
|
|
5082
|
-
|
|
5083
|
-
result = s(:redo)
|
|
4628
|
+
def _reduce_326(val, _values, result)
|
|
4629
|
+
result = s(:redo)
|
|
5084
4630
|
|
|
5085
4631
|
result
|
|
5086
|
-
|
|
5087
|
-
.,.,
|
|
4632
|
+
end
|
|
5088
4633
|
|
|
5089
|
-
|
|
5090
|
-
|
|
5091
|
-
result = s(:retry)
|
|
4634
|
+
def _reduce_327(val, _values, result)
|
|
4635
|
+
result = s(:retry)
|
|
5092
4636
|
|
|
5093
4637
|
result
|
|
5094
|
-
|
|
5095
|
-
.,.,
|
|
4638
|
+
end
|
|
5096
4639
|
|
|
5097
|
-
|
|
5098
|
-
|
|
5099
|
-
result = value_expr(val[0])
|
|
4640
|
+
def _reduce_328(val, _values, result)
|
|
4641
|
+
result = value_expr(val[0])
|
|
5100
4642
|
|
|
5101
4643
|
result
|
|
5102
|
-
|
|
5103
|
-
.,.,
|
|
4644
|
+
end
|
|
5104
4645
|
|
|
5105
4646
|
# reduce 329 omitted
|
|
5106
4647
|
|
|
@@ -5118,83 +4659,66 @@ module_eval(<<'.,.,', 'ruby_parser.y', 1161)
|
|
|
5118
4659
|
|
|
5119
4660
|
# reduce 336 omitted
|
|
5120
4661
|
|
|
5121
|
-
|
|
5122
|
-
|
|
5123
|
-
result = s(:if, val[1], val[3], val[4])
|
|
4662
|
+
def _reduce_337(val, _values, result)
|
|
4663
|
+
result = s(:if, val[1], val[3], val[4])
|
|
5124
4664
|
|
|
5125
4665
|
result
|
|
5126
|
-
|
|
5127
|
-
.,.,
|
|
4666
|
+
end
|
|
5128
4667
|
|
|
5129
4668
|
# reduce 338 omitted
|
|
5130
4669
|
|
|
5131
|
-
|
|
5132
|
-
|
|
5133
|
-
result = val[1]
|
|
4670
|
+
def _reduce_339(val, _values, result)
|
|
4671
|
+
result = val[1]
|
|
5134
4672
|
|
|
5135
4673
|
result
|
|
5136
|
-
|
|
5137
|
-
.,.,
|
|
4674
|
+
end
|
|
5138
4675
|
|
|
5139
4676
|
# reduce 340 omitted
|
|
5140
4677
|
|
|
5141
|
-
|
|
5142
|
-
|
|
5143
|
-
val[0].delete_at 1 if val[0][1].nil? # HACK
|
|
4678
|
+
def _reduce_341(val, _values, result)
|
|
4679
|
+
val[0].delete_at 1 if val[0][1].nil? # HACK
|
|
5144
4680
|
|
|
5145
4681
|
result
|
|
5146
|
-
|
|
5147
|
-
.,.,
|
|
4682
|
+
end
|
|
5148
4683
|
|
|
5149
4684
|
# reduce 342 omitted
|
|
5150
4685
|
|
|
5151
|
-
|
|
5152
|
-
|
|
5153
|
-
result = 0
|
|
4686
|
+
def _reduce_343(val, _values, result)
|
|
4687
|
+
result = 0
|
|
5154
4688
|
self.lexer.command_start = true
|
|
5155
4689
|
|
|
5156
4690
|
result
|
|
5157
|
-
|
|
5158
|
-
.,.,
|
|
4691
|
+
end
|
|
5159
4692
|
|
|
5160
|
-
|
|
5161
|
-
|
|
5162
|
-
result = 0
|
|
4693
|
+
def _reduce_344(val, _values, result)
|
|
4694
|
+
result = 0
|
|
5163
4695
|
self.lexer.command_start = true
|
|
5164
4696
|
|
|
5165
4697
|
result
|
|
5166
|
-
|
|
5167
|
-
.,.,
|
|
4698
|
+
end
|
|
5168
4699
|
|
|
5169
|
-
|
|
5170
|
-
|
|
5171
|
-
result = val[1]
|
|
4700
|
+
def _reduce_345(val, _values, result)
|
|
4701
|
+
result = val[1]
|
|
5172
4702
|
self.lexer.command_start = true
|
|
5173
4703
|
|
|
5174
4704
|
result
|
|
5175
|
-
|
|
5176
|
-
.,.,
|
|
4705
|
+
end
|
|
5177
4706
|
|
|
5178
|
-
|
|
5179
|
-
|
|
5180
|
-
self.env.extend :dynamic
|
|
4707
|
+
def _reduce_346(val, _values, result)
|
|
4708
|
+
self.env.extend :dynamic
|
|
5181
4709
|
result = self.lexer.lineno
|
|
5182
4710
|
|
|
5183
4711
|
result
|
|
5184
|
-
|
|
5185
|
-
.,.,
|
|
4712
|
+
end
|
|
5186
4713
|
|
|
5187
|
-
|
|
5188
|
-
|
|
5189
|
-
result = self.env.dynamic.keys
|
|
4714
|
+
def _reduce_347(val, _values, result)
|
|
4715
|
+
result = self.env.dynamic.keys
|
|
5190
4716
|
|
|
5191
4717
|
result
|
|
5192
|
-
|
|
5193
|
-
.,.,
|
|
4718
|
+
end
|
|
5194
4719
|
|
|
5195
|
-
|
|
5196
|
-
|
|
5197
|
-
vars = val[2]
|
|
4720
|
+
def _reduce_348(val, _values, result)
|
|
4721
|
+
vars = val[2]
|
|
5198
4722
|
body = val[4]
|
|
5199
4723
|
result = new_iter nil, vars, body
|
|
5200
4724
|
result.line = val[1]
|
|
@@ -5202,113 +4726,87 @@ module_eval(<<'.,.,', 'ruby_parser.y', 1219)
|
|
|
5202
4726
|
self.env.unextend
|
|
5203
4727
|
|
|
5204
4728
|
result
|
|
5205
|
-
|
|
5206
|
-
.,.,
|
|
4729
|
+
end
|
|
5207
4730
|
|
|
5208
|
-
|
|
5209
|
-
|
|
5210
|
-
raise SyntaxError, "Both block arg and actual block given." if
|
|
4731
|
+
def _reduce_349(val, _values, result)
|
|
4732
|
+
raise SyntaxError, "Both block arg and actual block given." if
|
|
5211
4733
|
val[0] && val[0][0] == :blockpass
|
|
5212
4734
|
|
|
5213
4735
|
result = val[1]
|
|
5214
4736
|
result.insert 1, val[0]
|
|
5215
4737
|
|
|
5216
4738
|
result
|
|
5217
|
-
|
|
5218
|
-
.,.,
|
|
4739
|
+
end
|
|
5219
4740
|
|
|
5220
|
-
|
|
5221
|
-
|
|
5222
|
-
result = new_call val[0], val[2], val[3]
|
|
4741
|
+
def _reduce_350(val, _values, result)
|
|
4742
|
+
result = new_call val[0], val[2], val[3]
|
|
5223
4743
|
|
|
5224
4744
|
result
|
|
5225
|
-
|
|
5226
|
-
.,.,
|
|
4745
|
+
end
|
|
5227
4746
|
|
|
5228
|
-
|
|
5229
|
-
|
|
5230
|
-
result = new_call val[0], val[2], val[3]
|
|
4747
|
+
def _reduce_351(val, _values, result)
|
|
4748
|
+
result = new_call val[0], val[2], val[3]
|
|
5231
4749
|
|
|
5232
4750
|
result
|
|
5233
|
-
|
|
5234
|
-
.,.,
|
|
4751
|
+
end
|
|
5235
4752
|
|
|
5236
|
-
|
|
5237
|
-
|
|
5238
|
-
result = self.lexer.lineno
|
|
4753
|
+
def _reduce_352(val, _values, result)
|
|
4754
|
+
result = self.lexer.lineno
|
|
5239
4755
|
|
|
5240
4756
|
result
|
|
5241
|
-
|
|
5242
|
-
.,.,
|
|
4757
|
+
end
|
|
5243
4758
|
|
|
5244
|
-
|
|
5245
|
-
|
|
5246
|
-
result = new_call nil, val[0].to_sym, val[2]
|
|
4759
|
+
def _reduce_353(val, _values, result)
|
|
4760
|
+
result = new_call nil, val[0].to_sym, val[2]
|
|
5247
4761
|
|
|
5248
4762
|
result
|
|
5249
|
-
|
|
5250
|
-
.,.,
|
|
4763
|
+
end
|
|
5251
4764
|
|
|
5252
|
-
|
|
5253
|
-
|
|
5254
|
-
result = new_call val[0], val[2].to_sym, val[3]
|
|
4765
|
+
def _reduce_354(val, _values, result)
|
|
4766
|
+
result = new_call val[0], val[2].to_sym, val[3]
|
|
5255
4767
|
|
|
5256
4768
|
result
|
|
5257
|
-
|
|
5258
|
-
.,.,
|
|
4769
|
+
end
|
|
5259
4770
|
|
|
5260
|
-
|
|
5261
|
-
|
|
5262
|
-
result = new_call val[0], val[2].to_sym, val[3]
|
|
4771
|
+
def _reduce_355(val, _values, result)
|
|
4772
|
+
result = new_call val[0], val[2].to_sym, val[3]
|
|
5263
4773
|
|
|
5264
4774
|
result
|
|
5265
|
-
|
|
5266
|
-
.,.,
|
|
4775
|
+
end
|
|
5267
4776
|
|
|
5268
|
-
|
|
5269
|
-
|
|
5270
|
-
result = new_call val[0], val[2].to_sym
|
|
4777
|
+
def _reduce_356(val, _values, result)
|
|
4778
|
+
result = new_call val[0], val[2].to_sym
|
|
5271
4779
|
|
|
5272
4780
|
result
|
|
5273
|
-
|
|
5274
|
-
.,.,
|
|
4781
|
+
end
|
|
5275
4782
|
|
|
5276
|
-
|
|
5277
|
-
|
|
5278
|
-
result = new_super val[1]
|
|
4783
|
+
def _reduce_357(val, _values, result)
|
|
4784
|
+
result = new_super val[1]
|
|
5279
4785
|
|
|
5280
4786
|
result
|
|
5281
|
-
|
|
5282
|
-
.,.,
|
|
4787
|
+
end
|
|
5283
4788
|
|
|
5284
|
-
|
|
5285
|
-
|
|
5286
|
-
result = s(:zsuper)
|
|
4789
|
+
def _reduce_358(val, _values, result)
|
|
4790
|
+
result = s(:zsuper)
|
|
5287
4791
|
|
|
5288
4792
|
result
|
|
5289
|
-
|
|
5290
|
-
.,.,
|
|
4793
|
+
end
|
|
5291
4794
|
|
|
5292
|
-
|
|
5293
|
-
|
|
5294
|
-
self.env.extend :dynamic
|
|
4795
|
+
def _reduce_359(val, _values, result)
|
|
4796
|
+
self.env.extend :dynamic
|
|
5295
4797
|
result = self.lexer.lineno
|
|
5296
4798
|
|
|
5297
4799
|
result
|
|
5298
|
-
|
|
5299
|
-
.,.,
|
|
4800
|
+
end
|
|
5300
4801
|
|
|
5301
|
-
|
|
5302
|
-
|
|
5303
|
-
result = self.env.dynamic.keys
|
|
4802
|
+
def _reduce_360(val, _values, result)
|
|
4803
|
+
result = self.env.dynamic.keys
|
|
5304
4804
|
|
|
5305
4805
|
result
|
|
5306
|
-
|
|
5307
|
-
.,.,
|
|
4806
|
+
end
|
|
5308
4807
|
|
|
5309
|
-
|
|
5310
|
-
|
|
5311
|
-
# REFACTOR
|
|
4808
|
+
def _reduce_361(val, _values, result)
|
|
4809
|
+
# REFACTOR
|
|
5312
4810
|
args = val[2]
|
|
5313
4811
|
body = val[4]
|
|
5314
4812
|
result = new_iter nil, args, body
|
|
@@ -5316,81 +4814,65 @@ module_eval(<<'.,.,', 'ruby_parser.y', 1284)
|
|
|
5316
4814
|
result.line = val[1]
|
|
5317
4815
|
|
|
5318
4816
|
result
|
|
5319
|
-
|
|
5320
|
-
.,.,
|
|
4817
|
+
end
|
|
5321
4818
|
|
|
5322
|
-
|
|
5323
|
-
|
|
5324
|
-
self.env.extend :dynamic
|
|
4819
|
+
def _reduce_362(val, _values, result)
|
|
4820
|
+
self.env.extend :dynamic
|
|
5325
4821
|
result = self.lexer.lineno
|
|
5326
4822
|
|
|
5327
4823
|
result
|
|
5328
|
-
|
|
5329
|
-
.,.,
|
|
4824
|
+
end
|
|
5330
4825
|
|
|
5331
|
-
|
|
5332
|
-
|
|
5333
|
-
result = self.env.dynamic.keys
|
|
4826
|
+
def _reduce_363(val, _values, result)
|
|
4827
|
+
result = self.env.dynamic.keys
|
|
5334
4828
|
|
|
5335
4829
|
result
|
|
5336
|
-
|
|
5337
|
-
.,.,
|
|
4830
|
+
end
|
|
5338
4831
|
|
|
5339
|
-
|
|
5340
|
-
|
|
5341
|
-
args = val[2]
|
|
4832
|
+
def _reduce_364(val, _values, result)
|
|
4833
|
+
args = val[2]
|
|
5342
4834
|
body = val[4]
|
|
5343
4835
|
result = new_iter nil, args, body
|
|
5344
4836
|
self.env.unextend
|
|
5345
4837
|
result.line = val[1]
|
|
5346
4838
|
|
|
5347
4839
|
result
|
|
5348
|
-
|
|
5349
|
-
.,.,
|
|
4840
|
+
end
|
|
5350
4841
|
|
|
5351
|
-
|
|
5352
|
-
|
|
5353
|
-
result = self.lexer.lineno
|
|
4842
|
+
def _reduce_365(val, _values, result)
|
|
4843
|
+
result = self.lexer.lineno
|
|
5354
4844
|
|
|
5355
4845
|
result
|
|
5356
|
-
|
|
5357
|
-
.,.,
|
|
4846
|
+
end
|
|
5358
4847
|
|
|
5359
|
-
|
|
5360
|
-
|
|
5361
|
-
result = s(:when, val[2], val[4])
|
|
4848
|
+
def _reduce_366(val, _values, result)
|
|
4849
|
+
result = s(:when, val[2], val[4])
|
|
5362
4850
|
result.line = val[1]
|
|
5363
4851
|
result << val[5] if val[5]
|
|
5364
4852
|
|
|
5365
4853
|
result
|
|
5366
|
-
|
|
5367
|
-
.,.,
|
|
4854
|
+
end
|
|
5368
4855
|
|
|
5369
4856
|
# reduce 367 omitted
|
|
5370
4857
|
|
|
5371
|
-
|
|
5372
|
-
|
|
5373
|
-
result = self.list_append val[0], s(:when, val[3], nil)
|
|
4858
|
+
def _reduce_368(val, _values, result)
|
|
4859
|
+
result = self.list_append val[0], s(:when, val[3], nil)
|
|
5374
4860
|
|
|
5375
4861
|
result
|
|
5376
|
-
|
|
5377
|
-
.,.,
|
|
4862
|
+
end
|
|
5378
4863
|
|
|
5379
|
-
|
|
5380
|
-
|
|
5381
|
-
result = s(:array, s(:when, val[1], nil))
|
|
4864
|
+
def _reduce_369(val, _values, result)
|
|
4865
|
+
result = s(:array, s(:when, val[1], nil))
|
|
5382
4866
|
|
|
5383
4867
|
result
|
|
5384
|
-
|
|
5385
|
-
.,.,
|
|
4868
|
+
end
|
|
5386
4869
|
|
|
5387
4870
|
# reduce 370 omitted
|
|
5388
4871
|
|
|
5389
4872
|
# reduce 371 omitted
|
|
5390
4873
|
|
|
5391
|
-
|
|
5392
|
-
|
|
5393
|
-
klasses, var, body, rest = val[1], val[2], val[4], val[5]
|
|
4874
|
+
def _reduce_372(val, _values, result)
|
|
4875
|
+
klasses, var, body, rest = val[1], val[2], val[4], val[5]
|
|
5394
4876
|
|
|
5395
4877
|
klasses ||= s(:array)
|
|
5396
4878
|
klasses << node_assign(var, s(:gvar, :"$!")) if var
|
|
@@ -5399,269 +4881,209 @@ module_eval(<<'.,.,', 'ruby_parser.y', 1334)
|
|
|
5399
4881
|
result << rest if rest # UGH, rewritten above
|
|
5400
4882
|
|
|
5401
4883
|
result
|
|
5402
|
-
|
|
5403
|
-
.,.,
|
|
4884
|
+
end
|
|
5404
4885
|
|
|
5405
|
-
|
|
5406
|
-
|
|
5407
|
-
result = nil
|
|
4886
|
+
def _reduce_373(val, _values, result)
|
|
4887
|
+
result = nil
|
|
5408
4888
|
|
|
5409
4889
|
result
|
|
5410
|
-
|
|
5411
|
-
.,.,
|
|
4890
|
+
end
|
|
5412
4891
|
|
|
5413
|
-
|
|
5414
|
-
|
|
5415
|
-
result = s(:array, val[0])
|
|
4892
|
+
def _reduce_374(val, _values, result)
|
|
4893
|
+
result = s(:array, val[0])
|
|
5416
4894
|
|
|
5417
4895
|
result
|
|
5418
|
-
|
|
5419
|
-
.,.,
|
|
4896
|
+
end
|
|
5420
4897
|
|
|
5421
4898
|
# reduce 375 omitted
|
|
5422
4899
|
|
|
5423
4900
|
# reduce 376 omitted
|
|
5424
4901
|
|
|
5425
|
-
|
|
5426
|
-
|
|
5427
|
-
result = val[1]
|
|
4902
|
+
def _reduce_377(val, _values, result)
|
|
4903
|
+
result = val[1]
|
|
5428
4904
|
|
|
5429
4905
|
result
|
|
5430
|
-
|
|
5431
|
-
.,.,
|
|
4906
|
+
end
|
|
5432
4907
|
|
|
5433
4908
|
# reduce 378 omitted
|
|
5434
4909
|
|
|
5435
|
-
|
|
5436
|
-
|
|
5437
|
-
if (val[1] != nil) then
|
|
4910
|
+
def _reduce_379(val, _values, result)
|
|
4911
|
+
if (val[1] != nil) then
|
|
5438
4912
|
result = val[1]
|
|
5439
4913
|
else
|
|
5440
4914
|
result = s(:nil)
|
|
5441
4915
|
end
|
|
5442
4916
|
|
|
5443
4917
|
result
|
|
5444
|
-
|
|
5445
|
-
.,.,
|
|
4918
|
+
end
|
|
5446
4919
|
|
|
5447
4920
|
# reduce 380 omitted
|
|
5448
4921
|
|
|
5449
|
-
|
|
5450
|
-
|
|
5451
|
-
result = s(:lit, val[0])
|
|
4922
|
+
def _reduce_381(val, _values, result)
|
|
4923
|
+
result = s(:lit, val[0])
|
|
5452
4924
|
result
|
|
5453
|
-
|
|
5454
|
-
.,.,
|
|
4925
|
+
end
|
|
5455
4926
|
|
|
5456
|
-
|
|
5457
|
-
|
|
5458
|
-
result = s(:lit, val[0])
|
|
4927
|
+
def _reduce_382(val, _values, result)
|
|
4928
|
+
result = s(:lit, val[0])
|
|
5459
4929
|
result
|
|
5460
|
-
|
|
5461
|
-
.,.,
|
|
4930
|
+
end
|
|
5462
4931
|
|
|
5463
4932
|
# reduce 383 omitted
|
|
5464
4933
|
|
|
5465
|
-
|
|
5466
|
-
|
|
5467
|
-
val[0] = s(:dstr, val[0].value) if val[0][0] == :evstr
|
|
4934
|
+
def _reduce_384(val, _values, result)
|
|
4935
|
+
val[0] = s(:dstr, val[0].value) if val[0][0] == :evstr
|
|
5468
4936
|
result = val[0]
|
|
5469
4937
|
|
|
5470
4938
|
result
|
|
5471
|
-
|
|
5472
|
-
.,.,
|
|
4939
|
+
end
|
|
5473
4940
|
|
|
5474
4941
|
# reduce 385 omitted
|
|
5475
4942
|
|
|
5476
|
-
|
|
5477
|
-
|
|
5478
|
-
result = self.literal_concat val[0], val[1]
|
|
4943
|
+
def _reduce_386(val, _values, result)
|
|
4944
|
+
result = self.literal_concat val[0], val[1]
|
|
5479
4945
|
|
|
5480
4946
|
result
|
|
5481
|
-
|
|
5482
|
-
.,.,
|
|
4947
|
+
end
|
|
5483
4948
|
|
|
5484
|
-
|
|
5485
|
-
|
|
5486
|
-
result = val[1]
|
|
4949
|
+
def _reduce_387(val, _values, result)
|
|
4950
|
+
result = val[1]
|
|
5487
4951
|
|
|
5488
4952
|
result
|
|
5489
|
-
|
|
5490
|
-
.,.,
|
|
4953
|
+
end
|
|
5491
4954
|
|
|
5492
|
-
|
|
5493
|
-
|
|
5494
|
-
result = s(:str, val[0])
|
|
4955
|
+
def _reduce_388(val, _values, result)
|
|
4956
|
+
result = s(:str, val[0])
|
|
5495
4957
|
|
|
5496
4958
|
result
|
|
5497
|
-
|
|
5498
|
-
.,.,
|
|
4959
|
+
end
|
|
5499
4960
|
|
|
5500
|
-
|
|
5501
|
-
|
|
5502
|
-
result = new_xstring val[1]
|
|
4961
|
+
def _reduce_389(val, _values, result)
|
|
4962
|
+
result = new_xstring val[1]
|
|
5503
4963
|
|
|
5504
4964
|
result
|
|
5505
|
-
|
|
5506
|
-
.,.,
|
|
4965
|
+
end
|
|
5507
4966
|
|
|
5508
|
-
|
|
5509
|
-
|
|
5510
|
-
result = new_regexp val
|
|
4967
|
+
def _reduce_390(val, _values, result)
|
|
4968
|
+
result = new_regexp val
|
|
5511
4969
|
|
|
5512
4970
|
result
|
|
5513
|
-
|
|
5514
|
-
.,.,
|
|
4971
|
+
end
|
|
5515
4972
|
|
|
5516
|
-
|
|
5517
|
-
|
|
5518
|
-
result = s(:array)
|
|
4973
|
+
def _reduce_391(val, _values, result)
|
|
4974
|
+
result = s(:array)
|
|
5519
4975
|
|
|
5520
4976
|
result
|
|
5521
|
-
|
|
5522
|
-
.,.,
|
|
4977
|
+
end
|
|
5523
4978
|
|
|
5524
|
-
|
|
5525
|
-
|
|
5526
|
-
result = val[1]
|
|
4979
|
+
def _reduce_392(val, _values, result)
|
|
4980
|
+
result = val[1]
|
|
5527
4981
|
|
|
5528
4982
|
result
|
|
5529
|
-
|
|
5530
|
-
.,.,
|
|
4983
|
+
end
|
|
5531
4984
|
|
|
5532
|
-
|
|
5533
|
-
|
|
5534
|
-
result = s(:array)
|
|
4985
|
+
def _reduce_393(val, _values, result)
|
|
4986
|
+
result = s(:array)
|
|
5535
4987
|
|
|
5536
4988
|
result
|
|
5537
|
-
|
|
5538
|
-
.,.,
|
|
4989
|
+
end
|
|
5539
4990
|
|
|
5540
|
-
|
|
5541
|
-
|
|
5542
|
-
word = val[1][0] == :evstr ? s(:dstr, "", val[1]) : val[1]
|
|
4991
|
+
def _reduce_394(val, _values, result)
|
|
4992
|
+
word = val[1][0] == :evstr ? s(:dstr, "", val[1]) : val[1]
|
|
5543
4993
|
result = val[0] << word
|
|
5544
4994
|
|
|
5545
4995
|
result
|
|
5546
|
-
|
|
5547
|
-
.,.,
|
|
4996
|
+
end
|
|
5548
4997
|
|
|
5549
4998
|
# reduce 395 omitted
|
|
5550
4999
|
|
|
5551
|
-
|
|
5552
|
-
|
|
5553
|
-
result = self.literal_concat val[0], val[1]
|
|
5000
|
+
def _reduce_396(val, _values, result)
|
|
5001
|
+
result = self.literal_concat val[0], val[1]
|
|
5554
5002
|
|
|
5555
5003
|
result
|
|
5556
|
-
|
|
5557
|
-
.,.,
|
|
5004
|
+
end
|
|
5558
5005
|
|
|
5559
|
-
|
|
5560
|
-
|
|
5561
|
-
result = s(:array)
|
|
5006
|
+
def _reduce_397(val, _values, result)
|
|
5007
|
+
result = s(:array)
|
|
5562
5008
|
|
|
5563
5009
|
result
|
|
5564
|
-
|
|
5565
|
-
.,.,
|
|
5010
|
+
end
|
|
5566
5011
|
|
|
5567
|
-
|
|
5568
|
-
|
|
5569
|
-
result = val[1]
|
|
5012
|
+
def _reduce_398(val, _values, result)
|
|
5013
|
+
result = val[1]
|
|
5570
5014
|
|
|
5571
5015
|
result
|
|
5572
|
-
|
|
5573
|
-
.,.,
|
|
5016
|
+
end
|
|
5574
5017
|
|
|
5575
|
-
|
|
5576
|
-
|
|
5577
|
-
result = s(:array)
|
|
5018
|
+
def _reduce_399(val, _values, result)
|
|
5019
|
+
result = s(:array)
|
|
5578
5020
|
|
|
5579
5021
|
result
|
|
5580
|
-
|
|
5581
|
-
.,.,
|
|
5022
|
+
end
|
|
5582
5023
|
|
|
5583
|
-
|
|
5584
|
-
|
|
5585
|
-
result = val[0] << s(:str, val[1])
|
|
5024
|
+
def _reduce_400(val, _values, result)
|
|
5025
|
+
result = val[0] << s(:str, val[1])
|
|
5586
5026
|
|
|
5587
5027
|
result
|
|
5588
|
-
|
|
5589
|
-
.,.,
|
|
5028
|
+
end
|
|
5590
5029
|
|
|
5591
|
-
|
|
5592
|
-
|
|
5593
|
-
result = s(:str, "")
|
|
5030
|
+
def _reduce_401(val, _values, result)
|
|
5031
|
+
result = s(:str, "")
|
|
5594
5032
|
|
|
5595
5033
|
result
|
|
5596
|
-
|
|
5597
|
-
.,.,
|
|
5034
|
+
end
|
|
5598
5035
|
|
|
5599
|
-
|
|
5600
|
-
|
|
5601
|
-
result = literal_concat(val[0], val[1])
|
|
5036
|
+
def _reduce_402(val, _values, result)
|
|
5037
|
+
result = literal_concat(val[0], val[1])
|
|
5602
5038
|
|
|
5603
5039
|
result
|
|
5604
|
-
|
|
5605
|
-
.,.,
|
|
5040
|
+
end
|
|
5606
5041
|
|
|
5607
|
-
|
|
5608
|
-
|
|
5609
|
-
result = nil
|
|
5042
|
+
def _reduce_403(val, _values, result)
|
|
5043
|
+
result = nil
|
|
5610
5044
|
|
|
5611
5045
|
result
|
|
5612
|
-
|
|
5613
|
-
.,.,
|
|
5046
|
+
end
|
|
5614
5047
|
|
|
5615
|
-
|
|
5616
|
-
|
|
5617
|
-
result = literal_concat(val[0], val[1])
|
|
5048
|
+
def _reduce_404(val, _values, result)
|
|
5049
|
+
result = literal_concat(val[0], val[1])
|
|
5618
5050
|
|
|
5619
5051
|
result
|
|
5620
|
-
|
|
5621
|
-
.,.,
|
|
5052
|
+
end
|
|
5622
5053
|
|
|
5623
|
-
|
|
5624
|
-
|
|
5625
|
-
result = s(:str, val[0])
|
|
5054
|
+
def _reduce_405(val, _values, result)
|
|
5055
|
+
result = s(:str, val[0])
|
|
5626
5056
|
|
|
5627
5057
|
result
|
|
5628
|
-
|
|
5629
|
-
.,.,
|
|
5058
|
+
end
|
|
5630
5059
|
|
|
5631
|
-
|
|
5632
|
-
|
|
5633
|
-
result = lexer.lex_strterm
|
|
5060
|
+
def _reduce_406(val, _values, result)
|
|
5061
|
+
result = lexer.lex_strterm
|
|
5634
5062
|
lexer.lex_strterm = nil
|
|
5635
5063
|
lexer.lex_state = :expr_beg
|
|
5636
5064
|
|
|
5637
5065
|
result
|
|
5638
|
-
|
|
5639
|
-
.,.,
|
|
5066
|
+
end
|
|
5640
5067
|
|
|
5641
|
-
|
|
5642
|
-
|
|
5643
|
-
lexer.lex_strterm = val[1]
|
|
5068
|
+
def _reduce_407(val, _values, result)
|
|
5069
|
+
lexer.lex_strterm = val[1]
|
|
5644
5070
|
result = s(:evstr, val[2])
|
|
5645
5071
|
|
|
5646
5072
|
result
|
|
5647
|
-
|
|
5648
|
-
.,.,
|
|
5073
|
+
end
|
|
5649
5074
|
|
|
5650
|
-
|
|
5651
|
-
|
|
5652
|
-
result = lexer.lex_strterm
|
|
5075
|
+
def _reduce_408(val, _values, result)
|
|
5076
|
+
result = lexer.lex_strterm
|
|
5653
5077
|
lexer.lex_strterm = nil
|
|
5654
5078
|
lexer.lex_state = :expr_beg
|
|
5655
5079
|
lexer.cond.push false
|
|
5656
5080
|
lexer.cmdarg.push false
|
|
5657
5081
|
|
|
5658
5082
|
result
|
|
5659
|
-
|
|
5660
|
-
.,.,
|
|
5083
|
+
end
|
|
5661
5084
|
|
|
5662
|
-
|
|
5663
|
-
|
|
5664
|
-
lexer.lex_strterm = val[1]
|
|
5085
|
+
def _reduce_409(val, _values, result)
|
|
5086
|
+
lexer.lex_strterm = val[1]
|
|
5665
5087
|
lexer.cond.lexpop
|
|
5666
5088
|
lexer.cmdarg.lexpop
|
|
5667
5089
|
|
|
@@ -5680,48 +5102,37 @@ module_eval(<<'.,.,', 'ruby_parser.y', 1491)
|
|
|
5680
5102
|
end
|
|
5681
5103
|
|
|
5682
5104
|
result
|
|
5683
|
-
|
|
5684
|
-
.,.,
|
|
5105
|
+
end
|
|
5685
5106
|
|
|
5686
|
-
|
|
5687
|
-
|
|
5688
|
-
result = s(:gvar, val[0].to_sym)
|
|
5107
|
+
def _reduce_410(val, _values, result)
|
|
5108
|
+
result = s(:gvar, val[0].to_sym)
|
|
5689
5109
|
result
|
|
5690
|
-
|
|
5691
|
-
.,.,
|
|
5110
|
+
end
|
|
5692
5111
|
|
|
5693
|
-
|
|
5694
|
-
|
|
5695
|
-
result = s(:ivar, val[0].to_sym)
|
|
5112
|
+
def _reduce_411(val, _values, result)
|
|
5113
|
+
result = s(:ivar, val[0].to_sym)
|
|
5696
5114
|
result
|
|
5697
|
-
|
|
5698
|
-
.,.,
|
|
5115
|
+
end
|
|
5699
5116
|
|
|
5700
|
-
|
|
5701
|
-
|
|
5702
|
-
result = s(:cvar, val[0].to_sym)
|
|
5117
|
+
def _reduce_412(val, _values, result)
|
|
5118
|
+
result = s(:cvar, val[0].to_sym)
|
|
5703
5119
|
result
|
|
5704
|
-
|
|
5705
|
-
.,.,
|
|
5120
|
+
end
|
|
5706
5121
|
|
|
5707
5122
|
# reduce 413 omitted
|
|
5708
5123
|
|
|
5709
|
-
|
|
5710
|
-
|
|
5711
|
-
lexer.lex_state = :expr_end
|
|
5124
|
+
def _reduce_414(val, _values, result)
|
|
5125
|
+
lexer.lex_state = :expr_end
|
|
5712
5126
|
result = val[1].to_sym
|
|
5713
5127
|
|
|
5714
5128
|
result
|
|
5715
|
-
|
|
5716
|
-
.,.,
|
|
5129
|
+
end
|
|
5717
5130
|
|
|
5718
|
-
|
|
5719
|
-
|
|
5720
|
-
result = val[0].to_sym
|
|
5131
|
+
def _reduce_415(val, _values, result)
|
|
5132
|
+
result = val[0].to_sym
|
|
5721
5133
|
|
|
5722
5134
|
result
|
|
5723
|
-
|
|
5724
|
-
.,.,
|
|
5135
|
+
end
|
|
5725
5136
|
|
|
5726
5137
|
# reduce 416 omitted
|
|
5727
5138
|
|
|
@@ -5731,9 +5142,8 @@ module_eval(<<'.,.,', 'ruby_parser.y', 1523)
|
|
|
5731
5142
|
|
|
5732
5143
|
# reduce 419 omitted
|
|
5733
5144
|
|
|
5734
|
-
|
|
5735
|
-
|
|
5736
|
-
lexer.lex_state = :expr_end
|
|
5145
|
+
def _reduce_420(val, _values, result)
|
|
5146
|
+
lexer.lex_state = :expr_end
|
|
5737
5147
|
result = val[1]
|
|
5738
5148
|
|
|
5739
5149
|
yyerror "empty symbol literal" if
|
|
@@ -5749,28 +5159,23 @@ module_eval(<<'.,.,', 'ruby_parser.y', 1530)
|
|
|
5749
5159
|
end
|
|
5750
5160
|
|
|
5751
5161
|
result
|
|
5752
|
-
|
|
5753
|
-
.,.,
|
|
5162
|
+
end
|
|
5754
5163
|
|
|
5755
5164
|
# reduce 421 omitted
|
|
5756
5165
|
|
|
5757
5166
|
# reduce 422 omitted
|
|
5758
5167
|
|
|
5759
|
-
|
|
5760
|
-
|
|
5761
|
-
result = -val[1] # TODO: pt_testcase
|
|
5168
|
+
def _reduce_423(val, _values, result)
|
|
5169
|
+
result = -val[1] # TODO: pt_testcase
|
|
5762
5170
|
|
|
5763
5171
|
result
|
|
5764
|
-
|
|
5765
|
-
.,.,
|
|
5172
|
+
end
|
|
5766
5173
|
|
|
5767
|
-
|
|
5768
|
-
|
|
5769
|
-
result = -val[1] # TODO: pt_testcase
|
|
5174
|
+
def _reduce_424(val, _values, result)
|
|
5175
|
+
result = -val[1] # TODO: pt_testcase
|
|
5770
5176
|
|
|
5771
5177
|
result
|
|
5772
|
-
|
|
5773
|
-
.,.,
|
|
5178
|
+
end
|
|
5774
5179
|
|
|
5775
5180
|
# reduce 425 omitted
|
|
5776
5181
|
|
|
@@ -5782,411 +5187,318 @@ module_eval(<<'.,.,', 'ruby_parser.y', 1554)
|
|
|
5782
5187
|
|
|
5783
5188
|
# reduce 429 omitted
|
|
5784
5189
|
|
|
5785
|
-
|
|
5786
|
-
|
|
5787
|
-
result = :nil
|
|
5190
|
+
def _reduce_430(val, _values, result)
|
|
5191
|
+
result = s(:nil)
|
|
5788
5192
|
result
|
|
5789
|
-
|
|
5790
|
-
.,.,
|
|
5193
|
+
end
|
|
5791
5194
|
|
|
5792
|
-
|
|
5793
|
-
|
|
5794
|
-
result = :self
|
|
5195
|
+
def _reduce_431(val, _values, result)
|
|
5196
|
+
result = s(:self)
|
|
5795
5197
|
result
|
|
5796
|
-
|
|
5797
|
-
.,.,
|
|
5198
|
+
end
|
|
5798
5199
|
|
|
5799
|
-
|
|
5800
|
-
|
|
5801
|
-
result = :true
|
|
5200
|
+
def _reduce_432(val, _values, result)
|
|
5201
|
+
result = s(:true)
|
|
5802
5202
|
result
|
|
5803
|
-
|
|
5804
|
-
.,.,
|
|
5203
|
+
end
|
|
5805
5204
|
|
|
5806
|
-
|
|
5807
|
-
|
|
5808
|
-
result = :false
|
|
5205
|
+
def _reduce_433(val, _values, result)
|
|
5206
|
+
result = s(:false)
|
|
5809
5207
|
result
|
|
5810
|
-
|
|
5811
|
-
.,.,
|
|
5208
|
+
end
|
|
5812
5209
|
|
|
5813
|
-
|
|
5814
|
-
|
|
5815
|
-
result = :__FILE__
|
|
5210
|
+
def _reduce_434(val, _values, result)
|
|
5211
|
+
result = s(:str, self.file)
|
|
5816
5212
|
result
|
|
5817
|
-
|
|
5818
|
-
.,.,
|
|
5213
|
+
end
|
|
5819
5214
|
|
|
5820
|
-
|
|
5821
|
-
|
|
5822
|
-
result = :__LINE__
|
|
5215
|
+
def _reduce_435(val, _values, result)
|
|
5216
|
+
result = s(:lit, lexer.src.current_line)
|
|
5823
5217
|
result
|
|
5824
|
-
|
|
5825
|
-
.,.,
|
|
5218
|
+
end
|
|
5826
5219
|
|
|
5827
|
-
|
|
5828
|
-
|
|
5829
|
-
|
|
5220
|
+
def _reduce_436(val, _values, result)
|
|
5221
|
+
var = val[0]
|
|
5222
|
+
result = Sexp === var ? var : self.gettable(var)
|
|
5830
5223
|
|
|
5831
5224
|
result
|
|
5832
|
-
|
|
5833
|
-
.,.,
|
|
5225
|
+
end
|
|
5834
5226
|
|
|
5835
|
-
|
|
5836
|
-
|
|
5837
|
-
result = self.assignable val[0]
|
|
5227
|
+
def _reduce_437(val, _values, result)
|
|
5228
|
+
result = self.assignable val[0]
|
|
5838
5229
|
|
|
5839
5230
|
result
|
|
5840
|
-
|
|
5841
|
-
.,.,
|
|
5231
|
+
end
|
|
5842
5232
|
|
|
5843
|
-
|
|
5844
|
-
|
|
5845
|
-
result = s(:nth_ref, val[0])
|
|
5233
|
+
def _reduce_438(val, _values, result)
|
|
5234
|
+
result = s(:nth_ref, val[0])
|
|
5846
5235
|
result
|
|
5847
|
-
|
|
5848
|
-
.,.,
|
|
5236
|
+
end
|
|
5849
5237
|
|
|
5850
|
-
|
|
5851
|
-
|
|
5852
|
-
result = s(:back_ref, val[0])
|
|
5238
|
+
def _reduce_439(val, _values, result)
|
|
5239
|
+
result = s(:back_ref, val[0])
|
|
5853
5240
|
result
|
|
5854
|
-
|
|
5855
|
-
.,.,
|
|
5241
|
+
end
|
|
5856
5242
|
|
|
5857
|
-
|
|
5858
|
-
|
|
5859
|
-
result = nil
|
|
5243
|
+
def _reduce_440(val, _values, result)
|
|
5244
|
+
result = nil
|
|
5860
5245
|
|
|
5861
5246
|
result
|
|
5862
|
-
|
|
5863
|
-
.,.,
|
|
5247
|
+
end
|
|
5864
5248
|
|
|
5865
|
-
|
|
5866
|
-
|
|
5867
|
-
lexer.lex_state = :expr_beg
|
|
5249
|
+
def _reduce_441(val, _values, result)
|
|
5250
|
+
lexer.lex_state = :expr_beg
|
|
5868
5251
|
|
|
5869
5252
|
result
|
|
5870
|
-
|
|
5871
|
-
.,.,
|
|
5253
|
+
end
|
|
5872
5254
|
|
|
5873
|
-
|
|
5874
|
-
|
|
5875
|
-
result = val[2]
|
|
5255
|
+
def _reduce_442(val, _values, result)
|
|
5256
|
+
result = val[2]
|
|
5876
5257
|
|
|
5877
5258
|
result
|
|
5878
|
-
|
|
5879
|
-
.,.,
|
|
5259
|
+
end
|
|
5880
5260
|
|
|
5881
|
-
|
|
5882
|
-
|
|
5883
|
-
yyerrok
|
|
5261
|
+
def _reduce_443(val, _values, result)
|
|
5262
|
+
yyerrok
|
|
5884
5263
|
result = nil
|
|
5885
5264
|
|
|
5886
5265
|
result
|
|
5887
|
-
|
|
5888
|
-
.,.,
|
|
5266
|
+
end
|
|
5889
5267
|
|
|
5890
|
-
|
|
5891
|
-
|
|
5892
|
-
result = val[1]
|
|
5268
|
+
def _reduce_444(val, _values, result)
|
|
5269
|
+
result = val[1]
|
|
5893
5270
|
lexer.lex_state = :expr_beg
|
|
5894
5271
|
self.lexer.command_start = true
|
|
5895
5272
|
|
|
5896
5273
|
result
|
|
5897
|
-
|
|
5898
|
-
.,.,
|
|
5274
|
+
end
|
|
5899
5275
|
|
|
5900
|
-
|
|
5901
|
-
|
|
5902
|
-
result = val[0]
|
|
5276
|
+
def _reduce_445(val, _values, result)
|
|
5277
|
+
result = val[0]
|
|
5903
5278
|
|
|
5904
5279
|
result
|
|
5905
|
-
|
|
5906
|
-
.,.,
|
|
5280
|
+
end
|
|
5907
5281
|
|
|
5908
|
-
|
|
5909
|
-
|
|
5910
|
-
result = args val[0], val[2], val[4], val[5]
|
|
5282
|
+
def _reduce_446(val, _values, result)
|
|
5283
|
+
result = args val[0], val[2], val[4], val[5]
|
|
5911
5284
|
|
|
5912
5285
|
result
|
|
5913
|
-
|
|
5914
|
-
.,.,
|
|
5286
|
+
end
|
|
5915
5287
|
|
|
5916
|
-
|
|
5917
|
-
|
|
5918
|
-
result = args val[0], val[2], nil, val[3]
|
|
5288
|
+
def _reduce_447(val, _values, result)
|
|
5289
|
+
result = args val[0], val[2], nil, val[3]
|
|
5919
5290
|
|
|
5920
5291
|
result
|
|
5921
|
-
|
|
5922
|
-
.,.,
|
|
5292
|
+
end
|
|
5923
5293
|
|
|
5924
|
-
|
|
5925
|
-
|
|
5926
|
-
result = args val[0], nil, val[2], val[3]
|
|
5294
|
+
def _reduce_448(val, _values, result)
|
|
5295
|
+
result = args val[0], nil, val[2], val[3]
|
|
5927
5296
|
|
|
5928
5297
|
result
|
|
5929
|
-
|
|
5930
|
-
.,.,
|
|
5298
|
+
end
|
|
5931
5299
|
|
|
5932
|
-
|
|
5933
|
-
|
|
5934
|
-
result = args val[0], nil, nil, val[1]
|
|
5300
|
+
def _reduce_449(val, _values, result)
|
|
5301
|
+
result = args val[0], nil, nil, val[1]
|
|
5935
5302
|
|
|
5936
5303
|
result
|
|
5937
|
-
|
|
5938
|
-
.,.,
|
|
5304
|
+
end
|
|
5939
5305
|
|
|
5940
|
-
|
|
5941
|
-
|
|
5942
|
-
result = args nil, val[0], val[2], val[3]
|
|
5306
|
+
def _reduce_450(val, _values, result)
|
|
5307
|
+
result = args nil, val[0], val[2], val[3]
|
|
5943
5308
|
|
|
5944
5309
|
result
|
|
5945
|
-
|
|
5946
|
-
.,.,
|
|
5310
|
+
end
|
|
5947
5311
|
|
|
5948
|
-
|
|
5949
|
-
|
|
5950
|
-
result = args nil, val[0], nil, val[1]
|
|
5312
|
+
def _reduce_451(val, _values, result)
|
|
5313
|
+
result = args nil, val[0], nil, val[1]
|
|
5951
5314
|
|
|
5952
5315
|
result
|
|
5953
|
-
|
|
5954
|
-
.,.,
|
|
5316
|
+
end
|
|
5955
5317
|
|
|
5956
|
-
|
|
5957
|
-
|
|
5958
|
-
result = args nil, nil, val[0], val[1]
|
|
5318
|
+
def _reduce_452(val, _values, result)
|
|
5319
|
+
result = args nil, nil, val[0], val[1]
|
|
5959
5320
|
|
|
5960
5321
|
result
|
|
5961
|
-
|
|
5962
|
-
.,.,
|
|
5322
|
+
end
|
|
5963
5323
|
|
|
5964
|
-
|
|
5965
|
-
|
|
5966
|
-
result = args nil, nil, nil, val[0]
|
|
5324
|
+
def _reduce_453(val, _values, result)
|
|
5325
|
+
result = args nil, nil, nil, val[0]
|
|
5967
5326
|
|
|
5968
5327
|
result
|
|
5969
|
-
|
|
5970
|
-
.,.,
|
|
5328
|
+
end
|
|
5971
5329
|
|
|
5972
|
-
|
|
5973
|
-
|
|
5974
|
-
result = args nil, nil, nil, nil
|
|
5330
|
+
def _reduce_454(val, _values, result)
|
|
5331
|
+
result = args nil, nil, nil, nil
|
|
5975
5332
|
|
|
5976
5333
|
result
|
|
5977
|
-
|
|
5978
|
-
.,.,
|
|
5334
|
+
end
|
|
5979
5335
|
|
|
5980
|
-
|
|
5981
|
-
|
|
5982
|
-
yyerror "formal argument cannot be a constant: #{val[0]}"
|
|
5336
|
+
def _reduce_455(val, _values, result)
|
|
5337
|
+
yyerror "formal argument cannot be a constant: #{val[0]}"
|
|
5983
5338
|
|
|
5984
5339
|
result
|
|
5985
|
-
|
|
5986
|
-
.,.,
|
|
5340
|
+
end
|
|
5987
5341
|
|
|
5988
|
-
|
|
5989
|
-
|
|
5990
|
-
yyerror "formal argument cannot be an instance variable"
|
|
5342
|
+
def _reduce_456(val, _values, result)
|
|
5343
|
+
yyerror "formal argument cannot be an instance variable"
|
|
5991
5344
|
|
|
5992
5345
|
result
|
|
5993
|
-
|
|
5994
|
-
.,.,
|
|
5346
|
+
end
|
|
5995
5347
|
|
|
5996
|
-
|
|
5997
|
-
|
|
5998
|
-
yyerror "formal argument cannot be a class variable"
|
|
5348
|
+
def _reduce_457(val, _values, result)
|
|
5349
|
+
yyerror "formal argument cannot be a class variable"
|
|
5999
5350
|
|
|
6000
5351
|
result
|
|
6001
|
-
|
|
6002
|
-
.,.,
|
|
5352
|
+
end
|
|
6003
5353
|
|
|
6004
|
-
|
|
6005
|
-
|
|
6006
|
-
identifier = val[0].to_sym
|
|
5354
|
+
def _reduce_458(val, _values, result)
|
|
5355
|
+
identifier = val[0].to_sym
|
|
6007
5356
|
self.env[identifier] = :lvar
|
|
6008
5357
|
|
|
6009
5358
|
result = val[0]
|
|
6010
5359
|
|
|
6011
5360
|
result
|
|
6012
|
-
|
|
6013
|
-
.,.,
|
|
5361
|
+
end
|
|
6014
5362
|
|
|
6015
|
-
|
|
6016
|
-
|
|
6017
|
-
result = s(:args)
|
|
5363
|
+
def _reduce_459(val, _values, result)
|
|
5364
|
+
result = s(:args)
|
|
6018
5365
|
result << val[0].to_sym
|
|
6019
5366
|
|
|
6020
5367
|
result
|
|
6021
|
-
|
|
6022
|
-
.,.,
|
|
5368
|
+
end
|
|
6023
5369
|
|
|
6024
|
-
|
|
6025
|
-
|
|
6026
|
-
val[0] << val[2].to_sym
|
|
5370
|
+
def _reduce_460(val, _values, result)
|
|
5371
|
+
val[0] << val[2].to_sym
|
|
6027
5372
|
result = val[0]
|
|
6028
5373
|
|
|
6029
5374
|
result
|
|
6030
|
-
|
|
6031
|
-
.,.,
|
|
5375
|
+
end
|
|
6032
5376
|
|
|
6033
|
-
|
|
6034
|
-
|
|
6035
|
-
result = self.assignable val[0], val[2]
|
|
5377
|
+
def _reduce_461(val, _values, result)
|
|
5378
|
+
result = self.assignable val[0], val[2]
|
|
6036
5379
|
# TODO: detect duplicate names
|
|
6037
5380
|
|
|
6038
5381
|
result
|
|
6039
|
-
|
|
6040
|
-
.,.,
|
|
5382
|
+
end
|
|
6041
5383
|
|
|
6042
|
-
|
|
6043
|
-
|
|
6044
|
-
result = s(:block, val[0])
|
|
5384
|
+
def _reduce_462(val, _values, result)
|
|
5385
|
+
result = s(:block, val[0])
|
|
6045
5386
|
|
|
6046
5387
|
result
|
|
6047
|
-
|
|
6048
|
-
.,.,
|
|
5388
|
+
end
|
|
6049
5389
|
|
|
6050
|
-
|
|
6051
|
-
|
|
6052
|
-
result = self.block_append val[0], val[2]
|
|
5390
|
+
def _reduce_463(val, _values, result)
|
|
5391
|
+
result = self.block_append val[0], val[2]
|
|
6053
5392
|
|
|
6054
5393
|
result
|
|
6055
|
-
|
|
6056
|
-
.,.,
|
|
5394
|
+
end
|
|
6057
5395
|
|
|
6058
5396
|
# reduce 464 omitted
|
|
6059
5397
|
|
|
6060
5398
|
# reduce 465 omitted
|
|
6061
5399
|
|
|
6062
|
-
|
|
6063
|
-
|
|
6064
|
-
# TODO: differs from parse.y - needs tests
|
|
5400
|
+
def _reduce_466(val, _values, result)
|
|
5401
|
+
# TODO: differs from parse.y - needs tests
|
|
6065
5402
|
name = val[1].to_sym
|
|
6066
5403
|
self.assignable name
|
|
6067
5404
|
result = :"*#{name}"
|
|
6068
5405
|
|
|
6069
5406
|
result
|
|
6070
|
-
|
|
6071
|
-
.,.,
|
|
5407
|
+
end
|
|
6072
5408
|
|
|
6073
|
-
|
|
6074
|
-
|
|
6075
|
-
name = :"*"
|
|
5409
|
+
def _reduce_467(val, _values, result)
|
|
5410
|
+
name = :"*"
|
|
6076
5411
|
self.env[name] = :lvar
|
|
6077
5412
|
result = name
|
|
6078
5413
|
|
|
6079
5414
|
result
|
|
6080
|
-
|
|
6081
|
-
.,.,
|
|
5415
|
+
end
|
|
6082
5416
|
|
|
6083
5417
|
# reduce 468 omitted
|
|
6084
5418
|
|
|
6085
5419
|
# reduce 469 omitted
|
|
6086
5420
|
|
|
6087
|
-
|
|
6088
|
-
|
|
6089
|
-
identifier = val[1].to_sym
|
|
5421
|
+
def _reduce_470(val, _values, result)
|
|
5422
|
+
identifier = val[1].to_sym
|
|
6090
5423
|
|
|
6091
5424
|
self.env[identifier] = :lvar
|
|
6092
5425
|
result = s(:block_arg, identifier.to_sym)
|
|
6093
5426
|
|
|
6094
5427
|
result
|
|
6095
|
-
|
|
6096
|
-
.,.,
|
|
5428
|
+
end
|
|
6097
5429
|
|
|
6098
|
-
|
|
6099
|
-
|
|
6100
|
-
result = val[1]
|
|
5430
|
+
def _reduce_471(val, _values, result)
|
|
5431
|
+
result = val[1]
|
|
6101
5432
|
|
|
6102
5433
|
result
|
|
6103
|
-
|
|
6104
|
-
.,.,
|
|
5434
|
+
end
|
|
6105
5435
|
|
|
6106
|
-
|
|
6107
|
-
|
|
6108
|
-
result = nil
|
|
5436
|
+
def _reduce_472(val, _values, result)
|
|
5437
|
+
result = nil
|
|
6109
5438
|
|
|
6110
5439
|
result
|
|
6111
|
-
|
|
6112
|
-
.,.,
|
|
5440
|
+
end
|
|
6113
5441
|
|
|
6114
5442
|
# reduce 473 omitted
|
|
6115
5443
|
|
|
6116
|
-
|
|
6117
|
-
|
|
6118
|
-
lexer.lex_state = :expr_beg
|
|
5444
|
+
def _reduce_474(val, _values, result)
|
|
5445
|
+
lexer.lex_state = :expr_beg
|
|
6119
5446
|
|
|
6120
5447
|
result
|
|
6121
|
-
|
|
6122
|
-
.,.,
|
|
5448
|
+
end
|
|
6123
5449
|
|
|
6124
|
-
|
|
6125
|
-
|
|
6126
|
-
result = val[2]
|
|
5450
|
+
def _reduce_475(val, _values, result)
|
|
5451
|
+
result = val[2]
|
|
6127
5452
|
yyerror "Can't define single method for literals." if
|
|
6128
5453
|
result[0] == :lit
|
|
6129
5454
|
|
|
6130
5455
|
result
|
|
6131
|
-
|
|
6132
|
-
.,.,
|
|
5456
|
+
end
|
|
6133
5457
|
|
|
6134
|
-
|
|
6135
|
-
|
|
6136
|
-
result = s(:array)
|
|
5458
|
+
def _reduce_476(val, _values, result)
|
|
5459
|
+
result = s(:array)
|
|
6137
5460
|
|
|
6138
5461
|
result
|
|
6139
|
-
|
|
6140
|
-
.,.,
|
|
5462
|
+
end
|
|
6141
5463
|
|
|
6142
|
-
|
|
6143
|
-
|
|
6144
|
-
result = val[0]
|
|
5464
|
+
def _reduce_477(val, _values, result)
|
|
5465
|
+
result = val[0]
|
|
6145
5466
|
|
|
6146
5467
|
result
|
|
6147
|
-
|
|
6148
|
-
.,.,
|
|
5468
|
+
end
|
|
6149
5469
|
|
|
6150
|
-
|
|
6151
|
-
|
|
6152
|
-
size = val[0].size
|
|
5470
|
+
def _reduce_478(val, _values, result)
|
|
5471
|
+
size = val[0].size
|
|
6153
5472
|
if (size % 2 != 1) then # != 1 because of leading :array
|
|
6154
5473
|
yyerror "Odd number (#{size}) list for Hash. #{val[0].inspect}"
|
|
6155
5474
|
end
|
|
6156
5475
|
result = val[0]
|
|
6157
5476
|
|
|
6158
5477
|
result
|
|
6159
|
-
|
|
6160
|
-
.,.,
|
|
5478
|
+
end
|
|
6161
5479
|
|
|
6162
5480
|
# reduce 479 omitted
|
|
6163
5481
|
|
|
6164
|
-
|
|
6165
|
-
|
|
6166
|
-
list = val[0].dup
|
|
5482
|
+
def _reduce_480(val, _values, result)
|
|
5483
|
+
list = val[0].dup
|
|
6167
5484
|
more = val[2][1..-1]
|
|
6168
5485
|
list.push(*more) unless more.empty?
|
|
6169
5486
|
result = list
|
|
6170
5487
|
|
|
6171
5488
|
result
|
|
6172
|
-
|
|
6173
|
-
.,.,
|
|
5489
|
+
end
|
|
6174
5490
|
|
|
6175
|
-
|
|
6176
|
-
|
|
6177
|
-
result = s(:array, s(:lit, val[0][0..-2].to_sym), val[1])
|
|
5491
|
+
def _reduce_481(val, _values, result)
|
|
5492
|
+
result = s(:array, s(:lit, val[0][0..-2].to_sym), val[1])
|
|
6178
5493
|
|
|
6179
5494
|
result
|
|
6180
|
-
|
|
6181
|
-
.,.,
|
|
5495
|
+
end
|
|
6182
5496
|
|
|
6183
|
-
|
|
6184
|
-
|
|
6185
|
-
result = s(:array, val[0], val[2])
|
|
5497
|
+
def _reduce_482(val, _values, result)
|
|
5498
|
+
result = s(:array, val[0], val[2])
|
|
6186
5499
|
|
|
6187
5500
|
result
|
|
6188
|
-
|
|
6189
|
-
.,.,
|
|
5501
|
+
end
|
|
6190
5502
|
|
|
6191
5503
|
# reduce 483 omitted
|
|
6192
5504
|
|
|
@@ -6226,37 +5538,29 @@ module_eval(<<'.,.,', 'ruby_parser.y', 1773)
|
|
|
6226
5538
|
|
|
6227
5539
|
# reduce 501 omitted
|
|
6228
5540
|
|
|
6229
|
-
|
|
6230
|
-
|
|
6231
|
-
yyerrok
|
|
5541
|
+
def _reduce_502(val, _values, result)
|
|
5542
|
+
yyerrok
|
|
6232
5543
|
result
|
|
6233
|
-
|
|
6234
|
-
.,.,
|
|
5544
|
+
end
|
|
6235
5545
|
|
|
6236
5546
|
# reduce 503 omitted
|
|
6237
5547
|
|
|
6238
5548
|
# reduce 504 omitted
|
|
6239
5549
|
|
|
6240
|
-
|
|
6241
|
-
|
|
6242
|
-
yyerrok
|
|
5550
|
+
def _reduce_505(val, _values, result)
|
|
5551
|
+
yyerrok
|
|
6243
5552
|
result
|
|
6244
|
-
|
|
6245
|
-
.,.,
|
|
5553
|
+
end
|
|
6246
5554
|
|
|
6247
|
-
|
|
6248
|
-
|
|
6249
|
-
result = nil
|
|
5555
|
+
def _reduce_506(val, _values, result)
|
|
5556
|
+
result = nil
|
|
6250
5557
|
result
|
|
6251
|
-
|
|
6252
|
-
.,.,
|
|
5558
|
+
end
|
|
6253
5559
|
|
|
6254
|
-
|
|
6255
|
-
|
|
6256
|
-
result = nil
|
|
5560
|
+
def _reduce_507(val, _values, result)
|
|
5561
|
+
result = nil
|
|
6257
5562
|
result
|
|
6258
|
-
|
|
6259
|
-
.,.,
|
|
5563
|
+
end
|
|
6260
5564
|
|
|
6261
5565
|
def _reduce_none(val, _values, result)
|
|
6262
5566
|
val[0]
|