def advance
Return next token: [type, value].
def advance
if @token_queue.any?
return @token_queue.shift
end
# Ugly, but dependent on Ragel output. Consider refactoring it somehow.
_lex_trans_keys = self.class.send :_lex_trans_keys
_lex_key_spans = self.class.send :_lex_key_spans
_lex_index_offsets = self.class.send :_lex_index_offsets
_lex_indicies = self.class.send :_lex_indicies
_lex_trans_targs = self.class.send :_lex_trans_targs
_lex_trans_actions = self.class.send :_lex_trans_actions
_lex_to_state_actions = self.class.send :_lex_to_state_actions
_lex_from_state_actions = self.class.send :_lex_from_state_actions
_lex_eof_trans = self.class.send :_lex_eof_trans
p, pe, eof = @p, @source.length + 1, @source.length + 1
@command_state = (@cs == self.class.lex_en_expr_value ||
@cs == self.class.lex_en_line_begin)
line 10513 "lib/parser/lexer.rb"
gin
estEof = false
slen, _trans, _keys, _inds, _acts, _nacts = nil
goto_level = 0
resume = 10
eof_trans = 15
again = 20
test_eof = 30
out = 40
hile true
f _goto_level <= 0
f p == pe
_goto_level = _test_eof
next
nd
f @cs == 0
_goto_level = _out
next
nd
nd
f _goto_level <= _resume
ase _lex_from_state_actions[ @cs]
hen 72 then
line 1 "NONE"
begin
ts = p
end
line 10541 "lib/parser/lexer.rb"
nd
keys = @cs << 1
inds = _lex_index_offsets[ @cs]
slen = _lex_key_spans[ @cs]
trans = if ( _slen > 0 &&
_lex_trans_keys[_keys] <= ( (@source_pts[p] || 0)) &&
( (@source_pts[p] || 0)) <= _lex_trans_keys[_keys + 1]
) then
_lex_indicies[ _inds + ( (@source_pts[p] || 0)) - _lex_trans_keys[_keys] ]
else
_lex_indicies[ _inds + _slen ]
end
nd
f _goto_level <= _eof_trans
@cs = _lex_trans_targs[_trans]
f _lex_trans_actions[_trans] != 0
ase _lex_trans_actions[_trans]
hen 20 then
line 452 "lib/parser/lexer.rl"
begin
# Record position of a newline for precise location reporting on tNL
# tokens.
#
# This action is embedded directly into c_nl, as it is idempotent and
# there are no cases when we need to skip it.
@newline_s = p
end
hen 50 then
line 722 "lib/parser/lexer.rl"
begin
@escape_s = p
@escape = nil
end
hen 21 then
line 762 "lib/parser/lexer.rl"
begin
# After every heredoc was parsed, @herebody_s contains the
# position of next token after all heredocs.
if @herebody_s
p = @herebody_s
@herebody_s = nil
end
end
hen 61 then
line 1035 "lib/parser/lexer.rl"
begin
sharp_s = p - 1 end
hen 64 then
line 1038 "lib/parser/lexer.rl"
begin
mit_comment(@sharp_s, p == pe ? p - 2 : p) end
hen 253 then
line 1079 "lib/parser/lexer.rl"
begin
m = p end
hen 29 then
line 1347 "lib/parser/lexer.rl"
begin
m = p end
hen 32 then
line 1376 "lib/parser/lexer.rl"
begin
m = p end
hen 47 then
line 1561 "lib/parser/lexer.rl"
begin
heredoc_e = p end
hen 322 then
line 1680 "lib/parser/lexer.rl"
begin
m = p end
hen 376 then
line 1873 "lib/parser/lexer.rl"
begin
num_base = 16; @num_digits_s = p end
hen 370 then
line 1875 "lib/parser/lexer.rl"
begin
num_base = 10; @num_digits_s = p end
hen 373 then
line 1877 "lib/parser/lexer.rl"
begin
num_base = 8; @num_digits_s = p end
hen 366 then
line 1879 "lib/parser/lexer.rl"
begin
num_base = 2; @num_digits_s = p end
hen 379 then
line 1882 "lib/parser/lexer.rl"
begin
num_base = 10; @num_digits_s = @ts end
hen 362 then
line 1885 "lib/parser/lexer.rl"
begin
num_base = 8; @num_digits_s = @ts end
hen 5 then
line 1 "NONE"
begin
te = p+1
end
hen 90 then
line 947 "lib/parser/lexer.rl"
begin
te = p+1
egin
literal.flush_string
literal.extend_content
emit(:tSTRING_DBEG, '#{')
if literal.heredoc?
literal.saved_herebody_s = @herebody_s
@herebody_s = nil
end
literal.start_interp_brace
begin
@stack[ @top] = @cs
@top+= 1
@cs = 728
_goto_level = _again
next
nd
end
end
hen 3 then
line 895 "lib/parser/lexer.rl"
begin
te = p+1
egin
literal.flush_string
literal.extend_content
emit(:tSTRING_DVAR, nil, @ts, @ts + 1)
p = @ts
begin
@stack[ @top] = @cs
@top+= 1
@cs = 302
_goto_level = _again
next
nd
end
end
hen 86 then
line 829 "lib/parser/lexer.rl"
begin
te = p+1
egin
if @te == pe
diagnostic :fatal, Parser::ERRORS[:string_eof],
range(literal.str_s, literal.str_s + 1)
end
if literal.heredoc?
line = tok(@herebody_s, @ts).gsub(/\r+$/, '')
# Try ending the heredoc with the complete most recently
# scanned line. @herebody_s always refers to the start of such line.
if literal.nest_and_try_closing(line, @herebody_s, @ts)
# Adjust @herebody_s to point to the next line.
@herebody_s = @te
# Continue regular lexing after the heredoc reference (<<END).
p = literal.heredoc_e - 1
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
else
# Ditto.
@herebody_s = @te
end
else
# Try ending the literal with a newline.
if literal.nest_and_try_closing(tok, @ts, @te)
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
end
if @herebody_s
# This is a regular literal intertwined with a heredoc. Like:
#
# p <<-foo+"1
# bar
# foo
# 2"
#
# which, incidentally, evaluates to "bar\n12".
p = @herebody_s - 1
@herebody_s = nil
end
end
if literal.words? && !eof_codepoint?(@source_pts[p])
literal.extend_space @ts, @te
else
# A literal newline is appended if the heredoc was _not_ closed
# this time (see fbreak above). See also Literal#nest_and_try_closing
# for rationale of calling #flush_string here.
literal.extend_string tok, @ts, @te
literal.flush_string
end
end
end
hen 85 then
line 771 "lib/parser/lexer.rl"
begin
te = p+1
egin
string = @source[@ts...@te]
if !literal.heredoc? && literal.nest_and_try_closing(string, @ts, @te)
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
else
literal.extend_string(string, @ts, @te)
end
end
end
hen 91 then
line 895 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
literal.flush_string
literal.extend_content
emit(:tSTRING_DVAR, nil, @ts, @ts + 1)
p = @ts
begin
@stack[ @top] = @cs
@top+= 1
@cs = 302
_goto_level = _again
next
nd
end
end
hen 88 then
line 882 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
literal.extend_space @ts, @te
end
end
hen 89 then
line 771 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
string = @source[@ts...@te]
if !literal.heredoc? && literal.nest_and_try_closing(string, @ts, @te)
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
else
literal.extend_string(string, @ts, @te)
end
end
end
hen 4 then
line 781 "lib/parser/lexer.rl"
begin
egin p = (( @te))-1; end
egin
if literal.nest_and_try_closing('\\', @ts, @ts + 1)
# If the literal is actually closed by the backslash,
# rewind the input prior to consuming the escape sequence.
p = @escape_s - 1
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
else
# Get the first character after the backslash.
escaped_char = @source[@escape_s].chr
if literal.munge_escape? escaped_char
# If this particular literal uses this character as an opening
# or closing delimiter, it is an escape sequence for that
# particular character. Write it without the backslash.
if literal.regexp?
# Regular expressions should have every escape sequence in its
# raw form.
literal.extend_string(tok, @ts, @te)
else
literal.extend_string(escaped_char, @ts, @te)
end
else
# It does not. So this is an actual escape sequence, yay!
# Two things to consider here.
#
# 1. The `escape' rule should be pure and so won't raise any
# errors by itself. Instead, it stores them in lambdas.
#
# 2. Non-interpolated literals do not go through the aforementioned
# rule. As \\ and \' (and variants) are munged, the full token
# should always be written for such literals.
@escape.call if @escape.respond_to? :call
if literal.regexp?
# Ditto. Also, expand escaped newlines.
literal.extend_string(tok.gsub("\\\n", ''), @ts, @te)
else
literal.extend_string(@escape || tok, @ts, @te)
end
end
end
end
end
hen 2 then
line 771 "lib/parser/lexer.rl"
begin
egin p = (( @te))-1; end
egin
string = @source[@ts...@te]
if !literal.heredoc? && literal.nest_and_try_closing(string, @ts, @te)
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
else
literal.extend_string(string, @ts, @te)
end
end
end
hen 117 then
line 947 "lib/parser/lexer.rl"
begin
te = p+1
egin
literal.flush_string
literal.extend_content
emit(:tSTRING_DBEG, '#{')
if literal.heredoc?
literal.saved_herebody_s = @herebody_s
@herebody_s = nil
end
literal.start_interp_brace
begin
@stack[ @top] = @cs
@top+= 1
@cs = 728
_goto_level = _again
next
nd
end
end
hen 8 then
line 895 "lib/parser/lexer.rl"
begin
te = p+1
egin
literal.flush_string
literal.extend_content
emit(:tSTRING_DVAR, nil, @ts, @ts + 1)
p = @ts
begin
@stack[ @top] = @cs
@top+= 1
@cs = 302
_goto_level = _again
next
nd
end
end
hen 114 then
line 829 "lib/parser/lexer.rl"
begin
te = p+1
egin
if @te == pe
diagnostic :fatal, Parser::ERRORS[:string_eof],
range(literal.str_s, literal.str_s + 1)
end
if literal.heredoc?
line = tok(@herebody_s, @ts).gsub(/\r+$/, '')
# Try ending the heredoc with the complete most recently
# scanned line. @herebody_s always refers to the start of such line.
if literal.nest_and_try_closing(line, @herebody_s, @ts)
# Adjust @herebody_s to point to the next line.
@herebody_s = @te
# Continue regular lexing after the heredoc reference (<<END).
p = literal.heredoc_e - 1
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
else
# Ditto.
@herebody_s = @te
end
else
# Try ending the literal with a newline.
if literal.nest_and_try_closing(tok, @ts, @te)
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
end
if @herebody_s
# This is a regular literal intertwined with a heredoc. Like:
#
# p <<-foo+"1
# bar
# foo
# 2"
#
# which, incidentally, evaluates to "bar\n12".
p = @herebody_s - 1
@herebody_s = nil
end
end
if literal.words? && !eof_codepoint?(@source_pts[p])
literal.extend_space @ts, @te
else
# A literal newline is appended if the heredoc was _not_ closed
# this time (see fbreak above). See also Literal#nest_and_try_closing
# for rationale of calling #flush_string here.
literal.extend_string tok, @ts, @te
literal.flush_string
end
end
end
hen 113 then
line 771 "lib/parser/lexer.rl"
begin
te = p+1
egin
string = @source[@ts...@te]
if !literal.heredoc? && literal.nest_and_try_closing(string, @ts, @te)
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
else
literal.extend_string(string, @ts, @te)
end
end
end
hen 118 then
line 895 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
literal.flush_string
literal.extend_content
emit(:tSTRING_DVAR, nil, @ts, @ts + 1)
p = @ts
begin
@stack[ @top] = @cs
@top+= 1
@cs = 302
_goto_level = _again
next
nd
end
end
hen 116 then
line 771 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
string = @source[@ts...@te]
if !literal.heredoc? && literal.nest_and_try_closing(string, @ts, @te)
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
else
literal.extend_string(string, @ts, @te)
end
end
end
hen 9 then
line 781 "lib/parser/lexer.rl"
begin
egin p = (( @te))-1; end
egin
if literal.nest_and_try_closing('\\', @ts, @ts + 1)
# If the literal is actually closed by the backslash,
# rewind the input prior to consuming the escape sequence.
p = @escape_s - 1
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
else
# Get the first character after the backslash.
escaped_char = @source[@escape_s].chr
if literal.munge_escape? escaped_char
# If this particular literal uses this character as an opening
# or closing delimiter, it is an escape sequence for that
# particular character. Write it without the backslash.
if literal.regexp?
# Regular expressions should have every escape sequence in its
# raw form.
literal.extend_string(tok, @ts, @te)
else
literal.extend_string(escaped_char, @ts, @te)
end
else
# It does not. So this is an actual escape sequence, yay!
# Two things to consider here.
#
# 1. The `escape' rule should be pure and so won't raise any
# errors by itself. Instead, it stores them in lambdas.
#
# 2. Non-interpolated literals do not go through the aforementioned
# rule. As \\ and \' (and variants) are munged, the full token
# should always be written for such literals.
@escape.call if @escape.respond_to? :call
if literal.regexp?
# Ditto. Also, expand escaped newlines.
literal.extend_string(tok.gsub("\\\n", ''), @ts, @te)
else
literal.extend_string(@escape || tok, @ts, @te)
end
end
end
end
end
hen 7 then
line 771 "lib/parser/lexer.rl"
begin
egin p = (( @te))-1; end
egin
string = @source[@ts...@te]
if !literal.heredoc? && literal.nest_and_try_closing(string, @ts, @te)
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
else
literal.extend_string(string, @ts, @te)
end
end
end
hen 141 then
line 829 "lib/parser/lexer.rl"
begin
te = p+1
egin
if @te == pe
diagnostic :fatal, Parser::ERRORS[:string_eof],
range(literal.str_s, literal.str_s + 1)
end
if literal.heredoc?
line = tok(@herebody_s, @ts).gsub(/\r+$/, '')
# Try ending the heredoc with the complete most recently
# scanned line. @herebody_s always refers to the start of such line.
if literal.nest_and_try_closing(line, @herebody_s, @ts)
# Adjust @herebody_s to point to the next line.
@herebody_s = @te
# Continue regular lexing after the heredoc reference (<<END).
p = literal.heredoc_e - 1
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
else
# Ditto.
@herebody_s = @te
end
else
# Try ending the literal with a newline.
if literal.nest_and_try_closing(tok, @ts, @te)
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
end
if @herebody_s
# This is a regular literal intertwined with a heredoc. Like:
#
# p <<-foo+"1
# bar
# foo
# 2"
#
# which, incidentally, evaluates to "bar\n12".
p = @herebody_s - 1
@herebody_s = nil
end
end
if literal.words? && !eof_codepoint?(@source_pts[p])
literal.extend_space @ts, @te
else
# A literal newline is appended if the heredoc was _not_ closed
# this time (see fbreak above). See also Literal#nest_and_try_closing
# for rationale of calling #flush_string here.
literal.extend_string tok, @ts, @te
literal.flush_string
end
end
end
hen 140 then
line 771 "lib/parser/lexer.rl"
begin
te = p+1
egin
string = @source[@ts...@te]
if !literal.heredoc? && literal.nest_and_try_closing(string, @ts, @te)
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
else
literal.extend_string(string, @ts, @te)
end
end
end
hen 143 then
line 882 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
literal.extend_space @ts, @te
end
end
hen 144 then
line 771 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
string = @source[@ts...@te]
if !literal.heredoc? && literal.nest_and_try_closing(string, @ts, @te)
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
else
literal.extend_string(string, @ts, @te)
end
end
end
hen 147 then
line 829 "lib/parser/lexer.rl"
begin
te = p+1
egin
if @te == pe
diagnostic :fatal, Parser::ERRORS[:string_eof],
range(literal.str_s, literal.str_s + 1)
end
if literal.heredoc?
line = tok(@herebody_s, @ts).gsub(/\r+$/, '')
# Try ending the heredoc with the complete most recently
# scanned line. @herebody_s always refers to the start of such line.
if literal.nest_and_try_closing(line, @herebody_s, @ts)
# Adjust @herebody_s to point to the next line.
@herebody_s = @te
# Continue regular lexing after the heredoc reference (<<END).
p = literal.heredoc_e - 1
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
else
# Ditto.
@herebody_s = @te
end
else
# Try ending the literal with a newline.
if literal.nest_and_try_closing(tok, @ts, @te)
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
end
if @herebody_s
# This is a regular literal intertwined with a heredoc. Like:
#
# p <<-foo+"1
# bar
# foo
# 2"
#
# which, incidentally, evaluates to "bar\n12".
p = @herebody_s - 1
@herebody_s = nil
end
end
if literal.words? && !eof_codepoint?(@source_pts[p])
literal.extend_space @ts, @te
else
# A literal newline is appended if the heredoc was _not_ closed
# this time (see fbreak above). See also Literal#nest_and_try_closing
# for rationale of calling #flush_string here.
literal.extend_string tok, @ts, @te
literal.flush_string
end
end
end
hen 146 then
line 771 "lib/parser/lexer.rl"
begin
te = p+1
egin
string = @source[@ts...@te]
if !literal.heredoc? && literal.nest_and_try_closing(string, @ts, @te)
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
else
literal.extend_string(string, @ts, @te)
end
end
end
hen 149 then
line 771 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
string = @source[@ts...@te]
if !literal.heredoc? && literal.nest_and_try_closing(string, @ts, @te)
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
else
literal.extend_string(string, @ts, @te)
end
end
end
hen 152 then
line 1010 "lib/parser/lexer.rl"
begin
te = p+1
egin
emit(:tREGEXP_OPT, tok(@ts, @te - 1), @ts, @te - 1)
p = p - 1; begin
@cs = 736
_goto_level = _again
next
nd
end
end
hen 153 then
line 998 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
unknown_options = tok.scan(/[^imxouesn]/)
if unknown_options.any?
message = Parser::ERRORS[:regexp_options] % { :options => unknown_options.join }
diagnostic :error, message
end
emit(:tREGEXP_OPT)
@cs = 736; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 10 then
line 1138 "lib/parser/lexer.rl"
begin
te = p+1
egin
if tok =~ /^\$([1-9][0-9]*)$/
emit(:tNTH_REF, tok(@ts + 1).to_i)
elsif tok =~ /^\$([&`'+])$/
emit(:tBACK_REF)
else
emit(:tGVAR)
end
@cs = (stack_pop); begin
p += 1
_goto_level = _out
next
nd
end
end
hen 154 then
line 1138 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
if tok =~ /^\$([1-9][0-9]*)$/
emit(:tNTH_REF, tok(@ts + 1).to_i)
elsif tok =~ /^\$([&`'+])$/
emit(:tBACK_REF)
else
emit(:tGVAR)
end
@cs = (stack_pop); begin
p += 1
_goto_level = _out
next
nd
end
end
hen 156 then
line 1151 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
if tok =~ /^@@[0-9]/
message = Parser::ERRORS[:cvar_name] % { :name => tok }
diagnostic :error, message
end
emit(:tCVAR)
@cs = (stack_pop); begin
p += 1
_goto_level = _out
next
nd
end
end
hen 155 then
line 1162 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
if tok =~ /^@[0-9]/
message = Parser::ERRORS[:ivar_name] % { :name => tok }
diagnostic :error, message
end
emit(:tIVAR)
@cs = (stack_pop); begin
p += 1
_goto_level = _out
next
nd
end
end
hen 177 then
line 1184 "lib/parser/lexer.rl"
begin
te = p+1
egin emit(KEYWORDS_BEGIN[tok]);
@cs = 419; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 163 then
line 1192 "lib/parser/lexer.rl"
begin
te = p+1
egin emit(:tIDENTIFIER)
@cs = 419; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 12 then
line 1196 "lib/parser/lexer.rl"
begin
te = p+1
egin p = @ts - 1
@cs = 736; begin
@stack[ @top] = @cs
@top+= 1
@cs = 302
_goto_level = _again
next
nd
end
end
hen 160 then
line 1205 "lib/parser/lexer.rl"
begin
te = p+1
egin emit_table(PUNCTUATION)
@cs = 419; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 172 then
line 1209 "lib/parser/lexer.rl"
begin
te = p+1
egin p = p - 1; p = p - 1; begin
@cs = 736
_goto_level = _again
next
nd
end
end
hen 159 then
line 1217 "lib/parser/lexer.rl"
begin
te = p+1
egin p = p - 1; begin
@cs = 736
_goto_level = _again
next
nd
end
end
hen 158 then
line 478 "lib/parser/lexer.rl"
begin
te = p+1
egin
# Sit at EOF indefinitely. #advance would return $eof each time.
# This allows to feed the lexer more data if needed; this is only used
# in tests.
#
# Note that this action is not embedded into e_eof like e_heredoc_nl and e_bs
# below. This is due to the fact that scanner state at EOF is observed
# by tests, and encapsulating it in a rule would break the introspection.
p = p - 1; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 176 then
line 1184 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin emit(KEYWORDS_BEGIN[tok]);
@cs = 419; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 173 then
line 1188 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin emit(:tCONSTANT)
@cs = 419; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 175 then
line 1192 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin emit(:tIDENTIFIER)
@cs = 419; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 170 then
line 1196 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin p = @ts - 1
@cs = 736; begin
@stack[ @top] = @cs
@top+= 1
@cs = 302
_goto_level = _again
next
nd
end
end
hen 166 then
line 1205 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin emit_table(PUNCTUATION)
@cs = 419; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 171 then
line 1212 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin p = p - 1; begin
@cs = 516
_goto_level = _again
next
nd
end
end
hen 164 then
line 1214 "lib/parser/lexer.rl"
begin
te = p
= p - 1; end
hen 169 then
line 1217 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin p = p - 1; begin
@cs = 736
_goto_level = _again
next
nd
end
end
hen 11 then
line 1217 "lib/parser/lexer.rl"
begin
egin p = (( @te))-1; end
egin p = p - 1; begin
@cs = 736
_goto_level = _again
next
nd
end
end
hen 162 then
line 1 "NONE"
begin
ase @act
hen 25 then
egin begin p = (( @te))-1; end
mit(KEYWORDS_BEGIN[tok]);
@cs = 419; begin
p += 1
_goto_level = _out
next
nd
nd
hen 26 then
egin begin p = (( @te))-1; end
mit(:tCONSTANT)
@cs = 419; begin
p += 1
_goto_level = _out
next
nd
nd
hen 27 then
egin begin p = (( @te))-1; end
mit(:tIDENTIFIER)
@cs = 419; begin
p += 1
_goto_level = _out
next
nd
nd
d
end
hen 14 then
line 1229 "lib/parser/lexer.rl"
begin
te = p+1
egin emit(:tLABEL, tok(@ts, @te - 1))
@cs = 516; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 179 then
line 1235 "lib/parser/lexer.rl"
begin
te = p+1
egin p = p - 1; begin
@cs = 736
_goto_level = _again
next
nd
end
end
hen 178 then
line 478 "lib/parser/lexer.rl"
begin
te = p+1
egin
# Sit at EOF indefinitely. #advance would return $eof each time.
# This allows to feed the lexer more data if needed; this is only used
# in tests.
#
# Note that this action is not embedded into e_eof like e_heredoc_nl and e_bs
# below. This is due to the fact that scanner state at EOF is observed
# by tests, and encapsulating it in a rule would break the introspection.
p = p - 1; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 181 then
line 1232 "lib/parser/lexer.rl"
begin
te = p
= p - 1; end
hen 180 then
line 1235 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin p = p - 1; begin
@cs = 736
_goto_level = _again
next
nd
end
end
hen 13 then
line 1235 "lib/parser/lexer.rl"
begin
egin p = (( @te))-1; end
egin p = p - 1; begin
@cs = 736
_goto_level = _again
next
nd
end
end
hen 187 then
line 1261 "lib/parser/lexer.rl"
begin
te = p+1
egin emit_table(PUNCTUATION)
@cs = 448; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 186 then
line 1267 "lib/parser/lexer.rl"
begin
te = p+1
egin p = p - 1; begin
@cs = 736
_goto_level = _again
next
nd
end
end
hen 185 then
line 478 "lib/parser/lexer.rl"
begin
te = p+1
egin
# Sit at EOF indefinitely. #advance would return $eof each time.
# This allows to feed the lexer more data if needed; this is only used
# in tests.
#
# Note that this action is not embedded into e_eof like e_heredoc_nl and e_bs
# below. This is due to the fact that scanner state at EOF is observed
# by tests, and encapsulating it in a rule would break the introspection.
p = p - 1; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 197 then
line 1246 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin emit(:tCONSTANT)
@cs = (arg_or_cmdarg); begin
p += 1
_goto_level = _out
next
nd
end
end
hen 188 then
line 1250 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin emit(:tIDENTIFIER)
@cs = (arg_or_cmdarg); begin
p += 1
_goto_level = _out
next
nd
end
end
hen 193 then
line 1261 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin emit_table(PUNCTUATION)
@cs = 448; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 191 then
line 1264 "lib/parser/lexer.rl"
begin
te = p
= p - 1; end
hen 196 then
line 1267 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin p = p - 1; begin
@cs = 736
_goto_level = _again
next
nd
end
end
hen 201 then
line 1325 "lib/parser/lexer.rl"
begin
te = p+1
egin p = p - 1; begin
@cs = 516
_goto_level = _again
next
nd
end
end
hen 203 then
line 1333 "lib/parser/lexer.rl"
begin
te = p+1
egin p = p - 1; p = p - 1; begin
@cs = 516
_goto_level = _again
next
nd
end
end
hen 210 then
line 1360 "lib/parser/lexer.rl"
begin
te = p+1
egin p = p - 1; p = p - 1; begin
@cs = 516
_goto_level = _again
next
nd
end
end
hen 16 then
line 1368 "lib/parser/lexer.rl"
begin
te = p+1
egin p = @ts - 1; begin
@cs = 516
_goto_level = _again
next
nd
end
end
hen 212 then
line 1377 "lib/parser/lexer.rl"
begin
te = p+1
egin p = tm - 1; begin
@cs = 736
_goto_level = _again
next
nd
end
end
hen 30 then
line 1386 "lib/parser/lexer.rl"
begin
te = p+1
egin
p = @ts - 1
begin
@cs = 736
_goto_level = _again
next
nd
end
end
hen 198 then
line 1400 "lib/parser/lexer.rl"
begin
te = p+1
egin p = p - 1; begin
@cs = 516
_goto_level = _again
next
nd
end
end
hen 199 then
line 478 "lib/parser/lexer.rl"
begin
te = p+1
egin
# Sit at EOF indefinitely. #advance would return $eof each time.
# This allows to feed the lexer more data if needed; this is only used
# in tests.
#
# Note that this action is not embedded into e_eof like e_heredoc_nl and e_bs
# below. This is due to the fact that scanner state at EOF is observed
# by tests, and encapsulating it in a rule would break the introspection.
p = p - 1; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 211 then
line 1325 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin p = p - 1; begin
@cs = 516
_goto_level = _again
next
nd
end
end
hen 206 then
line 1348 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
message = Parser::ERRORS[:ambiguous_prefix] % { :prefix => tok(tm, @te) }
diagnostic :warning, message,
range(tm, @te)
p = tm - 1
begin
@cs = 516
_goto_level = _again
next
nd
end
end
hen 209 then
line 1365 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin p = p - 1; begin
@cs = 516
_goto_level = _again
next
nd
end
end
hen 208 then
line 1386 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
p = @ts - 1
begin
@cs = 736
_goto_level = _again
next
nd
end
end
hen 202 then
line 1391 "lib/parser/lexer.rl"
begin
te = p
= p - 1; end
hen 220 then
line 1400 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin p = p - 1; begin
@cs = 516
_goto_level = _again
next
nd
end
end
hen 17 then
line 1391 "lib/parser/lexer.rl"
begin
egin p = (( @te))-1; end
end
hen 33 then
line 1400 "lib/parser/lexer.rl"
begin
egin p = (( @te))-1; end
egin p = p - 1; begin
@cs = 516
_goto_level = _again
next
nd
end
end
hen 15 then
line 1 "NONE"
begin
ase @act
hen 51 then
egin begin p = (( @te))-1; end
= p - 1; p = p - 1; begin
@cs = 516
_goto_level = _again
next
nd
nd
hen 52 then
egin begin p = (( @te))-1; end
diagnostic :warning, Parser::ERRORS[:ambiguous_literal],
range(@te - 1, @te)
p = p - 1; begin
@cs = 516
_goto_level = _again
next
nd
end
hen 53 then
egin begin p = (( @te))-1; end
message = Parser::ERRORS[:ambiguous_prefix] % { :prefix => tok(tm, @te) }
diagnostic :warning, message,
range(tm, @te)
p = tm - 1
begin
@cs = 516
_goto_level = _again
next
nd
end
hen 58 then
egin begin p = (( @te))-1; end
p = @ts - 1
begin
@cs = 736
_goto_level = _again
next
nd
end
lse
egin begin p = (( @te))-1; end
d
d
end
hen 35 then
line 1436 "lib/parser/lexer.rl"
begin
te = p+1
egin p = @ts - 1
begin
@cs = 448
_goto_level = _again
next
nd
end
end
hen 223 then
line 478 "lib/parser/lexer.rl"
begin
te = p+1
egin
# Sit at EOF indefinitely. #advance would return $eof each time.
# This allows to feed the lexer more data if needed; this is only used
# in tests.
#
# Note that this action is not embedded into e_eof like e_heredoc_nl and e_bs
# below. This is due to the fact that scanner state at EOF is observed
# by tests, and encapsulating it in a rule would break the introspection.
p = p - 1; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 224 then
line 1436 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin p = @ts - 1
begin
@cs = 448
_goto_level = _again
next
nd
end
end
hen 36 then
line 1436 "lib/parser/lexer.rl"
begin
egin p = (( @te))-1; end
egin p = @ts - 1
begin
@cs = 448
_goto_level = _again
next
nd
end
end
hen 34 then
line 1 "NONE"
begin
ase @act
hen 65 then
egin begin p = (( @te))-1; end
if @cond.active?
emit(:kDO_COND, 'do', @te - 2, @te)
else
emit(:kDO, 'do', @te - 2, @te)
end
@cs = 728; begin
p += 1
_goto_level = _out
next
nd
end
hen 66 then
egin begin p = (( @te))-1; end
= @ts - 1
begin
@cs = 448
_goto_level = _again
next
nd
nd
d
end
hen 234 then
line 1463 "lib/parser/lexer.rl"
begin
te = p+1
egin emit_do(true)
@cs = 728; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 227 then
line 1469 "lib/parser/lexer.rl"
begin
te = p+1
egin p = p - 1; begin
@cs = 736
_goto_level = _again
next
nd
end
end
hen 228 then
line 478 "lib/parser/lexer.rl"
begin
te = p+1
egin
# Sit at EOF indefinitely. #advance would return $eof each time.
# This allows to feed the lexer more data if needed; this is only used
# in tests.
#
# Note that this action is not embedded into e_eof like e_heredoc_nl and e_bs
# below. This is due to the fact that scanner state at EOF is observed
# by tests, and encapsulating it in a rule would break the introspection.
p = p - 1; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 229 then
line 1466 "lib/parser/lexer.rl"
begin
te = p
= p - 1; end
hen 232 then
line 1469 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin p = p - 1; begin
@cs = 736
_goto_level = _again
next
nd
end
end
hen 238 then
line 1493 "lib/parser/lexer.rl"
begin
te = p+1
egin p = p - 1; begin
@cs = 516
_goto_level = _again
next
nd
end
end
hen 237 then
line 478 "lib/parser/lexer.rl"
begin
te = p+1
egin
# Sit at EOF indefinitely. #advance would return $eof each time.
# This allows to feed the lexer more data if needed; this is only used
# in tests.
#
# Note that this action is not embedded into e_eof like e_heredoc_nl and e_bs
# below. This is due to the fact that scanner state at EOF is observed
# by tests, and encapsulating it in a rule would break the introspection.
p = p - 1; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 246 then
line 1485 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin p = @ts - 1; begin
@cs = 516
_goto_level = _again
next
nd
end
end
hen 240 then
line 1487 "lib/parser/lexer.rl"
begin
te = p
= p - 1; end
hen 244 then
line 1493 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin p = p - 1; begin
@cs = 516
_goto_level = _again
next
nd
end
end
hen 239 then
line 1 "NONE"
begin
ase @act
hen 73 then
egin begin p = (( @te))-1; end
mit_table(KEYWORDS)
@cs = 516; begin
p += 1
_goto_level = _out
next
nd
nd
hen 74 then
egin begin p = (( @te))-1; end
= @ts - 1; begin
@cs = 516
_goto_level = _again
next
nd
nd
d
end
hen 274 then
line 1510 "lib/parser/lexer.rl"
begin
te = p+1
egin
p = p - 1;
if tok.start_with? '-'
emit(:tUMINUS_NUM, '-', @ts, @ts + 1)
@cs = 736; begin
p += 1
_goto_level = _out
next
nd
end
end
end
hen 275 then
line 1530 "lib/parser/lexer.rl"
begin
te = p+1
egin
type = delimiter = tok[0].chr
p = p - 1; begin
@cs = (push_literal(type, delimiter, @ts))
_goto_level = _again
next
nd
end
end
hen 269 then
line 1537 "lib/parser/lexer.rl"
begin
te = p+1
egin
type, delimiter = tok[0].chr, tok[-1].chr
begin
@cs = (push_literal(type, delimiter, @ts))
_goto_level = _again
next
nd
end
end
hen 43 then
line 1544 "lib/parser/lexer.rl"
begin
te = p+1
egin
type, delimiter = tok[0..-2], tok[-1].chr
begin
@cs = (push_literal(type, delimiter, @ts))
_goto_level = _again
next
nd
end
end
hen 276 then
line 1585 "lib/parser/lexer.rl"
begin
te = p+1
egin
type, delimiter = tok, tok[-1].chr
begin
@cs = (push_literal(type, delimiter, @ts))
_goto_level = _again
next
nd
end
end
hen 46 then
line 1599 "lib/parser/lexer.rl"
begin
te = p+1
egin
emit(:tSYMBOL, tok(@ts + 1), @ts)
@cs = 736; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 289 then
line 1611 "lib/parser/lexer.rl"
begin
te = p+1
egin
# Show an error if memorized.
@escape.call if @escape.respond_to? :call
value = @escape || tok(@ts + 1)
if version?(18)
emit(:tINTEGER, value[0].ord)
else
emit(:tCHARACTER, value)
end
@cs = 736; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 291 then
line 1627 "lib/parser/lexer.rl"
begin
te = p+1
egin
escape = { " " => '\s', "\r" => '\r', "\n" => '\n', "\t" => '\t',
"\v" => '\v', "\f" => '\f' }[tok[1]]
message = Parser::ERRORS[:invalid_escape_use] % { :escape => escape }
diagnostic :warning, message, range
p = @ts - 1
begin
@cs = 736
_goto_level = _again
next
nd
end
end
hen 290 then
line 1638 "lib/parser/lexer.rl"
begin
te = p+1
egin
diagnostic :fatal, Parser::ERRORS[:incomplete_escape],
range(@ts, @ts + 1)
end
end
hen 277 then
line 1675 "lib/parser/lexer.rl"
begin
te = p+1
egin emit_table(PUNCTUATION_BEGIN)
begin
p += 1
_goto_level = _out
next
nd
end
end
hen 40 then
line 1695 "lib/parser/lexer.rl"
begin
te = p+1
egin
p = p - 1;
if version?(18)
ident = tok(@ts, @te - 2)
emit((tok[0] =~ /[A-Z]/) ? :tCONSTANT : :tIDENTIFIER,
ident, @ts, @te - 2)
p = p - 1; # continue as a symbol
if !@static_env.nil? && @static_env.declared?(ident)
@cs = 736;
else
@cs = (arg_or_cmdarg);
end
else
emit(:tLABEL, tok(@ts, @te - 2), @ts, @te - 1)
end
begin
p += 1
_goto_level = _out
next
nd
end
end
hen 263 then
line 1740 "lib/parser/lexer.rl"
begin
te = p+1
egin p = @ts - 1
begin
@cs = 152
_goto_level = _again
next
nd
end
end
hen 44 then
line 1753 "lib/parser/lexer.rl"
begin
te = p+1
egin p = @ts - 1; begin
@cs = 736
_goto_level = _again
next
nd
end
end
hen 249 then
line 478 "lib/parser/lexer.rl"
begin
te = p+1
egin
# Sit at EOF indefinitely. #advance would return $eof each time.
# This allows to feed the lexer more data if needed; this is only used
# in tests.
#
# Note that this action is not embedded into e_eof like e_heredoc_nl and e_bs
# below. This is due to the fact that scanner state at EOF is observed
# by tests, and encapsulating it in a rule would break the introspection.
p = p - 1; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 273 then
line 1520 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin emit(:tSTAR)
begin
p += 1
_goto_level = _out
next
nd
end
end
hen 270 then
line 1544 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
type, delimiter = tok[0..-2], tok[-1].chr
begin
@cs = (push_literal(type, delimiter, @ts))
_goto_level = _again
next
nd
end
end
hen 268 then
line 1550 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
diagnostic :fatal, Parser::ERRORS[:string_eof],
range(@ts, @ts + 1)
end
end
hen 278 then
line 1599 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
emit(:tSYMBOL, tok(@ts + 1), @ts)
@cs = 736; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 293 then
line 1611 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
# Show an error if memorized.
@escape.call if @escape.respond_to? :call
value = @escape || tok(@ts + 1)
if version?(18)
emit(:tINTEGER, value[0].ord)
else
emit(:tCHARACTER, value)
end
@cs = 736; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 288 then
line 1638 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
diagnostic :fatal, Parser::ERRORS[:incomplete_escape],
range(@ts, @ts + 1)
end
end
hen 294 then
line 1645 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
p = @ts - 1
begin
@cs = 736
_goto_level = _again
next
nd
end
end
hen 271 then
line 1675 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin emit_table(PUNCTUATION_BEGIN)
begin
p += 1
_goto_level = _out
next
nd
end
end
hen 316 then
line 1123 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
emit(:tIDENTIFIER)
if !@static_env.nil? && @static_env.declared?(tok)
@cs = 736; begin
p += 1
_goto_level = _out
next
nd
else
@cs = (arg_or_cmdarg); begin
p += 1
_goto_level = _out
next
nd
end
end
end
hen 260 then
line 1737 "lib/parser/lexer.rl"
begin
te = p
= p - 1; end
hen 262 then
line 1740 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin p = @ts - 1
begin
@cs = 152
_goto_level = _again
next
nd
end
end
hen 265 then
line 1753 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin p = @ts - 1; begin
@cs = 736
_goto_level = _again
next
nd
end
end
hen 42 then
line 1550 "lib/parser/lexer.rl"
begin
egin p = (( @te))-1; end
egin
diagnostic :fatal, Parser::ERRORS[:string_eof],
range(@ts, @ts + 1)
end
end
hen 51 then
line 1611 "lib/parser/lexer.rl"
begin
egin p = (( @te))-1; end
egin
# Show an error if memorized.
@escape.call if @escape.respond_to? :call
value = @escape || tok(@ts + 1)
if version?(18)
emit(:tINTEGER, value[0].ord)
else
emit(:tCHARACTER, value)
end
@cs = 736; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 49 then
line 1638 "lib/parser/lexer.rl"
begin
egin p = (( @te))-1; end
egin
diagnostic :fatal, Parser::ERRORS[:incomplete_escape],
range(@ts, @ts + 1)
end
end
hen 41 then
line 1737 "lib/parser/lexer.rl"
begin
egin p = (( @te))-1; end
end
hen 45 then
line 1753 "lib/parser/lexer.rl"
begin
egin p = (( @te))-1; end
egin p = @ts - 1; begin
@cs = 736
_goto_level = _again
next
nd
end
end
hen 39 then
line 1 "NONE"
begin
ase @act
hen 95 then
egin begin p = (( @te))-1; end
mit_table(PUNCTUATION_BEGIN)
begin
p += 1
_goto_level = _out
next
nd
nd
hen 96 then
egin begin p = (( @te))-1; end
mit_table(KEYWORDS_BEGIN, @ts, tm)
p = tm - 1
@cs = 492; begin
p += 1
_goto_level = _out
next
nd
nd
hen 97 then
egin begin p = (( @te))-1; end
mit_table(KEYWORDS_BEGIN)
@cs = 728; begin
p += 1
_goto_level = _out
next
nd
nd
hen 99 then
egin begin p = (( @te))-1; end
= @ts - 1
begin
@cs = 736
_goto_level = _again
next
nd
nd
hen 100 then
egin begin p = (( @te))-1; end
emit(:tIDENTIFIER)
if !@static_env.nil? && @static_env.declared?(tok)
@cs = 736; begin
p += 1
_goto_level = _out
next
nd
else
@cs = (arg_or_cmdarg); begin
p += 1
_goto_level = _out
next
nd
end
end
hen 103 then
egin begin p = (( @te))-1; end
= @ts - 1; begin
@cs = 736
_goto_level = _again
next
nd
nd
d
end
hen 54 then
line 1763 "lib/parser/lexer.rl"
begin
te = p+1
egin p = @ts - 1
begin
@cs = 736
_goto_level = _again
next
nd
end
end
hen 325 then
line 1772 "lib/parser/lexer.rl"
begin
te = p+1
egin p = p - 1; begin
@cs = 516
_goto_level = _again
next
nd
end
end
hen 324 then
line 478 "lib/parser/lexer.rl"
begin
te = p+1
egin
# Sit at EOF indefinitely. #advance would return $eof each time.
# This allows to feed the lexer more data if needed; this is only used
# in tests.
#
# Note that this action is not embedded into e_eof like e_heredoc_nl and e_bs
# below. This is due to the fact that scanner state at EOF is observed
# by tests, and encapsulating it in a rule would break the introspection.
p = p - 1; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 327 then
line 1766 "lib/parser/lexer.rl"
begin
te = p
= p - 1; end
hen 326 then
line 1772 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin p = p - 1; begin
@cs = 516
_goto_level = _again
next
nd
end
end
hen 53 then
line 1772 "lib/parser/lexer.rl"
begin
egin p = (( @te))-1; end
egin p = p - 1; begin
@cs = 516
_goto_level = _again
next
nd
end
end
hen 357 then
line 1783 "lib/parser/lexer.rl"
begin
te = p+1
egin
emit_table(PUNCTUATION, @ts, @ts + 2)
@lambda_stack.push @paren_nest
begin
p += 1
_goto_level = _out
next
nd
end
end
hen 68 then
line 1820 "lib/parser/lexer.rl"
begin
te = p+1
egin emit(:kCLASS, 'class', @ts, @ts + 5)
emit(:tLSHFT, '<<', @te - 2, @te)
@cs = 728; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 368 then
line 1888 "lib/parser/lexer.rl"
begin
te = p+1
egin
digits = tok(@num_digits_s)
if digits.end_with? '_'
diagnostic :error, Parser::ERRORS[:trailing_in_number] % { :character => '_' },
range(@te - 1, @te)
elsif digits.empty? && @num_base == 8 && version?(18)
# 1.8 did not raise an error on 0o.
digits = "0"
elsif digits.empty?
diagnostic :error, Parser::ERRORS[:empty_numeric]
elsif @num_base == 8 && (invalid_idx = digits.index(/[89]/))
invalid_s = @num_digits_s + invalid_idx
diagnostic :error, Parser::ERRORS[:invalid_octal],
range(invalid_s, invalid_s + 1)
end
emit(:tINTEGER, digits.to_i(@num_base))
begin
p += 1
_goto_level = _out
next
nd
end
end
hen 335 then
line 1935 "lib/parser/lexer.rl"
begin
te = p+1
egin
type, delimiter = tok, tok[-1].chr
begin
@cs = (push_literal(type, delimiter, @ts))
_goto_level = _again
next
nd
end
end
hen 56 then
line 1953 "lib/parser/lexer.rl"
begin
te = p+1
egin p = @ts - 1; begin
@stack[ @top] = @cs
@top+= 1
@cs = 302
_goto_level = _again
next
nd
end
end
hen 381 then
line 1960 "lib/parser/lexer.rl"
begin
te = p+1
egin emit_table(PUNCTUATION)
@cs = 426; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 349 then
line 1979 "lib/parser/lexer.rl"
begin
te = p+1
egin emit_table(PUNCTUATION)
@cs = 516; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 341 then
line 1983 "lib/parser/lexer.rl"
begin
te = p+1
egin
emit_table(PUNCTUATION)
@cond.lexpop; @cmdarg.lexpop
if %w"} ]".include?(tok)
@cs = 484;
else # )
# fnext expr_endfn; ?
end
begin
p += 1
_goto_level = _out
next
nd
end
end
hen 354 then
line 1997 "lib/parser/lexer.rl"
begin
te = p+1
egin emit(:tOP_ASGN, tok(@ts, @te - 1))
@cs = 516; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 339 then
line 2001 "lib/parser/lexer.rl"
begin
te = p+1
egin emit_table(PUNCTUATION)
@cs = 728; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 336 then
line 2009 "lib/parser/lexer.rl"
begin
te = p+1
egin emit_table(PUNCTUATION)
@cs = 516; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 338 then
line 2022 "lib/parser/lexer.rl"
begin
te = p+1
egin emit_table(PUNCTUATION)
@cs = 728; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 386 then
line 2025 "lib/parser/lexer.rl"
begin
te = p+1
egin
diagnostic :error, Parser::ERRORS[:bare_backslash],
range(@ts, @ts + 1)
p = p - 1;
end
end
hen 334 then
line 2032 "lib/parser/lexer.rl"
begin
te = p+1
egin
message = Parser::ERRORS[:unexpected] % { :character => tok.inspect[1..-2] }
diagnostic :fatal, message
end
end
hen 333 then
line 478 "lib/parser/lexer.rl"
begin
te = p+1
egin
# Sit at EOF indefinitely. #advance would return $eof each time.
# This allows to feed the lexer more data if needed; this is only used
# in tests.
#
# Note that this action is not embedded into e_eof like e_heredoc_nl and e_bs
# below. This is due to the fact that scanner state at EOF is observed
# by tests, and encapsulating it in a rule would break the introspection.
p = p - 1; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 396 then
line 1816 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin emit_table(KEYWORDS)
@cs = 307; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 394 then
line 1820 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin emit(:kCLASS, 'class', @ts, @ts + 5)
emit(:tLSHFT, '<<', @te - 2, @te)
@cs = 728; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 393 then
line 1831 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin emit_table(KEYWORDS)
@cs = 728; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 364 then
line 1888 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
digits = tok(@num_digits_s)
if digits.end_with? '_'
diagnostic :error, Parser::ERRORS[:trailing_in_number] % { :character => '_' },
range(@te - 1, @te)
elsif digits.empty? && @num_base == 8 && version?(18)
# 1.8 did not raise an error on 0o.
digits = "0"
elsif digits.empty?
diagnostic :error, Parser::ERRORS[:empty_numeric]
elsif @num_base == 8 && (invalid_idx = digits.index(/[89]/))
invalid_s = @num_digits_s + invalid_idx
diagnostic :error, Parser::ERRORS[:invalid_octal],
range(invalid_s, invalid_s + 1)
end
emit(:tINTEGER, digits.to_i(@num_base))
begin
p += 1
_goto_level = _out
next
nd
end
end
hen 360 then
line 1910 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
diagnostic :error, Parser::ERRORS[:no_dot_digit_literal]
end
end
hen 363 then
line 1919 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
if tok.end_with? 'e'
diagnostic :error, Parser::ERRORS[:trailing_in_number] % { :character => 'e' },
range(@te - 1, @te)
end
emit(:tFLOAT, tok.to_f)
begin
p += 1
_goto_level = _out
next
nd
end
end
hen 383 then
line 1945 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin emit(:tCONSTANT)
@cs = (arg_or_cmdarg); begin
p += 1
_goto_level = _out
next
nd
end
end
hen 353 then
line 1953 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin p = @ts - 1; begin
@stack[ @top] = @cs
@top+= 1
@cs = 302
_goto_level = _again
next
nd
end
end
hen 358 then
line 1960 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin emit_table(PUNCTUATION)
@cs = 426; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 388 then
line 1123 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
emit(:tIDENTIFIER)
if !@static_env.nil? && @static_env.declared?(tok)
@cs = 736; begin
p += 1
_goto_level = _out
next
nd
else
@cs = (arg_or_cmdarg); begin
p += 1
_goto_level = _out
next
nd
end
end
end
hen 348 then
line 1979 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin emit_table(PUNCTUATION)
@cs = 516; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 359 then
line 2009 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin emit_table(PUNCTUATION)
@cs = 516; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 346 then
line 2016 "lib/parser/lexer.rl"
begin
te = p
= p - 1; end
hen 352 then
line 2032 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
message = Parser::ERRORS[:unexpected] % { :character => tok.inspect[1..-2] }
diagnostic :fatal, message
end
end
hen 57 then
line 1910 "lib/parser/lexer.rl"
begin
egin p = (( @te))-1; end
egin
diagnostic :error, Parser::ERRORS[:no_dot_digit_literal]
end
end
hen 55 then
line 2032 "lib/parser/lexer.rl"
begin
egin p = (( @te))-1; end
egin
message = Parser::ERRORS[:unexpected] % { :character => tok.inspect[1..-2] }
diagnostic :fatal, message
end
end
hen 58 then
line 1 "NONE"
begin
ase @act
hen 111 then
egin begin p = (( @te))-1; end
if @lambda_stack.last == @paren_nest
@lambda_stack.pop
if tok == '{'
emit(:tLAMBEG)
else # 'do'
emit(:kDO_LAMBDA)
end
else
if tok == '{'
emit_table(PUNCTUATION)
else # 'do'
emit_do
end
end
@cs = 728; begin
p += 1
_goto_level = _out
next
nd
end
hen 112 then
egin begin p = (( @te))-1; end
mit_table(KEYWORDS)
@cs = 307; begin
p += 1
_goto_level = _out
next
nd
nd
hen 113 then
egin begin p = (( @te))-1; end
mit(:kCLASS, 'class', @ts, @ts + 5)
emit(:tLSHFT, '<<', @te - 2, @te)
@cs = 728; begin
p += 1
_goto_level = _out
next
nd
nd
hen 114 then
egin begin p = (( @te))-1; end
mit_table(KEYWORDS)
@cs = 516; begin
p += 1
_goto_level = _out
next
nd
nd
hen 115 then
egin begin p = (( @te))-1; end
mit_table(KEYWORDS)
@cs = 728; begin
p += 1
_goto_level = _out
next
nd
nd
hen 116 then
egin begin p = (( @te))-1; end
mit_table(KEYWORDS)
@cs = 492; begin
p += 1
_goto_level = _out
next
nd
nd
hen 117 then
egin begin p = (( @te))-1; end
emit_table(KEYWORDS)
if version?(18) && tok == 'not'
@cs = 516; begin
p += 1
_goto_level = _out
next
nd
else
@cs = 448; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 118 then
egin begin p = (( @te))-1; end
if version?(18)
emit(:tIDENTIFIER)
if !@static_env.nil? && @static_env.declared?(tok)
@cs = 736;
else
@cs = (arg_or_cmdarg);
end
else
emit_table(KEYWORDS)
end
begin
p += 1
_goto_level = _out
next
nd
end
hen 119 then
egin begin p = (( @te))-1; end
mit_table(KEYWORDS)
begin
p += 1
_goto_level = _out
next
nd
nd
hen 120 then
egin begin p = (( @te))-1; end
digits = tok(@num_digits_s)
if digits.end_with? '_'
diagnostic :error, Parser::ERRORS[:trailing_in_number] % { :character => '_' },
range(@te - 1, @te)
elsif digits.empty? && @num_base == 8 && version?(18)
# 1.8 did not raise an error on 0o.
digits = "0"
elsif digits.empty?
diagnostic :error, Parser::ERRORS[:empty_numeric]
elsif @num_base == 8 && (invalid_idx = digits.index(/[89]/))
invalid_s = @num_digits_s + invalid_idx
diagnostic :error, Parser::ERRORS[:invalid_octal],
range(invalid_s, invalid_s + 1)
end
emit(:tINTEGER, digits.to_i(@num_base))
begin
p += 1
_goto_level = _out
next
nd
end
hen 122 then
egin begin p = (( @te))-1; end
if tok.end_with? 'e'
diagnostic :error, Parser::ERRORS[:trailing_in_number] % { :character => 'e' },
range(@te - 1, @te)
end
emit(:tFLOAT, tok.to_f)
begin
p += 1
_goto_level = _out
next
nd
end
hen 124 then
egin begin p = (( @te))-1; end
mit(:tCONSTANT)
@cs = (arg_or_cmdarg); begin
p += 1
_goto_level = _out
next
nd
nd
hen 128 then
egin begin p = (( @te))-1; end
emit(:tIDENTIFIER)
if !@static_env.nil? && @static_env.declared?(tok)
@cs = 736; begin
p += 1
_goto_level = _out
next
nd
else
@cs = (arg_or_cmdarg); begin
p += 1
_goto_level = _out
next
nd
end
end
hen 129 then
egin begin p = (( @te))-1; end
mit(:tFID, tok(@ts, tm), @ts, tm)
p = tm - 1
@cs = 448; begin
p += 1
_goto_level = _out
next
nd
nd
d
end
hen 70 then
line 2045 "lib/parser/lexer.rl"
begin
te = p+1
egin p = p - 1; p = p - 1;
begin
@cs = 736
_goto_level = _again
next
nd
end
end
hen 401 then
line 2049 "lib/parser/lexer.rl"
begin
te = p+1
egin emit(:tNL, nil, @newline_s, @newline_s + 1)
p = p - 1; @cs = 152; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 402 then
line 2049 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin emit(:tNL, nil, @newline_s, @newline_s + 1)
p = p - 1; @cs = 152; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 69 then
line 2049 "lib/parser/lexer.rl"
begin
egin p = (( @te))-1; end
egin emit(:tNL, nil, @newline_s, @newline_s + 1)
p = p - 1; @cs = 152; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 405 then
line 2059 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
emit_comment(@eq_begin_s, @te)
begin
@cs = 152
_goto_level = _again
next
nd
end
end
hen 404 then
line 2067 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
diagnostic :fatal, Parser::ERRORS[:embedded_document],
range(@eq_begin_s, @eq_begin_s + '=begin'.length)
end
end
hen 81 then
line 2077 "lib/parser/lexer.rl"
begin
te = p+1
egin @eq_begin_s = @ts
begin
@cs = 906
_goto_level = _again
next
nd
end
end
hen 73 then
line 2084 "lib/parser/lexer.rl"
begin
te = p+1
egin p = p - 1; begin
@cs = 728
_goto_level = _again
next
nd
end
end
hen 74 then
line 478 "lib/parser/lexer.rl"
begin
te = p+1
egin
# Sit at EOF indefinitely. #advance would return $eof each time.
# This allows to feed the lexer more data if needed; this is only used
# in tests.
#
# Note that this action is not embedded into e_eof like e_heredoc_nl and e_bs
# below. This is due to the fact that scanner state at EOF is observed
# by tests, and encapsulating it in a rule would break the introspection.
p = p - 1; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 75 then
line 2074 "lib/parser/lexer.rl"
begin
te = p
= p - 1; end
hen 80 then
line 2077 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin @eq_begin_s = @ts
begin
@cs = 906
_goto_level = _again
next
nd
end
end
hen 83 then
line 2081 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin p = pe - 1 end
end
hen 79 then
line 2084 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin p = p - 1; begin
@cs = 728
_goto_level = _again
next
nd
end
end
hen 1 then
line 2084 "lib/parser/lexer.rl"
begin
egin p = (( @te))-1; end
egin p = p - 1; begin
@cs = 728
_goto_level = _again
next
nd
end
end
hen 67 then
line 452 "lib/parser/lexer.rl"
begin
# Record position of a newline for precise location reporting on tNL
# tokens.
#
# This action is embedded directly into c_nl, as it is idempotent and
# there are no cases when we need to skip it.
@newline_s = p
end
line 1038 "lib/parser/lexer.rl"
begin
mit_comment(@sharp_s, p == pe ? p - 2 : p) end
hen 87 then
line 452 "lib/parser/lexer.rl"
begin
# Record position of a newline for precise location reporting on tNL
# tokens.
#
# This action is embedded directly into c_nl, as it is idempotent and
# there are no cases when we need to skip it.
@newline_s = p
end
line 829 "lib/parser/lexer.rl"
begin
te = p+1
egin
if @te == pe
diagnostic :fatal, Parser::ERRORS[:string_eof],
range(literal.str_s, literal.str_s + 1)
end
if literal.heredoc?
line = tok(@herebody_s, @ts).gsub(/\r+$/, '')
# Try ending the heredoc with the complete most recently
# scanned line. @herebody_s always refers to the start of such line.
if literal.nest_and_try_closing(line, @herebody_s, @ts)
# Adjust @herebody_s to point to the next line.
@herebody_s = @te
# Continue regular lexing after the heredoc reference (<<END).
p = literal.heredoc_e - 1
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
else
# Ditto.
@herebody_s = @te
end
else
# Try ending the literal with a newline.
if literal.nest_and_try_closing(tok, @ts, @te)
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
end
if @herebody_s
# This is a regular literal intertwined with a heredoc. Like:
#
# p <<-foo+"1
# bar
# foo
# 2"
#
# which, incidentally, evaluates to "bar\n12".
p = @herebody_s - 1
@herebody_s = nil
end
end
if literal.words? && !eof_codepoint?(@source_pts[p])
literal.extend_space @ts, @te
else
# A literal newline is appended if the heredoc was _not_ closed
# this time (see fbreak above). See also Literal#nest_and_try_closing
# for rationale of calling #flush_string here.
literal.extend_string tok, @ts, @te
literal.flush_string
end
end
end
hen 115 then
line 452 "lib/parser/lexer.rl"
begin
# Record position of a newline for precise location reporting on tNL
# tokens.
#
# This action is embedded directly into c_nl, as it is idempotent and
# there are no cases when we need to skip it.
@newline_s = p
end
line 829 "lib/parser/lexer.rl"
begin
te = p+1
egin
if @te == pe
diagnostic :fatal, Parser::ERRORS[:string_eof],
range(literal.str_s, literal.str_s + 1)
end
if literal.heredoc?
line = tok(@herebody_s, @ts).gsub(/\r+$/, '')
# Try ending the heredoc with the complete most recently
# scanned line. @herebody_s always refers to the start of such line.
if literal.nest_and_try_closing(line, @herebody_s, @ts)
# Adjust @herebody_s to point to the next line.
@herebody_s = @te
# Continue regular lexing after the heredoc reference (<<END).
p = literal.heredoc_e - 1
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
else
# Ditto.
@herebody_s = @te
end
else
# Try ending the literal with a newline.
if literal.nest_and_try_closing(tok, @ts, @te)
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
end
if @herebody_s
# This is a regular literal intertwined with a heredoc. Like:
#
# p <<-foo+"1
# bar
# foo
# 2"
#
# which, incidentally, evaluates to "bar\n12".
p = @herebody_s - 1
@herebody_s = nil
end
end
if literal.words? && !eof_codepoint?(@source_pts[p])
literal.extend_space @ts, @te
else
# A literal newline is appended if the heredoc was _not_ closed
# this time (see fbreak above). See also Literal#nest_and_try_closing
# for rationale of calling #flush_string here.
literal.extend_string tok, @ts, @te
literal.flush_string
end
end
end
hen 142 then
line 452 "lib/parser/lexer.rl"
begin
# Record position of a newline for precise location reporting on tNL
# tokens.
#
# This action is embedded directly into c_nl, as it is idempotent and
# there are no cases when we need to skip it.
@newline_s = p
end
line 829 "lib/parser/lexer.rl"
begin
te = p+1
egin
if @te == pe
diagnostic :fatal, Parser::ERRORS[:string_eof],
range(literal.str_s, literal.str_s + 1)
end
if literal.heredoc?
line = tok(@herebody_s, @ts).gsub(/\r+$/, '')
# Try ending the heredoc with the complete most recently
# scanned line. @herebody_s always refers to the start of such line.
if literal.nest_and_try_closing(line, @herebody_s, @ts)
# Adjust @herebody_s to point to the next line.
@herebody_s = @te
# Continue regular lexing after the heredoc reference (<<END).
p = literal.heredoc_e - 1
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
else
# Ditto.
@herebody_s = @te
end
else
# Try ending the literal with a newline.
if literal.nest_and_try_closing(tok, @ts, @te)
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
end
if @herebody_s
# This is a regular literal intertwined with a heredoc. Like:
#
# p <<-foo+"1
# bar
# foo
# 2"
#
# which, incidentally, evaluates to "bar\n12".
p = @herebody_s - 1
@herebody_s = nil
end
end
if literal.words? && !eof_codepoint?(@source_pts[p])
literal.extend_space @ts, @te
else
# A literal newline is appended if the heredoc was _not_ closed
# this time (see fbreak above). See also Literal#nest_and_try_closing
# for rationale of calling #flush_string here.
literal.extend_string tok, @ts, @te
literal.flush_string
end
end
end
hen 148 then
line 452 "lib/parser/lexer.rl"
begin
# Record position of a newline for precise location reporting on tNL
# tokens.
#
# This action is embedded directly into c_nl, as it is idempotent and
# there are no cases when we need to skip it.
@newline_s = p
end
line 829 "lib/parser/lexer.rl"
begin
te = p+1
egin
if @te == pe
diagnostic :fatal, Parser::ERRORS[:string_eof],
range(literal.str_s, literal.str_s + 1)
end
if literal.heredoc?
line = tok(@herebody_s, @ts).gsub(/\r+$/, '')
# Try ending the heredoc with the complete most recently
# scanned line. @herebody_s always refers to the start of such line.
if literal.nest_and_try_closing(line, @herebody_s, @ts)
# Adjust @herebody_s to point to the next line.
@herebody_s = @te
# Continue regular lexing after the heredoc reference (<<END).
p = literal.heredoc_e - 1
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
else
# Ditto.
@herebody_s = @te
end
else
# Try ending the literal with a newline.
if literal.nest_and_try_closing(tok, @ts, @te)
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
end
if @herebody_s
# This is a regular literal intertwined with a heredoc. Like:
#
# p <<-foo+"1
# bar
# foo
# 2"
#
# which, incidentally, evaluates to "bar\n12".
p = @herebody_s - 1
@herebody_s = nil
end
end
if literal.words? && !eof_codepoint?(@source_pts[p])
literal.extend_space @ts, @te
else
# A literal newline is appended if the heredoc was _not_ closed
# this time (see fbreak above). See also Literal#nest_and_try_closing
# for rationale of calling #flush_string here.
literal.extend_string tok, @ts, @te
literal.flush_string
end
end
end
hen 213 then
line 452 "lib/parser/lexer.rl"
begin
# Record position of a newline for precise location reporting on tNL
# tokens.
#
# This action is embedded directly into c_nl, as it is idempotent and
# there are no cases when we need to skip it.
@newline_s = p
end
line 1377 "lib/parser/lexer.rl"
begin
te = p+1
egin p = tm - 1; begin
@cs = 736
_goto_level = _again
next
nd
end
end
hen 204 then
line 452 "lib/parser/lexer.rl"
begin
# Record position of a newline for precise location reporting on tNL
# tokens.
#
# This action is embedded directly into c_nl, as it is idempotent and
# there are no cases when we need to skip it.
@newline_s = p
end
line 1386 "lib/parser/lexer.rl"
begin
te = p+1
egin
p = @ts - 1
begin
@cs = 736
_goto_level = _again
next
nd
end
end
hen 292 then
line 452 "lib/parser/lexer.rl"
begin
# Record position of a newline for precise location reporting on tNL
# tokens.
#
# This action is embedded directly into c_nl, as it is idempotent and
# there are no cases when we need to skip it.
@newline_s = p
end
line 1627 "lib/parser/lexer.rl"
begin
te = p+1
egin
escape = { " " => '\s', "\r" => '\r', "\n" => '\n', "\t" => '\t',
"\v" => '\v', "\f" => '\f' }[tok[1]]
message = Parser::ERRORS[:invalid_escape_use] % { :escape => escape }
diagnostic :warning, message, range
p = @ts - 1
begin
@cs = 736
_goto_level = _again
next
nd
end
end
hen 264 then
line 452 "lib/parser/lexer.rl"
begin
# Record position of a newline for precise location reporting on tNL
# tokens.
#
# This action is embedded directly into c_nl, as it is idempotent and
# there are no cases when we need to skip it.
@newline_s = p
end
line 1740 "lib/parser/lexer.rl"
begin
te = p+1
egin p = @ts - 1
begin
@cs = 152
_goto_level = _again
next
nd
end
end
hen 406 then
line 452 "lib/parser/lexer.rl"
begin
# Record position of a newline for precise location reporting on tNL
# tokens.
#
# This action is embedded directly into c_nl, as it is idempotent and
# there are no cases when we need to skip it.
@newline_s = p
end
line 2059 "lib/parser/lexer.rl"
begin
te = p+1
egin
emit_comment(@eq_begin_s, @te)
begin
@cs = 152
_goto_level = _again
next
nd
end
end
hen 403 then
line 452 "lib/parser/lexer.rl"
begin
# Record position of a newline for precise location reporting on tNL
# tokens.
#
# This action is embedded directly into c_nl, as it is idempotent and
# there are no cases when we need to skip it.
@newline_s = p
end
line 2064 "lib/parser/lexer.rl"
begin
te = p+1
end
hen 82 then
line 452 "lib/parser/lexer.rl"
begin
# Record position of a newline for precise location reporting on tNL
# tokens.
#
# This action is embedded directly into c_nl, as it is idempotent and
# there are no cases when we need to skip it.
@newline_s = p
end
line 2077 "lib/parser/lexer.rl"
begin
te = p+1
egin @eq_begin_s = @ts
begin
@cs = 906
_goto_level = _again
next
nd
end
end
hen 84 then
line 452 "lib/parser/lexer.rl"
begin
# Record position of a newline for precise location reporting on tNL
# tokens.
#
# This action is embedded directly into c_nl, as it is idempotent and
# there are no cases when we need to skip it.
@newline_s = p
end
line 2081 "lib/parser/lexer.rl"
begin
te = p+1
egin p = pe - 1 end
end
hen 109 then
line 586 "lib/parser/lexer.rl"
begin
@escape = ""
codepoints = tok(@escape_s + 2, p - 1)
codepoint_s = @escape_s + 2
codepoints.split(/[ \t]/).each do |codepoint_str|
codepoint = codepoint_str.to_i(16)
if codepoint >= 0x110000
@escape = lambda do
diagnostic :error, Parser::ERRORS[:unicode_point_too_large],
range(codepoint_s, codepoint_s + codepoint_str.length)
end
break
end
@escape += codepoint.chr(Encoding::UTF_8)
codepoint_s += codepoint_str.length + 1
end
end
line 781 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
if literal.nest_and_try_closing('\\', @ts, @ts + 1)
# If the literal is actually closed by the backslash,
# rewind the input prior to consuming the escape sequence.
p = @escape_s - 1
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
else
# Get the first character after the backslash.
escaped_char = @source[@escape_s].chr
if literal.munge_escape? escaped_char
# If this particular literal uses this character as an opening
# or closing delimiter, it is an escape sequence for that
# particular character. Write it without the backslash.
if literal.regexp?
# Regular expressions should have every escape sequence in its
# raw form.
literal.extend_string(tok, @ts, @te)
else
literal.extend_string(escaped_char, @ts, @te)
end
else
# It does not. So this is an actual escape sequence, yay!
# Two things to consider here.
#
# 1. The `escape' rule should be pure and so won't raise any
# errors by itself. Instead, it stores them in lambdas.
#
# 2. Non-interpolated literals do not go through the aforementioned
# rule. As \\ and \' (and variants) are munged, the full token
# should always be written for such literals.
@escape.call if @escape.respond_to? :call
if literal.regexp?
# Ditto. Also, expand escaped newlines.
literal.extend_string(tok.gsub("\\\n", ''), @ts, @te)
else
literal.extend_string(@escape || tok, @ts, @te)
end
end
end
end
end
hen 136 then
line 586 "lib/parser/lexer.rl"
begin
@escape = ""
codepoints = tok(@escape_s + 2, p - 1)
codepoint_s = @escape_s + 2
codepoints.split(/[ \t]/).each do |codepoint_str|
codepoint = codepoint_str.to_i(16)
if codepoint >= 0x110000
@escape = lambda do
diagnostic :error, Parser::ERRORS[:unicode_point_too_large],
range(codepoint_s, codepoint_s + codepoint_str.length)
end
break
end
@escape += codepoint.chr(Encoding::UTF_8)
codepoint_s += codepoint_str.length + 1
end
end
line 781 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
if literal.nest_and_try_closing('\\', @ts, @ts + 1)
# If the literal is actually closed by the backslash,
# rewind the input prior to consuming the escape sequence.
p = @escape_s - 1
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
else
# Get the first character after the backslash.
escaped_char = @source[@escape_s].chr
if literal.munge_escape? escaped_char
# If this particular literal uses this character as an opening
# or closing delimiter, it is an escape sequence for that
# particular character. Write it without the backslash.
if literal.regexp?
# Regular expressions should have every escape sequence in its
# raw form.
literal.extend_string(tok, @ts, @te)
else
literal.extend_string(escaped_char, @ts, @te)
end
else
# It does not. So this is an actual escape sequence, yay!
# Two things to consider here.
#
# 1. The `escape' rule should be pure and so won't raise any
# errors by itself. Instead, it stores them in lambdas.
#
# 2. Non-interpolated literals do not go through the aforementioned
# rule. As \\ and \' (and variants) are munged, the full token
# should always be written for such literals.
@escape.call if @escape.respond_to? :call
if literal.regexp?
# Ditto. Also, expand escaped newlines.
literal.extend_string(tok.gsub("\\\n", ''), @ts, @te)
else
literal.extend_string(@escape || tok, @ts, @te)
end
end
end
end
end
hen 311 then
line 586 "lib/parser/lexer.rl"
begin
@escape = ""
codepoints = tok(@escape_s + 2, p - 1)
codepoint_s = @escape_s + 2
codepoints.split(/[ \t]/).each do |codepoint_str|
codepoint = codepoint_str.to_i(16)
if codepoint >= 0x110000
@escape = lambda do
diagnostic :error, Parser::ERRORS[:unicode_point_too_large],
range(codepoint_s, codepoint_s + codepoint_str.length)
end
break
end
@escape += codepoint.chr(Encoding::UTF_8)
codepoint_s += codepoint_str.length + 1
end
end
line 1611 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
# Show an error if memorized.
@escape.call if @escape.respond_to? :call
value = @escape || tok(@ts + 1)
if version?(18)
emit(:tINTEGER, value[0].ord)
else
emit(:tCHARACTER, value)
end
@cs = 736; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 93 then
line 609 "lib/parser/lexer.rl"
begin
@escape = {
'a' => "\a", 'b' => "\b", 'e' => "\e", 'f' => "\f",
'n' => "\n", 'r' => "\r", 's' => "\s", 't' => "\t",
'v' => "\v", '\\' => "\\"
}.fetch(@source[p - 1].chr, @source[p - 1].chr)
end
line 781 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
if literal.nest_and_try_closing('\\', @ts, @ts + 1)
# If the literal is actually closed by the backslash,
# rewind the input prior to consuming the escape sequence.
p = @escape_s - 1
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
else
# Get the first character after the backslash.
escaped_char = @source[@escape_s].chr
if literal.munge_escape? escaped_char
# If this particular literal uses this character as an opening
# or closing delimiter, it is an escape sequence for that
# particular character. Write it without the backslash.
if literal.regexp?
# Regular expressions should have every escape sequence in its
# raw form.
literal.extend_string(tok, @ts, @te)
else
literal.extend_string(escaped_char, @ts, @te)
end
else
# It does not. So this is an actual escape sequence, yay!
# Two things to consider here.
#
# 1. The `escape' rule should be pure and so won't raise any
# errors by itself. Instead, it stores them in lambdas.
#
# 2. Non-interpolated literals do not go through the aforementioned
# rule. As \\ and \' (and variants) are munged, the full token
# should always be written for such literals.
@escape.call if @escape.respond_to? :call
if literal.regexp?
# Ditto. Also, expand escaped newlines.
literal.extend_string(tok.gsub("\\\n", ''), @ts, @te)
else
literal.extend_string(@escape || tok, @ts, @te)
end
end
end
end
end
hen 120 then
line 609 "lib/parser/lexer.rl"
begin
@escape = {
'a' => "\a", 'b' => "\b", 'e' => "\e", 'f' => "\f",
'n' => "\n", 'r' => "\r", 's' => "\s", 't' => "\t",
'v' => "\v", '\\' => "\\"
}.fetch(@source[p - 1].chr, @source[p - 1].chr)
end
line 781 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
if literal.nest_and_try_closing('\\', @ts, @ts + 1)
# If the literal is actually closed by the backslash,
# rewind the input prior to consuming the escape sequence.
p = @escape_s - 1
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
else
# Get the first character after the backslash.
escaped_char = @source[@escape_s].chr
if literal.munge_escape? escaped_char
# If this particular literal uses this character as an opening
# or closing delimiter, it is an escape sequence for that
# particular character. Write it without the backslash.
if literal.regexp?
# Regular expressions should have every escape sequence in its
# raw form.
literal.extend_string(tok, @ts, @te)
else
literal.extend_string(escaped_char, @ts, @te)
end
else
# It does not. So this is an actual escape sequence, yay!
# Two things to consider here.
#
# 1. The `escape' rule should be pure and so won't raise any
# errors by itself. Instead, it stores them in lambdas.
#
# 2. Non-interpolated literals do not go through the aforementioned
# rule. As \\ and \' (and variants) are munged, the full token
# should always be written for such literals.
@escape.call if @escape.respond_to? :call
if literal.regexp?
# Ditto. Also, expand escaped newlines.
literal.extend_string(tok.gsub("\\\n", ''), @ts, @te)
else
literal.extend_string(@escape || tok, @ts, @te)
end
end
end
end
end
hen 295 then
line 609 "lib/parser/lexer.rl"
begin
@escape = {
'a' => "\a", 'b' => "\b", 'e' => "\e", 'f' => "\f",
'n' => "\n", 'r' => "\r", 's' => "\s", 't' => "\t",
'v' => "\v", '\\' => "\\"
}.fetch(@source[p - 1].chr, @source[p - 1].chr)
end
line 1611 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
# Show an error if memorized.
@escape.call if @escape.respond_to? :call
value = @escape || tok(@ts + 1)
if version?(18)
emit(:tINTEGER, value[0].ord)
else
emit(:tCHARACTER, value)
end
@cs = 736; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 96 then
line 617 "lib/parser/lexer.rl"
begin
@escape = lambda do
diagnostic :error, Parser::ERRORS[:invalid_escape]
end
end
line 781 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
if literal.nest_and_try_closing('\\', @ts, @ts + 1)
# If the literal is actually closed by the backslash,
# rewind the input prior to consuming the escape sequence.
p = @escape_s - 1
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
else
# Get the first character after the backslash.
escaped_char = @source[@escape_s].chr
if literal.munge_escape? escaped_char
# If this particular literal uses this character as an opening
# or closing delimiter, it is an escape sequence for that
# particular character. Write it without the backslash.
if literal.regexp?
# Regular expressions should have every escape sequence in its
# raw form.
literal.extend_string(tok, @ts, @te)
else
literal.extend_string(escaped_char, @ts, @te)
end
else
# It does not. So this is an actual escape sequence, yay!
# Two things to consider here.
#
# 1. The `escape' rule should be pure and so won't raise any
# errors by itself. Instead, it stores them in lambdas.
#
# 2. Non-interpolated literals do not go through the aforementioned
# rule. As \\ and \' (and variants) are munged, the full token
# should always be written for such literals.
@escape.call if @escape.respond_to? :call
if literal.regexp?
# Ditto. Also, expand escaped newlines.
literal.extend_string(tok.gsub("\\\n", ''), @ts, @te)
else
literal.extend_string(@escape || tok, @ts, @te)
end
end
end
end
end
hen 123 then
line 617 "lib/parser/lexer.rl"
begin
@escape = lambda do
diagnostic :error, Parser::ERRORS[:invalid_escape]
end
end
line 781 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
if literal.nest_and_try_closing('\\', @ts, @ts + 1)
# If the literal is actually closed by the backslash,
# rewind the input prior to consuming the escape sequence.
p = @escape_s - 1
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
else
# Get the first character after the backslash.
escaped_char = @source[@escape_s].chr
if literal.munge_escape? escaped_char
# If this particular literal uses this character as an opening
# or closing delimiter, it is an escape sequence for that
# particular character. Write it without the backslash.
if literal.regexp?
# Regular expressions should have every escape sequence in its
# raw form.
literal.extend_string(tok, @ts, @te)
else
literal.extend_string(escaped_char, @ts, @te)
end
else
# It does not. So this is an actual escape sequence, yay!
# Two things to consider here.
#
# 1. The `escape' rule should be pure and so won't raise any
# errors by itself. Instead, it stores them in lambdas.
#
# 2. Non-interpolated literals do not go through the aforementioned
# rule. As \\ and \' (and variants) are munged, the full token
# should always be written for such literals.
@escape.call if @escape.respond_to? :call
if literal.regexp?
# Ditto. Also, expand escaped newlines.
literal.extend_string(tok.gsub("\\\n", ''), @ts, @te)
else
literal.extend_string(@escape || tok, @ts, @te)
end
end
end
end
end
hen 298 then
line 617 "lib/parser/lexer.rl"
begin
@escape = lambda do
diagnostic :error, Parser::ERRORS[:invalid_escape]
end
end
line 1611 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
# Show an error if memorized.
@escape.call if @escape.respond_to? :call
value = @escape || tok(@ts + 1)
if version?(18)
emit(:tINTEGER, value[0].ord)
else
emit(:tCHARACTER, value)
end
@cs = 736; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 98 then
line 638 "lib/parser/lexer.rl"
begin
escape = "\x7f" end
line 781 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
if literal.nest_and_try_closing('\\', @ts, @ts + 1)
# If the literal is actually closed by the backslash,
# rewind the input prior to consuming the escape sequence.
p = @escape_s - 1
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
else
# Get the first character after the backslash.
escaped_char = @source[@escape_s].chr
if literal.munge_escape? escaped_char
# If this particular literal uses this character as an opening
# or closing delimiter, it is an escape sequence for that
# particular character. Write it without the backslash.
if literal.regexp?
# Regular expressions should have every escape sequence in its
# raw form.
literal.extend_string(tok, @ts, @te)
else
literal.extend_string(escaped_char, @ts, @te)
end
else
# It does not. So this is an actual escape sequence, yay!
# Two things to consider here.
#
# 1. The `escape' rule should be pure and so won't raise any
# errors by itself. Instead, it stores them in lambdas.
#
# 2. Non-interpolated literals do not go through the aforementioned
# rule. As \\ and \' (and variants) are munged, the full token
# should always be written for such literals.
@escape.call if @escape.respond_to? :call
if literal.regexp?
# Ditto. Also, expand escaped newlines.
literal.extend_string(tok.gsub("\\\n", ''), @ts, @te)
else
literal.extend_string(@escape || tok, @ts, @te)
end
end
end
end
end
hen 125 then
line 638 "lib/parser/lexer.rl"
begin
escape = "\x7f" end
line 781 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
if literal.nest_and_try_closing('\\', @ts, @ts + 1)
# If the literal is actually closed by the backslash,
# rewind the input prior to consuming the escape sequence.
p = @escape_s - 1
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
else
# Get the first character after the backslash.
escaped_char = @source[@escape_s].chr
if literal.munge_escape? escaped_char
# If this particular literal uses this character as an opening
# or closing delimiter, it is an escape sequence for that
# particular character. Write it without the backslash.
if literal.regexp?
# Regular expressions should have every escape sequence in its
# raw form.
literal.extend_string(tok, @ts, @te)
else
literal.extend_string(escaped_char, @ts, @te)
end
else
# It does not. So this is an actual escape sequence, yay!
# Two things to consider here.
#
# 1. The `escape' rule should be pure and so won't raise any
# errors by itself. Instead, it stores them in lambdas.
#
# 2. Non-interpolated literals do not go through the aforementioned
# rule. As \\ and \' (and variants) are munged, the full token
# should always be written for such literals.
@escape.call if @escape.respond_to? :call
if literal.regexp?
# Ditto. Also, expand escaped newlines.
literal.extend_string(tok.gsub("\\\n", ''), @ts, @te)
else
literal.extend_string(@escape || tok, @ts, @te)
end
end
end
end
end
hen 300 then
line 638 "lib/parser/lexer.rl"
begin
escape = "\x7f" end
line 1611 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
# Show an error if memorized.
@escape.call if @escape.respond_to? :call
value = @escape || tok(@ts + 1)
if version?(18)
emit(:tINTEGER, value[0].ord)
else
emit(:tCHARACTER, value)
end
@cs = 736; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 95 then
line 645 "lib/parser/lexer.rl"
begin
escape = encode_escape(tok(@escape_s, p).to_i(8) % 0x100) end
line 781 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
if literal.nest_and_try_closing('\\', @ts, @ts + 1)
# If the literal is actually closed by the backslash,
# rewind the input prior to consuming the escape sequence.
p = @escape_s - 1
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
else
# Get the first character after the backslash.
escaped_char = @source[@escape_s].chr
if literal.munge_escape? escaped_char
# If this particular literal uses this character as an opening
# or closing delimiter, it is an escape sequence for that
# particular character. Write it without the backslash.
if literal.regexp?
# Regular expressions should have every escape sequence in its
# raw form.
literal.extend_string(tok, @ts, @te)
else
literal.extend_string(escaped_char, @ts, @te)
end
else
# It does not. So this is an actual escape sequence, yay!
# Two things to consider here.
#
# 1. The `escape' rule should be pure and so won't raise any
# errors by itself. Instead, it stores them in lambdas.
#
# 2. Non-interpolated literals do not go through the aforementioned
# rule. As \\ and \' (and variants) are munged, the full token
# should always be written for such literals.
@escape.call if @escape.respond_to? :call
if literal.regexp?
# Ditto. Also, expand escaped newlines.
literal.extend_string(tok.gsub("\\\n", ''), @ts, @te)
else
literal.extend_string(@escape || tok, @ts, @te)
end
end
end
end
end
hen 122 then
line 645 "lib/parser/lexer.rl"
begin
escape = encode_escape(tok(@escape_s, p).to_i(8) % 0x100) end
line 781 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
if literal.nest_and_try_closing('\\', @ts, @ts + 1)
# If the literal is actually closed by the backslash,
# rewind the input prior to consuming the escape sequence.
p = @escape_s - 1
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
else
# Get the first character after the backslash.
escaped_char = @source[@escape_s].chr
if literal.munge_escape? escaped_char
# If this particular literal uses this character as an opening
# or closing delimiter, it is an escape sequence for that
# particular character. Write it without the backslash.
if literal.regexp?
# Regular expressions should have every escape sequence in its
# raw form.
literal.extend_string(tok, @ts, @te)
else
literal.extend_string(escaped_char, @ts, @te)
end
else
# It does not. So this is an actual escape sequence, yay!
# Two things to consider here.
#
# 1. The `escape' rule should be pure and so won't raise any
# errors by itself. Instead, it stores them in lambdas.
#
# 2. Non-interpolated literals do not go through the aforementioned
# rule. As \\ and \' (and variants) are munged, the full token
# should always be written for such literals.
@escape.call if @escape.respond_to? :call
if literal.regexp?
# Ditto. Also, expand escaped newlines.
literal.extend_string(tok.gsub("\\\n", ''), @ts, @te)
else
literal.extend_string(@escape || tok, @ts, @te)
end
end
end
end
end
hen 297 then
line 645 "lib/parser/lexer.rl"
begin
escape = encode_escape(tok(@escape_s, p).to_i(8) % 0x100) end
line 1611 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
# Show an error if memorized.
@escape.call if @escape.respond_to? :call
value = @escape || tok(@ts + 1)
if version?(18)
emit(:tINTEGER, value[0].ord)
else
emit(:tCHARACTER, value)
end
@cs = 736; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 112 then
line 649 "lib/parser/lexer.rl"
begin
escape = encode_escape(tok(@escape_s + 1, p).to_i(16)) end
line 781 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
if literal.nest_and_try_closing('\\', @ts, @ts + 1)
# If the literal is actually closed by the backslash,
# rewind the input prior to consuming the escape sequence.
p = @escape_s - 1
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
else
# Get the first character after the backslash.
escaped_char = @source[@escape_s].chr
if literal.munge_escape? escaped_char
# If this particular literal uses this character as an opening
# or closing delimiter, it is an escape sequence for that
# particular character. Write it without the backslash.
if literal.regexp?
# Regular expressions should have every escape sequence in its
# raw form.
literal.extend_string(tok, @ts, @te)
else
literal.extend_string(escaped_char, @ts, @te)
end
else
# It does not. So this is an actual escape sequence, yay!
# Two things to consider here.
#
# 1. The `escape' rule should be pure and so won't raise any
# errors by itself. Instead, it stores them in lambdas.
#
# 2. Non-interpolated literals do not go through the aforementioned
# rule. As \\ and \' (and variants) are munged, the full token
# should always be written for such literals.
@escape.call if @escape.respond_to? :call
if literal.regexp?
# Ditto. Also, expand escaped newlines.
literal.extend_string(tok.gsub("\\\n", ''), @ts, @te)
else
literal.extend_string(@escape || tok, @ts, @te)
end
end
end
end
end
hen 139 then
line 649 "lib/parser/lexer.rl"
begin
escape = encode_escape(tok(@escape_s + 1, p).to_i(16)) end
line 781 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
if literal.nest_and_try_closing('\\', @ts, @ts + 1)
# If the literal is actually closed by the backslash,
# rewind the input prior to consuming the escape sequence.
p = @escape_s - 1
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
else
# Get the first character after the backslash.
escaped_char = @source[@escape_s].chr
if literal.munge_escape? escaped_char
# If this particular literal uses this character as an opening
# or closing delimiter, it is an escape sequence for that
# particular character. Write it without the backslash.
if literal.regexp?
# Regular expressions should have every escape sequence in its
# raw form.
literal.extend_string(tok, @ts, @te)
else
literal.extend_string(escaped_char, @ts, @te)
end
else
# It does not. So this is an actual escape sequence, yay!
# Two things to consider here.
#
# 1. The `escape' rule should be pure and so won't raise any
# errors by itself. Instead, it stores them in lambdas.
#
# 2. Non-interpolated literals do not go through the aforementioned
# rule. As \\ and \' (and variants) are munged, the full token
# should always be written for such literals.
@escape.call if @escape.respond_to? :call
if literal.regexp?
# Ditto. Also, expand escaped newlines.
literal.extend_string(tok.gsub("\\\n", ''), @ts, @te)
else
literal.extend_string(@escape || tok, @ts, @te)
end
end
end
end
end
hen 314 then
line 649 "lib/parser/lexer.rl"
begin
escape = encode_escape(tok(@escape_s + 1, p).to_i(16)) end
line 1611 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
# Show an error if memorized.
@escape.call if @escape.respond_to? :call
value = @escape || tok(@ts + 1)
if version?(18)
emit(:tINTEGER, value[0].ord)
else
emit(:tCHARACTER, value)
end
@cs = 736; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 106 then
line 652 "lib/parser/lexer.rl"
begin
escape = tok(@escape_s + 1, p).to_i(16).chr(Encoding::UTF_8) end
line 781 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
if literal.nest_and_try_closing('\\', @ts, @ts + 1)
# If the literal is actually closed by the backslash,
# rewind the input prior to consuming the escape sequence.
p = @escape_s - 1
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
else
# Get the first character after the backslash.
escaped_char = @source[@escape_s].chr
if literal.munge_escape? escaped_char
# If this particular literal uses this character as an opening
# or closing delimiter, it is an escape sequence for that
# particular character. Write it without the backslash.
if literal.regexp?
# Regular expressions should have every escape sequence in its
# raw form.
literal.extend_string(tok, @ts, @te)
else
literal.extend_string(escaped_char, @ts, @te)
end
else
# It does not. So this is an actual escape sequence, yay!
# Two things to consider here.
#
# 1. The `escape' rule should be pure and so won't raise any
# errors by itself. Instead, it stores them in lambdas.
#
# 2. Non-interpolated literals do not go through the aforementioned
# rule. As \\ and \' (and variants) are munged, the full token
# should always be written for such literals.
@escape.call if @escape.respond_to? :call
if literal.regexp?
# Ditto. Also, expand escaped newlines.
literal.extend_string(tok.gsub("\\\n", ''), @ts, @te)
else
literal.extend_string(@escape || tok, @ts, @te)
end
end
end
end
end
hen 133 then
line 652 "lib/parser/lexer.rl"
begin
escape = tok(@escape_s + 1, p).to_i(16).chr(Encoding::UTF_8) end
line 781 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
if literal.nest_and_try_closing('\\', @ts, @ts + 1)
# If the literal is actually closed by the backslash,
# rewind the input prior to consuming the escape sequence.
p = @escape_s - 1
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
else
# Get the first character after the backslash.
escaped_char = @source[@escape_s].chr
if literal.munge_escape? escaped_char
# If this particular literal uses this character as an opening
# or closing delimiter, it is an escape sequence for that
# particular character. Write it without the backslash.
if literal.regexp?
# Regular expressions should have every escape sequence in its
# raw form.
literal.extend_string(tok, @ts, @te)
else
literal.extend_string(escaped_char, @ts, @te)
end
else
# It does not. So this is an actual escape sequence, yay!
# Two things to consider here.
#
# 1. The `escape' rule should be pure and so won't raise any
# errors by itself. Instead, it stores them in lambdas.
#
# 2. Non-interpolated literals do not go through the aforementioned
# rule. As \\ and \' (and variants) are munged, the full token
# should always be written for such literals.
@escape.call if @escape.respond_to? :call
if literal.regexp?
# Ditto. Also, expand escaped newlines.
literal.extend_string(tok.gsub("\\\n", ''), @ts, @te)
else
literal.extend_string(@escape || tok, @ts, @te)
end
end
end
end
end
hen 308 then
line 652 "lib/parser/lexer.rl"
begin
escape = tok(@escape_s + 1, p).to_i(16).chr(Encoding::UTF_8) end
line 1611 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
# Show an error if memorized.
@escape.call if @escape.respond_to? :call
value = @escape || tok(@ts + 1)
if version?(18)
emit(:tINTEGER, value[0].ord)
else
emit(:tCHARACTER, value)
end
@cs = 736; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 111 then
line 657 "lib/parser/lexer.rl"
begin
@escape = lambda do
diagnostic :error, Parser::ERRORS[:invalid_hex_escape],
range(@escape_s - 1, p + 2)
end
end
line 781 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
if literal.nest_and_try_closing('\\', @ts, @ts + 1)
# If the literal is actually closed by the backslash,
# rewind the input prior to consuming the escape sequence.
p = @escape_s - 1
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
else
# Get the first character after the backslash.
escaped_char = @source[@escape_s].chr
if literal.munge_escape? escaped_char
# If this particular literal uses this character as an opening
# or closing delimiter, it is an escape sequence for that
# particular character. Write it without the backslash.
if literal.regexp?
# Regular expressions should have every escape sequence in its
# raw form.
literal.extend_string(tok, @ts, @te)
else
literal.extend_string(escaped_char, @ts, @te)
end
else
# It does not. So this is an actual escape sequence, yay!
# Two things to consider here.
#
# 1. The `escape' rule should be pure and so won't raise any
# errors by itself. Instead, it stores them in lambdas.
#
# 2. Non-interpolated literals do not go through the aforementioned
# rule. As \\ and \' (and variants) are munged, the full token
# should always be written for such literals.
@escape.call if @escape.respond_to? :call
if literal.regexp?
# Ditto. Also, expand escaped newlines.
literal.extend_string(tok.gsub("\\\n", ''), @ts, @te)
else
literal.extend_string(@escape || tok, @ts, @te)
end
end
end
end
end
hen 138 then
line 657 "lib/parser/lexer.rl"
begin
@escape = lambda do
diagnostic :error, Parser::ERRORS[:invalid_hex_escape],
range(@escape_s - 1, p + 2)
end
end
line 781 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
if literal.nest_and_try_closing('\\', @ts, @ts + 1)
# If the literal is actually closed by the backslash,
# rewind the input prior to consuming the escape sequence.
p = @escape_s - 1
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
else
# Get the first character after the backslash.
escaped_char = @source[@escape_s].chr
if literal.munge_escape? escaped_char
# If this particular literal uses this character as an opening
# or closing delimiter, it is an escape sequence for that
# particular character. Write it without the backslash.
if literal.regexp?
# Regular expressions should have every escape sequence in its
# raw form.
literal.extend_string(tok, @ts, @te)
else
literal.extend_string(escaped_char, @ts, @te)
end
else
# It does not. So this is an actual escape sequence, yay!
# Two things to consider here.
#
# 1. The `escape' rule should be pure and so won't raise any
# errors by itself. Instead, it stores them in lambdas.
#
# 2. Non-interpolated literals do not go through the aforementioned
# rule. As \\ and \' (and variants) are munged, the full token
# should always be written for such literals.
@escape.call if @escape.respond_to? :call
if literal.regexp?
# Ditto. Also, expand escaped newlines.
literal.extend_string(tok.gsub("\\\n", ''), @ts, @te)
else
literal.extend_string(@escape || tok, @ts, @te)
end
end
end
end
end
hen 313 then
line 657 "lib/parser/lexer.rl"
begin
@escape = lambda do
diagnostic :error, Parser::ERRORS[:invalid_hex_escape],
range(@escape_s - 1, p + 2)
end
end
line 1611 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
# Show an error if memorized.
@escape.call if @escape.respond_to? :call
value = @escape || tok(@ts + 1)
if version?(18)
emit(:tINTEGER, value[0].ord)
else
emit(:tCHARACTER, value)
end
@cs = 736; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 105 then
line 672 "lib/parser/lexer.rl"
begin
@escape = lambda do
diagnostic :error, Parser::ERRORS[:invalid_unicode_escape],
range(@escape_s - 1, p)
end
end
line 781 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
if literal.nest_and_try_closing('\\', @ts, @ts + 1)
# If the literal is actually closed by the backslash,
# rewind the input prior to consuming the escape sequence.
p = @escape_s - 1
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
else
# Get the first character after the backslash.
escaped_char = @source[@escape_s].chr
if literal.munge_escape? escaped_char
# If this particular literal uses this character as an opening
# or closing delimiter, it is an escape sequence for that
# particular character. Write it without the backslash.
if literal.regexp?
# Regular expressions should have every escape sequence in its
# raw form.
literal.extend_string(tok, @ts, @te)
else
literal.extend_string(escaped_char, @ts, @te)
end
else
# It does not. So this is an actual escape sequence, yay!
# Two things to consider here.
#
# 1. The `escape' rule should be pure and so won't raise any
# errors by itself. Instead, it stores them in lambdas.
#
# 2. Non-interpolated literals do not go through the aforementioned
# rule. As \\ and \' (and variants) are munged, the full token
# should always be written for such literals.
@escape.call if @escape.respond_to? :call
if literal.regexp?
# Ditto. Also, expand escaped newlines.
literal.extend_string(tok.gsub("\\\n", ''), @ts, @te)
else
literal.extend_string(@escape || tok, @ts, @te)
end
end
end
end
end
hen 132 then
line 672 "lib/parser/lexer.rl"
begin
@escape = lambda do
diagnostic :error, Parser::ERRORS[:invalid_unicode_escape],
range(@escape_s - 1, p)
end
end
line 781 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
if literal.nest_and_try_closing('\\', @ts, @ts + 1)
# If the literal is actually closed by the backslash,
# rewind the input prior to consuming the escape sequence.
p = @escape_s - 1
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
else
# Get the first character after the backslash.
escaped_char = @source[@escape_s].chr
if literal.munge_escape? escaped_char
# If this particular literal uses this character as an opening
# or closing delimiter, it is an escape sequence for that
# particular character. Write it without the backslash.
if literal.regexp?
# Regular expressions should have every escape sequence in its
# raw form.
literal.extend_string(tok, @ts, @te)
else
literal.extend_string(escaped_char, @ts, @te)
end
else
# It does not. So this is an actual escape sequence, yay!
# Two things to consider here.
#
# 1. The `escape' rule should be pure and so won't raise any
# errors by itself. Instead, it stores them in lambdas.
#
# 2. Non-interpolated literals do not go through the aforementioned
# rule. As \\ and \' (and variants) are munged, the full token
# should always be written for such literals.
@escape.call if @escape.respond_to? :call
if literal.regexp?
# Ditto. Also, expand escaped newlines.
literal.extend_string(tok.gsub("\\\n", ''), @ts, @te)
else
literal.extend_string(@escape || tok, @ts, @te)
end
end
end
end
end
hen 307 then
line 672 "lib/parser/lexer.rl"
begin
@escape = lambda do
diagnostic :error, Parser::ERRORS[:invalid_unicode_escape],
range(@escape_s - 1, p)
end
end
line 1611 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
# Show an error if memorized.
@escape.call if @escape.respond_to? :call
value = @escape || tok(@ts + 1)
if version?(18)
emit(:tINTEGER, value[0].ord)
else
emit(:tCHARACTER, value)
end
@cs = 736; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 108 then
line 686 "lib/parser/lexer.rl"
begin
@escape = lambda do
diagnostic :fatal, Parser::ERRORS[:unterminated_unicode],
range(p - 1, p)
end
end
line 781 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
if literal.nest_and_try_closing('\\', @ts, @ts + 1)
# If the literal is actually closed by the backslash,
# rewind the input prior to consuming the escape sequence.
p = @escape_s - 1
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
else
# Get the first character after the backslash.
escaped_char = @source[@escape_s].chr
if literal.munge_escape? escaped_char
# If this particular literal uses this character as an opening
# or closing delimiter, it is an escape sequence for that
# particular character. Write it without the backslash.
if literal.regexp?
# Regular expressions should have every escape sequence in its
# raw form.
literal.extend_string(tok, @ts, @te)
else
literal.extend_string(escaped_char, @ts, @te)
end
else
# It does not. So this is an actual escape sequence, yay!
# Two things to consider here.
#
# 1. The `escape' rule should be pure and so won't raise any
# errors by itself. Instead, it stores them in lambdas.
#
# 2. Non-interpolated literals do not go through the aforementioned
# rule. As \\ and \' (and variants) are munged, the full token
# should always be written for such literals.
@escape.call if @escape.respond_to? :call
if literal.regexp?
# Ditto. Also, expand escaped newlines.
literal.extend_string(tok.gsub("\\\n", ''), @ts, @te)
else
literal.extend_string(@escape || tok, @ts, @te)
end
end
end
end
end
hen 135 then
line 686 "lib/parser/lexer.rl"
begin
@escape = lambda do
diagnostic :fatal, Parser::ERRORS[:unterminated_unicode],
range(p - 1, p)
end
end
line 781 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
if literal.nest_and_try_closing('\\', @ts, @ts + 1)
# If the literal is actually closed by the backslash,
# rewind the input prior to consuming the escape sequence.
p = @escape_s - 1
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
else
# Get the first character after the backslash.
escaped_char = @source[@escape_s].chr
if literal.munge_escape? escaped_char
# If this particular literal uses this character as an opening
# or closing delimiter, it is an escape sequence for that
# particular character. Write it without the backslash.
if literal.regexp?
# Regular expressions should have every escape sequence in its
# raw form.
literal.extend_string(tok, @ts, @te)
else
literal.extend_string(escaped_char, @ts, @te)
end
else
# It does not. So this is an actual escape sequence, yay!
# Two things to consider here.
#
# 1. The `escape' rule should be pure and so won't raise any
# errors by itself. Instead, it stores them in lambdas.
#
# 2. Non-interpolated literals do not go through the aforementioned
# rule. As \\ and \' (and variants) are munged, the full token
# should always be written for such literals.
@escape.call if @escape.respond_to? :call
if literal.regexp?
# Ditto. Also, expand escaped newlines.
literal.extend_string(tok.gsub("\\\n", ''), @ts, @te)
else
literal.extend_string(@escape || tok, @ts, @te)
end
end
end
end
end
hen 310 then
line 686 "lib/parser/lexer.rl"
begin
@escape = lambda do
diagnostic :fatal, Parser::ERRORS[:unterminated_unicode],
range(p - 1, p)
end
end
line 1611 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
# Show an error if memorized.
@escape.call if @escape.respond_to? :call
value = @escape || tok(@ts + 1)
if version?(18)
emit(:tINTEGER, value[0].ord)
else
emit(:tCHARACTER, value)
end
@cs = 736; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 94 then
line 715 "lib/parser/lexer.rl"
begin
diagnostic :fatal, Parser::ERRORS[:escape_eof],
range(p - 1, p)
end
line 781 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
if literal.nest_and_try_closing('\\', @ts, @ts + 1)
# If the literal is actually closed by the backslash,
# rewind the input prior to consuming the escape sequence.
p = @escape_s - 1
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
else
# Get the first character after the backslash.
escaped_char = @source[@escape_s].chr
if literal.munge_escape? escaped_char
# If this particular literal uses this character as an opening
# or closing delimiter, it is an escape sequence for that
# particular character. Write it without the backslash.
if literal.regexp?
# Regular expressions should have every escape sequence in its
# raw form.
literal.extend_string(tok, @ts, @te)
else
literal.extend_string(escaped_char, @ts, @te)
end
else
# It does not. So this is an actual escape sequence, yay!
# Two things to consider here.
#
# 1. The `escape' rule should be pure and so won't raise any
# errors by itself. Instead, it stores them in lambdas.
#
# 2. Non-interpolated literals do not go through the aforementioned
# rule. As \\ and \' (and variants) are munged, the full token
# should always be written for such literals.
@escape.call if @escape.respond_to? :call
if literal.regexp?
# Ditto. Also, expand escaped newlines.
literal.extend_string(tok.gsub("\\\n", ''), @ts, @te)
else
literal.extend_string(@escape || tok, @ts, @te)
end
end
end
end
end
hen 121 then
line 715 "lib/parser/lexer.rl"
begin
diagnostic :fatal, Parser::ERRORS[:escape_eof],
range(p - 1, p)
end
line 781 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
if literal.nest_and_try_closing('\\', @ts, @ts + 1)
# If the literal is actually closed by the backslash,
# rewind the input prior to consuming the escape sequence.
p = @escape_s - 1
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
else
# Get the first character after the backslash.
escaped_char = @source[@escape_s].chr
if literal.munge_escape? escaped_char
# If this particular literal uses this character as an opening
# or closing delimiter, it is an escape sequence for that
# particular character. Write it without the backslash.
if literal.regexp?
# Regular expressions should have every escape sequence in its
# raw form.
literal.extend_string(tok, @ts, @te)
else
literal.extend_string(escaped_char, @ts, @te)
end
else
# It does not. So this is an actual escape sequence, yay!
# Two things to consider here.
#
# 1. The `escape' rule should be pure and so won't raise any
# errors by itself. Instead, it stores them in lambdas.
#
# 2. Non-interpolated literals do not go through the aforementioned
# rule. As \\ and \' (and variants) are munged, the full token
# should always be written for such literals.
@escape.call if @escape.respond_to? :call
if literal.regexp?
# Ditto. Also, expand escaped newlines.
literal.extend_string(tok.gsub("\\\n", ''), @ts, @te)
else
literal.extend_string(@escape || tok, @ts, @te)
end
end
end
end
end
hen 296 then
line 715 "lib/parser/lexer.rl"
begin
diagnostic :fatal, Parser::ERRORS[:escape_eof],
range(p - 1, p)
end
line 1611 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
# Show an error if memorized.
@escape.call if @escape.respond_to? :call
value = @escape || tok(@ts + 1)
if version?(18)
emit(:tINTEGER, value[0].ord)
else
emit(:tCHARACTER, value)
end
@cs = 736; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 145 then
line 722 "lib/parser/lexer.rl"
begin
@escape_s = p
@escape = nil
end
line 781 "lib/parser/lexer.rl"
begin
te = p+1
egin
if literal.nest_and_try_closing('\\', @ts, @ts + 1)
# If the literal is actually closed by the backslash,
# rewind the input prior to consuming the escape sequence.
p = @escape_s - 1
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
else
# Get the first character after the backslash.
escaped_char = @source[@escape_s].chr
if literal.munge_escape? escaped_char
# If this particular literal uses this character as an opening
# or closing delimiter, it is an escape sequence for that
# particular character. Write it without the backslash.
if literal.regexp?
# Regular expressions should have every escape sequence in its
# raw form.
literal.extend_string(tok, @ts, @te)
else
literal.extend_string(escaped_char, @ts, @te)
end
else
# It does not. So this is an actual escape sequence, yay!
# Two things to consider here.
#
# 1. The `escape' rule should be pure and so won't raise any
# errors by itself. Instead, it stores them in lambdas.
#
# 2. Non-interpolated literals do not go through the aforementioned
# rule. As \\ and \' (and variants) are munged, the full token
# should always be written for such literals.
@escape.call if @escape.respond_to? :call
if literal.regexp?
# Ditto. Also, expand escaped newlines.
literal.extend_string(tok.gsub("\\\n", ''), @ts, @te)
else
literal.extend_string(@escape || tok, @ts, @te)
end
end
end
end
end
hen 150 then
line 722 "lib/parser/lexer.rl"
begin
@escape_s = p
@escape = nil
end
line 781 "lib/parser/lexer.rl"
begin
te = p+1
egin
if literal.nest_and_try_closing('\\', @ts, @ts + 1)
# If the literal is actually closed by the backslash,
# rewind the input prior to consuming the escape sequence.
p = @escape_s - 1
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
else
# Get the first character after the backslash.
escaped_char = @source[@escape_s].chr
if literal.munge_escape? escaped_char
# If this particular literal uses this character as an opening
# or closing delimiter, it is an escape sequence for that
# particular character. Write it without the backslash.
if literal.regexp?
# Regular expressions should have every escape sequence in its
# raw form.
literal.extend_string(tok, @ts, @te)
else
literal.extend_string(escaped_char, @ts, @te)
end
else
# It does not. So this is an actual escape sequence, yay!
# Two things to consider here.
#
# 1. The `escape' rule should be pure and so won't raise any
# errors by itself. Instead, it stores them in lambdas.
#
# 2. Non-interpolated literals do not go through the aforementioned
# rule. As \\ and \' (and variants) are munged, the full token
# should always be written for such literals.
@escape.call if @escape.respond_to? :call
if literal.regexp?
# Ditto. Also, expand escaped newlines.
literal.extend_string(tok.gsub("\\\n", ''), @ts, @te)
else
literal.extend_string(@escape || tok, @ts, @te)
end
end
end
end
end
hen 60 then
line 762 "lib/parser/lexer.rl"
begin
# After every heredoc was parsed, @herebody_s contains the
# position of next token after all heredocs.
if @herebody_s
p = @herebody_s
@herebody_s = nil
end
end
line 452 "lib/parser/lexer.rl"
begin
# Record position of a newline for precise location reporting on tNL
# tokens.
#
# This action is embedded directly into c_nl, as it is idempotent and
# there are no cases when we need to skip it.
@newline_s = p
end
hen 24 then
line 762 "lib/parser/lexer.rl"
begin
# After every heredoc was parsed, @herebody_s contains the
# position of next token after all heredocs.
if @herebody_s
p = @herebody_s
@herebody_s = nil
end
end
line 1347 "lib/parser/lexer.rl"
begin
m = p end
hen 27 then
line 762 "lib/parser/lexer.rl"
begin
# After every heredoc was parsed, @herebody_s contains the
# position of next token after all heredocs.
if @herebody_s
p = @herebody_s
@herebody_s = nil
end
end
line 1376 "lib/parser/lexer.rl"
begin
m = p end
hen 165 then
line 762 "lib/parser/lexer.rl"
begin
# After every heredoc was parsed, @herebody_s contains the
# position of next token after all heredocs.
if @herebody_s
p = @herebody_s
@herebody_s = nil
end
end
line 1214 "lib/parser/lexer.rl"
begin
te = p
= p - 1; end
hen 184 then
line 762 "lib/parser/lexer.rl"
begin
# After every heredoc was parsed, @herebody_s contains the
# position of next token after all heredocs.
if @herebody_s
p = @herebody_s
@herebody_s = nil
end
end
line 1232 "lib/parser/lexer.rl"
begin
te = p
= p - 1; end
hen 192 then
line 762 "lib/parser/lexer.rl"
begin
# After every heredoc was parsed, @herebody_s contains the
# position of next token after all heredocs.
if @herebody_s
p = @herebody_s
@herebody_s = nil
end
end
line 1264 "lib/parser/lexer.rl"
begin
te = p
= p - 1; end
hen 25 then
line 762 "lib/parser/lexer.rl"
begin
# After every heredoc was parsed, @herebody_s contains the
# position of next token after all heredocs.
if @herebody_s
p = @herebody_s
@herebody_s = nil
end
end
line 1386 "lib/parser/lexer.rl"
begin
te = p+1
egin
p = @ts - 1
begin
@cs = 736
_goto_level = _again
next
nd
end
end
hen 222 then
line 762 "lib/parser/lexer.rl"
begin
# After every heredoc was parsed, @herebody_s contains the
# position of next token after all heredocs.
if @herebody_s
p = @herebody_s
@herebody_s = nil
end
end
line 1391 "lib/parser/lexer.rl"
begin
te = p
= p - 1; end
hen 216 then
line 762 "lib/parser/lexer.rl"
begin
# After every heredoc was parsed, @herebody_s contains the
# position of next token after all heredocs.
if @herebody_s
p = @herebody_s
@herebody_s = nil
end
end
line 1397 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin p = p - 1; begin
@cs = 736
_goto_level = _again
next
nd
end
end
hen 233 then
line 762 "lib/parser/lexer.rl"
begin
# After every heredoc was parsed, @herebody_s contains the
# position of next token after all heredocs.
if @herebody_s
p = @herebody_s
@herebody_s = nil
end
end
line 1466 "lib/parser/lexer.rl"
begin
te = p
= p - 1; end
hen 245 then
line 762 "lib/parser/lexer.rl"
begin
# After every heredoc was parsed, @herebody_s contains the
# position of next token after all heredocs.
if @herebody_s
p = @herebody_s
@herebody_s = nil
end
end
line 1487 "lib/parser/lexer.rl"
begin
te = p
= p - 1; end
hen 241 then
line 762 "lib/parser/lexer.rl"
begin
# After every heredoc was parsed, @herebody_s contains the
# position of next token after all heredocs.
if @herebody_s
p = @herebody_s
@herebody_s = nil
end
end
line 1490 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin p = p - 1; begin
@cs = 736
_goto_level = _again
next
nd
end
end
hen 261 then
line 762 "lib/parser/lexer.rl"
begin
# After every heredoc was parsed, @herebody_s contains the
# position of next token after all heredocs.
if @herebody_s
p = @herebody_s
@herebody_s = nil
end
end
line 1737 "lib/parser/lexer.rl"
begin
te = p
= p - 1; end
hen 331 then
line 762 "lib/parser/lexer.rl"
begin
# After every heredoc was parsed, @herebody_s contains the
# position of next token after all heredocs.
if @herebody_s
p = @herebody_s
@herebody_s = nil
end
end
line 1766 "lib/parser/lexer.rl"
begin
te = p
= p - 1; end
hen 328 then
line 762 "lib/parser/lexer.rl"
begin
# After every heredoc was parsed, @herebody_s contains the
# position of next token after all heredocs.
if @herebody_s
p = @herebody_s
@herebody_s = nil
end
end
line 1769 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin begin
@cs = 152
_goto_level = _again
next
nd
end
end
hen 387 then
line 762 "lib/parser/lexer.rl"
begin
# After every heredoc was parsed, @herebody_s contains the
# position of next token after all heredocs.
if @herebody_s
p = @herebody_s
@herebody_s = nil
end
end
line 2016 "lib/parser/lexer.rl"
begin
te = p
= p - 1; end
hen 347 then
line 762 "lib/parser/lexer.rl"
begin
# After every heredoc was parsed, @herebody_s contains the
# position of next token after all heredocs.
if @herebody_s
p = @herebody_s
@herebody_s = nil
end
end
line 2019 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin begin
@cs = 903
_goto_level = _again
next
nd
end
end
hen 76 then
line 762 "lib/parser/lexer.rl"
begin
# After every heredoc was parsed, @herebody_s contains the
# position of next token after all heredocs.
if @herebody_s
p = @herebody_s
@herebody_s = nil
end
end
line 2074 "lib/parser/lexer.rl"
begin
te = p
= p - 1; end
hen 215 then
line 919 "lib/parser/lexer.rl"
begin
@cond.push(false); @cmdarg.push(false)
if literal
literal.start_interp_brace
end
end
line 1308 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
if @lambda_stack.last == @paren_nest
p = @ts - 1
begin
@cs = 736
_goto_level = _again
next
nd
else
emit(:tLCURLY, '{', @te - 1, @te)
@cs = 728; begin
p += 1
_goto_level = _out
next
nd
end
end
end
hen 235 then
line 919 "lib/parser/lexer.rl"
begin
@cond.push(false); @cmdarg.push(false)
if literal
literal.start_interp_brace
end
end
line 1459 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin emit(:tLBRACE_ARG)
@cs = 728; end
end
hen 323 then
line 919 "lib/parser/lexer.rl"
begin
@cond.push(false); @cmdarg.push(false)
if literal
literal.start_interp_brace
end
end
line 1656 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
if @lambda_stack.last == @paren_nest
@lambda_stack.pop
emit(:tLAMBEG)
else
emit_table(PUNCTUATION_BEGIN)
end
begin
p += 1
_goto_level = _out
next
nd
end
end
hen 399 then
line 919 "lib/parser/lexer.rl"
begin
@cond.push(false); @cmdarg.push(false)
if literal
literal.start_interp_brace
end
end
line 1791 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
if @lambda_stack.last == @paren_nest
@lambda_stack.pop
if tok == '{'
emit(:tLAMBEG)
else # 'do'
emit(:kDO_LAMBDA)
end
else
if tok == '{'
emit_table(PUNCTUATION)
else # 'do'
emit_do
end
end
@cs = 728; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 400 then
line 927 "lib/parser/lexer.rl"
begin
if literal
if literal.end_interp_brace_and_try_closing
if version?(18, 19)
emit(:tRCURLY, '}', p - 1, p)
else
emit(:tSTRING_DEND, '}', p - 1, p)
end
if literal.saved_herebody_s
@herebody_s = literal.saved_herebody_s
end
p = p - 1;
@cs = (stack_pop);
begin
p += 1
_goto_level = _out
next
nd
end
end
end
line 1983 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
emit_table(PUNCTUATION)
@cond.lexpop; @cmdarg.lexpop
if %w"} ]".include?(tok)
@cs = 484;
else # )
# fnext expr_endfn; ?
end
begin
p += 1
_goto_level = _out
next
nd
end
end
hen 62 then
line 1035 "lib/parser/lexer.rl"
begin
sharp_s = p - 1 end
line 1038 "lib/parser/lexer.rl"
begin
mit_comment(@sharp_s, p == pe ? p - 2 : p) end
hen 65 then
line 1038 "lib/parser/lexer.rl"
begin
mit_comment(@sharp_s, p == pe ? p - 2 : p) end
line 452 "lib/parser/lexer.rl"
begin
# Record position of a newline for precise location reporting on tNL
# tokens.
#
# This action is embedded directly into c_nl, as it is idempotent and
# there are no cases when we need to skip it.
@newline_s = p
end
hen 168 then
line 1038 "lib/parser/lexer.rl"
begin
mit_comment(@sharp_s, p == pe ? p - 2 : p) end
line 1214 "lib/parser/lexer.rl"
begin
te = p
= p - 1; end
hen 183 then
line 1038 "lib/parser/lexer.rl"
begin
mit_comment(@sharp_s, p == pe ? p - 2 : p) end
line 1232 "lib/parser/lexer.rl"
begin
te = p
= p - 1; end
hen 195 then
line 1038 "lib/parser/lexer.rl"
begin
mit_comment(@sharp_s, p == pe ? p - 2 : p) end
line 1264 "lib/parser/lexer.rl"
begin
te = p
= p - 1; end
hen 218 then
line 1038 "lib/parser/lexer.rl"
begin
mit_comment(@sharp_s, p == pe ? p - 2 : p) end
line 1394 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin begin
@cs = 736
_goto_level = _again
next
nd
end
end
hen 231 then
line 1038 "lib/parser/lexer.rl"
begin
mit_comment(@sharp_s, p == pe ? p - 2 : p) end
line 1466 "lib/parser/lexer.rl"
begin
te = p
= p - 1; end
hen 243 then
line 1038 "lib/parser/lexer.rl"
begin
mit_comment(@sharp_s, p == pe ? p - 2 : p) end
line 1487 "lib/parser/lexer.rl"
begin
te = p
= p - 1; end
hen 267 then
line 1038 "lib/parser/lexer.rl"
begin
mit_comment(@sharp_s, p == pe ? p - 2 : p) end
line 1737 "lib/parser/lexer.rl"
begin
te = p
= p - 1; end
hen 330 then
line 1038 "lib/parser/lexer.rl"
begin
mit_comment(@sharp_s, p == pe ? p - 2 : p) end
line 1766 "lib/parser/lexer.rl"
begin
te = p
= p - 1; end
hen 351 then
line 1038 "lib/parser/lexer.rl"
begin
mit_comment(@sharp_s, p == pe ? p - 2 : p) end
line 2016 "lib/parser/lexer.rl"
begin
te = p
= p - 1; end
hen 78 then
line 1038 "lib/parser/lexer.rl"
begin
mit_comment(@sharp_s, p == pe ? p - 2 : p) end
line 2074 "lib/parser/lexer.rl"
begin
te = p
= p - 1; end
hen 189 then
line 1079 "lib/parser/lexer.rl"
begin
m = p end
line 1254 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin emit(:tFID, tok(@ts, tm), @ts, tm)
@cs = (arg_or_cmdarg); p = tm - 1; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 279 then
line 1079 "lib/parser/lexer.rl"
begin
m = p end
line 1591 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
emit(:tSYMBOL, tok(@ts + 1, tm), @ts, tm)
p = tm - 1
@cs = 736; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 252 then
line 1079 "lib/parser/lexer.rl"
begin
m = p end
line 1725 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin p = @ts - 1
begin
@cs = 736
_goto_level = _again
next
nd
end
end
hen 343 then
line 1079 "lib/parser/lexer.rl"
begin
m = p end
line 1967 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin emit(:tFID, tok(@ts, tm), @ts, tm)
p = tm - 1
@cs = 448; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 345 then
line 1079 "lib/parser/lexer.rl"
begin
m = p end
line 1 "NONE"
begin
ase @act
hen 111 then
egin begin p = (( @te))-1; end
if @lambda_stack.last == @paren_nest
@lambda_stack.pop
if tok == '{'
emit(:tLAMBEG)
else # 'do'
emit(:kDO_LAMBDA)
end
else
if tok == '{'
emit_table(PUNCTUATION)
else # 'do'
emit_do
end
end
@cs = 728; begin
p += 1
_goto_level = _out
next
nd
end
hen 112 then
egin begin p = (( @te))-1; end
mit_table(KEYWORDS)
@cs = 307; begin
p += 1
_goto_level = _out
next
nd
nd
hen 113 then
egin begin p = (( @te))-1; end
mit(:kCLASS, 'class', @ts, @ts + 5)
emit(:tLSHFT, '<<', @te - 2, @te)
@cs = 728; begin
p += 1
_goto_level = _out
next
nd
nd
hen 114 then
egin begin p = (( @te))-1; end
mit_table(KEYWORDS)
@cs = 516; begin
p += 1
_goto_level = _out
next
nd
nd
hen 115 then
egin begin p = (( @te))-1; end
mit_table(KEYWORDS)
@cs = 728; begin
p += 1
_goto_level = _out
next
nd
nd
hen 116 then
egin begin p = (( @te))-1; end
mit_table(KEYWORDS)
@cs = 492; begin
p += 1
_goto_level = _out
next
nd
nd
hen 117 then
egin begin p = (( @te))-1; end
emit_table(KEYWORDS)
if version?(18) && tok == 'not'
@cs = 516; begin
p += 1
_goto_level = _out
next
nd
else
@cs = 448; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 118 then
egin begin p = (( @te))-1; end
if version?(18)
emit(:tIDENTIFIER)
if !@static_env.nil? && @static_env.declared?(tok)
@cs = 736;
else
@cs = (arg_or_cmdarg);
end
else
emit_table(KEYWORDS)
end
begin
p += 1
_goto_level = _out
next
nd
end
hen 119 then
egin begin p = (( @te))-1; end
mit_table(KEYWORDS)
begin
p += 1
_goto_level = _out
next
nd
nd
hen 120 then
egin begin p = (( @te))-1; end
digits = tok(@num_digits_s)
if digits.end_with? '_'
diagnostic :error, Parser::ERRORS[:trailing_in_number] % { :character => '_' },
range(@te - 1, @te)
elsif digits.empty? && @num_base == 8 && version?(18)
# 1.8 did not raise an error on 0o.
digits = "0"
elsif digits.empty?
diagnostic :error, Parser::ERRORS[:empty_numeric]
elsif @num_base == 8 && (invalid_idx = digits.index(/[89]/))
invalid_s = @num_digits_s + invalid_idx
diagnostic :error, Parser::ERRORS[:invalid_octal],
range(invalid_s, invalid_s + 1)
end
emit(:tINTEGER, digits.to_i(@num_base))
begin
p += 1
_goto_level = _out
next
nd
end
hen 122 then
egin begin p = (( @te))-1; end
if tok.end_with? 'e'
diagnostic :error, Parser::ERRORS[:trailing_in_number] % { :character => 'e' },
range(@te - 1, @te)
end
emit(:tFLOAT, tok.to_f)
begin
p += 1
_goto_level = _out
next
nd
end
hen 124 then
egin begin p = (( @te))-1; end
mit(:tCONSTANT)
@cs = (arg_or_cmdarg); begin
p += 1
_goto_level = _out
next
nd
nd
hen 128 then
egin begin p = (( @te))-1; end
emit(:tIDENTIFIER)
if !@static_env.nil? && @static_env.declared?(tok)
@cs = 736; begin
p += 1
_goto_level = _out
next
nd
else
@cs = (arg_or_cmdarg); begin
p += 1
_goto_level = _out
next
nd
end
end
hen 129 then
egin begin p = (( @te))-1; end
mit(:tFID, tok(@ts, tm), @ts, tm)
p = tm - 1
@cs = 448; begin
p += 1
_goto_level = _out
next
nd
nd
d
end
hen 190 then
line 1080 "lib/parser/lexer.rl"
begin
m = p - 2 end
line 1254 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin emit(:tFID, tok(@ts, tm), @ts, tm)
@cs = (arg_or_cmdarg); p = tm - 1; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 280 then
line 1080 "lib/parser/lexer.rl"
begin
m = p - 2 end
line 1591 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
emit(:tSYMBOL, tok(@ts + 1, tm), @ts, tm)
p = tm - 1
@cs = 736; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 254 then
line 1080 "lib/parser/lexer.rl"
begin
m = p - 2 end
line 1725 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin p = @ts - 1
begin
@cs = 736
_goto_level = _again
next
nd
end
end
hen 344 then
line 1080 "lib/parser/lexer.rl"
begin
m = p - 2 end
line 1967 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin emit(:tFID, tok(@ts, tm), @ts, tm)
p = tm - 1
@cs = 448; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 281 then
line 1085 "lib/parser/lexer.rl"
begin
m = p end
line 1591 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
emit(:tSYMBOL, tok(@ts + 1, tm), @ts, tm)
p = tm - 1
@cs = 736; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 255 then
line 1085 "lib/parser/lexer.rl"
begin
m = p end
line 1725 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin p = @ts - 1
begin
@cs = 736
_goto_level = _again
next
nd
end
end
hen 282 then
line 1086 "lib/parser/lexer.rl"
begin
m = p - 2 end
line 1591 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
emit(:tSYMBOL, tok(@ts + 1, tm), @ts, tm)
p = tm - 1
@cs = 736; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 256 then
line 1086 "lib/parser/lexer.rl"
begin
m = p - 2 end
line 1725 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin p = @ts - 1
begin
@cs = 736
_goto_level = _again
next
nd
end
end
hen 286 then
line 1087 "lib/parser/lexer.rl"
begin
m = p - 2 end
line 1591 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
emit(:tSYMBOL, tok(@ts + 1, tm), @ts, tm)
p = tm - 1
@cs = 736; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 259 then
line 1087 "lib/parser/lexer.rl"
begin
m = p - 2 end
line 1725 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin p = @ts - 1
begin
@cs = 736
_goto_level = _again
next
nd
end
end
hen 285 then
line 1088 "lib/parser/lexer.rl"
begin
m = p - 2 end
line 1591 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
emit(:tSYMBOL, tok(@ts + 1, tm), @ts, tm)
p = tm - 1
@cs = 736; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 258 then
line 1088 "lib/parser/lexer.rl"
begin
m = p - 2 end
line 1 "NONE"
begin
ase @act
hen 95 then
egin begin p = (( @te))-1; end
mit_table(PUNCTUATION_BEGIN)
begin
p += 1
_goto_level = _out
next
nd
nd
hen 96 then
egin begin p = (( @te))-1; end
mit_table(KEYWORDS_BEGIN, @ts, tm)
p = tm - 1
@cs = 492; begin
p += 1
_goto_level = _out
next
nd
nd
hen 97 then
egin begin p = (( @te))-1; end
mit_table(KEYWORDS_BEGIN)
@cs = 728; begin
p += 1
_goto_level = _out
next
nd
nd
hen 99 then
egin begin p = (( @te))-1; end
= @ts - 1
begin
@cs = 736
_goto_level = _again
next
nd
nd
hen 100 then
egin begin p = (( @te))-1; end
emit(:tIDENTIFIER)
if !@static_env.nil? && @static_env.declared?(tok)
@cs = 736; begin
p += 1
_goto_level = _out
next
nd
else
@cs = (arg_or_cmdarg); begin
p += 1
_goto_level = _out
next
nd
end
end
hen 103 then
egin begin p = (( @te))-1; end
= @ts - 1; begin
@cs = 736
_goto_level = _again
next
nd
nd
d
end
hen 283 then
line 1089 "lib/parser/lexer.rl"
begin
m = p - 3 end
line 1591 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
emit(:tSYMBOL, tok(@ts + 1, tm), @ts, tm)
p = tm - 1
@cs = 736; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 257 then
line 1089 "lib/parser/lexer.rl"
begin
m = p - 3 end
line 1725 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin p = @ts - 1
begin
@cs = 736
_goto_level = _again
next
nd
end
end
hen 284 then
line 1094 "lib/parser/lexer.rl"
begin
m = p - 2 end
line 1591 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
emit(:tSYMBOL, tok(@ts + 1, tm), @ts, tm)
p = tm - 1
@cs = 736; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 382 then
line 1099 "lib/parser/lexer.rl"
begin
m = p - 2 end
line 1949 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin emit(:tCONSTANT, tok(@ts, tm), @ts, tm)
p = tm - 1; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 214 then
line 1105 "lib/parser/lexer.rl"
begin
@cond.push(false); @cmdarg.push(false)
end
line 1302 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin emit(:tLBRACK, '[', @te - 1, @te)
@cs = 516; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 315 then
line 1105 "lib/parser/lexer.rl"
begin
@cond.push(false); @cmdarg.push(false)
end
line 1670 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin emit_table(PUNCTUATION_BEGIN)
begin
p += 1
_goto_level = _out
next
nd
end
end
hen 385 then
line 1105 "lib/parser/lexer.rl"
begin
@cond.push(false); @cmdarg.push(false)
end
line 2005 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin emit_table(PUNCTUATION)
@cs = 516; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 205 then
line 1112 "lib/parser/lexer.rl"
begin
@cond.push(false); @cmdarg.push(false)
@paren_nest += 1
end
line 1283 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
if version?(18)
emit(:tLPAREN2, '(', @te - 1, @te)
@cs = 728; begin
p += 1
_goto_level = _out
next
nd
else
emit(:tLPAREN_ARG, '(', @te - 1, @te)
@cs = 516; begin
p += 1
_goto_level = _out
next
nd
end
end
end
hen 219 then
line 1112 "lib/parser/lexer.rl"
begin
@cond.push(false); @cmdarg.push(false)
@paren_nest += 1
end
line 1296 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin emit(:tLPAREN2)
@cs = 516; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 225 then
line 1112 "lib/parser/lexer.rl"
begin
@cond.push(false); @cmdarg.push(false)
@paren_nest += 1
end
line 1413 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
emit(:tLPAREN_ARG, '(', @te - 1, @te)
if version?(18)
@cs = 728; begin
p += 1
_goto_level = _out
next
nd
else
@cs = 516; begin
p += 1
_goto_level = _out
next
nd
end
end
end
hen 272 then
line 1112 "lib/parser/lexer.rl"
begin
@cond.push(false); @cmdarg.push(false)
@paren_nest += 1
end
line 1670 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin emit_table(PUNCTUATION_BEGIN)
begin
p += 1
_goto_level = _out
next
nd
end
end
hen 355 then
line 1112 "lib/parser/lexer.rl"
begin
@cond.push(false); @cmdarg.push(false)
@paren_nest += 1
end
line 1979 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin emit_table(PUNCTUATION)
@cs = 516; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 356 then
line 1118 "lib/parser/lexer.rl"
begin
@paren_nest -= 1
end
line 1983 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
emit_table(PUNCTUATION)
@cond.lexpop; @cmdarg.lexpop
if %w"} ]".include?(tok)
@cs = 484;
else # )
# fnext expr_endfn; ?
end
begin
p += 1
_goto_level = _out
next
nd
end
end
hen 48 then
line 1561 "lib/parser/lexer.rl"
begin
heredoc_e = p end
line 452 "lib/parser/lexer.rl"
begin
# Record position of a newline for precise location reporting on tNL
# tokens.
#
# This action is embedded directly into c_nl, as it is idempotent and
# there are no cases when we need to skip it.
@newline_s = p
end
hen 287 then
line 1562 "lib/parser/lexer.rl"
begin
ew_herebody_s = p end
line 1563 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
tok(@ts, @heredoc_e) =~ /^<<(-?)(["'`]?)(.*)\2$/
indent = !$1.empty?
type = $2.empty? ? '"' : $2
delimiter = $3
@cs = (push_literal(type, delimiter, @ts, @heredoc_e, indent));
if @herebody_s.nil?
@herebody_s = new_herebody_s
end
p = @herebody_s - 1
end
end
hen 319 then
line 1680 "lib/parser/lexer.rl"
begin
m = p end
line 1681 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin emit_table(KEYWORDS_BEGIN, @ts, tm)
p = tm - 1
@cs = 492; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 377 then
line 1873 "lib/parser/lexer.rl"
begin
num_base = 16; @num_digits_s = p end
line 1888 "lib/parser/lexer.rl"
begin
te = p+1
egin
digits = tok(@num_digits_s)
if digits.end_with? '_'
diagnostic :error, Parser::ERRORS[:trailing_in_number] % { :character => '_' },
range(@te - 1, @te)
elsif digits.empty? && @num_base == 8 && version?(18)
# 1.8 did not raise an error on 0o.
digits = "0"
elsif digits.empty?
diagnostic :error, Parser::ERRORS[:empty_numeric]
elsif @num_base == 8 && (invalid_idx = digits.index(/[89]/))
invalid_s = @num_digits_s + invalid_idx
diagnostic :error, Parser::ERRORS[:invalid_octal],
range(invalid_s, invalid_s + 1)
end
emit(:tINTEGER, digits.to_i(@num_base))
begin
p += 1
_goto_level = _out
next
nd
end
end
hen 375 then
line 1873 "lib/parser/lexer.rl"
begin
num_base = 16; @num_digits_s = p end
line 1888 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
digits = tok(@num_digits_s)
if digits.end_with? '_'
diagnostic :error, Parser::ERRORS[:trailing_in_number] % { :character => '_' },
range(@te - 1, @te)
elsif digits.empty? && @num_base == 8 && version?(18)
# 1.8 did not raise an error on 0o.
digits = "0"
elsif digits.empty?
diagnostic :error, Parser::ERRORS[:empty_numeric]
elsif @num_base == 8 && (invalid_idx = digits.index(/[89]/))
invalid_s = @num_digits_s + invalid_idx
diagnostic :error, Parser::ERRORS[:invalid_octal],
range(invalid_s, invalid_s + 1)
end
emit(:tINTEGER, digits.to_i(@num_base))
begin
p += 1
_goto_level = _out
next
nd
end
end
hen 371 then
line 1875 "lib/parser/lexer.rl"
begin
num_base = 10; @num_digits_s = p end
line 1888 "lib/parser/lexer.rl"
begin
te = p+1
egin
digits = tok(@num_digits_s)
if digits.end_with? '_'
diagnostic :error, Parser::ERRORS[:trailing_in_number] % { :character => '_' },
range(@te - 1, @te)
elsif digits.empty? && @num_base == 8 && version?(18)
# 1.8 did not raise an error on 0o.
digits = "0"
elsif digits.empty?
diagnostic :error, Parser::ERRORS[:empty_numeric]
elsif @num_base == 8 && (invalid_idx = digits.index(/[89]/))
invalid_s = @num_digits_s + invalid_idx
diagnostic :error, Parser::ERRORS[:invalid_octal],
range(invalid_s, invalid_s + 1)
end
emit(:tINTEGER, digits.to_i(@num_base))
begin
p += 1
_goto_level = _out
next
nd
end
end
hen 369 then
line 1875 "lib/parser/lexer.rl"
begin
num_base = 10; @num_digits_s = p end
line 1888 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
digits = tok(@num_digits_s)
if digits.end_with? '_'
diagnostic :error, Parser::ERRORS[:trailing_in_number] % { :character => '_' },
range(@te - 1, @te)
elsif digits.empty? && @num_base == 8 && version?(18)
# 1.8 did not raise an error on 0o.
digits = "0"
elsif digits.empty?
diagnostic :error, Parser::ERRORS[:empty_numeric]
elsif @num_base == 8 && (invalid_idx = digits.index(/[89]/))
invalid_s = @num_digits_s + invalid_idx
diagnostic :error, Parser::ERRORS[:invalid_octal],
range(invalid_s, invalid_s + 1)
end
emit(:tINTEGER, digits.to_i(@num_base))
begin
p += 1
_goto_level = _out
next
nd
end
end
hen 374 then
line 1877 "lib/parser/lexer.rl"
begin
num_base = 8; @num_digits_s = p end
line 1888 "lib/parser/lexer.rl"
begin
te = p+1
egin
digits = tok(@num_digits_s)
if digits.end_with? '_'
diagnostic :error, Parser::ERRORS[:trailing_in_number] % { :character => '_' },
range(@te - 1, @te)
elsif digits.empty? && @num_base == 8 && version?(18)
# 1.8 did not raise an error on 0o.
digits = "0"
elsif digits.empty?
diagnostic :error, Parser::ERRORS[:empty_numeric]
elsif @num_base == 8 && (invalid_idx = digits.index(/[89]/))
invalid_s = @num_digits_s + invalid_idx
diagnostic :error, Parser::ERRORS[:invalid_octal],
range(invalid_s, invalid_s + 1)
end
emit(:tINTEGER, digits.to_i(@num_base))
begin
p += 1
_goto_level = _out
next
nd
end
end
hen 372 then
line 1877 "lib/parser/lexer.rl"
begin
num_base = 8; @num_digits_s = p end
line 1888 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
digits = tok(@num_digits_s)
if digits.end_with? '_'
diagnostic :error, Parser::ERRORS[:trailing_in_number] % { :character => '_' },
range(@te - 1, @te)
elsif digits.empty? && @num_base == 8 && version?(18)
# 1.8 did not raise an error on 0o.
digits = "0"
elsif digits.empty?
diagnostic :error, Parser::ERRORS[:empty_numeric]
elsif @num_base == 8 && (invalid_idx = digits.index(/[89]/))
invalid_s = @num_digits_s + invalid_idx
diagnostic :error, Parser::ERRORS[:invalid_octal],
range(invalid_s, invalid_s + 1)
end
emit(:tINTEGER, digits.to_i(@num_base))
begin
p += 1
_goto_level = _out
next
nd
end
end
hen 367 then
line 1879 "lib/parser/lexer.rl"
begin
num_base = 2; @num_digits_s = p end
line 1888 "lib/parser/lexer.rl"
begin
te = p+1
egin
digits = tok(@num_digits_s)
if digits.end_with? '_'
diagnostic :error, Parser::ERRORS[:trailing_in_number] % { :character => '_' },
range(@te - 1, @te)
elsif digits.empty? && @num_base == 8 && version?(18)
# 1.8 did not raise an error on 0o.
digits = "0"
elsif digits.empty?
diagnostic :error, Parser::ERRORS[:empty_numeric]
elsif @num_base == 8 && (invalid_idx = digits.index(/[89]/))
invalid_s = @num_digits_s + invalid_idx
diagnostic :error, Parser::ERRORS[:invalid_octal],
range(invalid_s, invalid_s + 1)
end
emit(:tINTEGER, digits.to_i(@num_base))
begin
p += 1
_goto_level = _out
next
nd
end
end
hen 365 then
line 1879 "lib/parser/lexer.rl"
begin
num_base = 2; @num_digits_s = p end
line 1888 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
digits = tok(@num_digits_s)
if digits.end_with? '_'
diagnostic :error, Parser::ERRORS[:trailing_in_number] % { :character => '_' },
range(@te - 1, @te)
elsif digits.empty? && @num_base == 8 && version?(18)
# 1.8 did not raise an error on 0o.
digits = "0"
elsif digits.empty?
diagnostic :error, Parser::ERRORS[:empty_numeric]
elsif @num_base == 8 && (invalid_idx = digits.index(/[89]/))
invalid_s = @num_digits_s + invalid_idx
diagnostic :error, Parser::ERRORS[:invalid_octal],
range(invalid_s, invalid_s + 1)
end
emit(:tINTEGER, digits.to_i(@num_base))
begin
p += 1
_goto_level = _out
next
nd
end
end
hen 378 then
line 1882 "lib/parser/lexer.rl"
begin
num_base = 10; @num_digits_s = @ts end
line 1888 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
digits = tok(@num_digits_s)
if digits.end_with? '_'
diagnostic :error, Parser::ERRORS[:trailing_in_number] % { :character => '_' },
range(@te - 1, @te)
elsif digits.empty? && @num_base == 8 && version?(18)
# 1.8 did not raise an error on 0o.
digits = "0"
elsif digits.empty?
diagnostic :error, Parser::ERRORS[:empty_numeric]
elsif @num_base == 8 && (invalid_idx = digits.index(/[89]/))
invalid_s = @num_digits_s + invalid_idx
diagnostic :error, Parser::ERRORS[:invalid_octal],
range(invalid_s, invalid_s + 1)
end
emit(:tINTEGER, digits.to_i(@num_base))
begin
p += 1
_goto_level = _out
next
nd
end
end
hen 361 then
line 1885 "lib/parser/lexer.rl"
begin
num_base = 8; @num_digits_s = @ts end
line 1888 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
digits = tok(@num_digits_s)
if digits.end_with? '_'
diagnostic :error, Parser::ERRORS[:trailing_in_number] % { :character => '_' },
range(@te - 1, @te)
elsif digits.empty? && @num_base == 8 && version?(18)
# 1.8 did not raise an error on 0o.
digits = "0"
elsif digits.empty?
diagnostic :error, Parser::ERRORS[:empty_numeric]
elsif @num_base == 8 && (invalid_idx = digits.index(/[89]/))
invalid_s = @num_digits_s + invalid_idx
diagnostic :error, Parser::ERRORS[:invalid_octal],
range(invalid_s, invalid_s + 1)
end
emit(:tINTEGER, digits.to_i(@num_base))
begin
p += 1
_goto_level = _out
next
nd
end
end
hen 6 then
line 1 "NONE"
begin
te = p+1
end
line 452 "lib/parser/lexer.rl"
begin
# Record position of a newline for precise location reporting on tNL
# tokens.
#
# This action is embedded directly into c_nl, as it is idempotent and
# there are no cases when we need to skip it.
@newline_s = p
end
hen 174 then
line 1 "NONE"
begin
te = p+1
end
line 1184 "lib/parser/lexer.rl"
begin
act = 25; end
hen 161 then
line 1 "NONE"
begin
te = p+1
end
line 1188 "lib/parser/lexer.rl"
begin
act = 26; end
hen 157 then
line 1 "NONE"
begin
te = p+1
end
line 1192 "lib/parser/lexer.rl"
begin
act = 27; end
hen 18 then
line 1 "NONE"
begin
te = p+1
end
line 1333 "lib/parser/lexer.rl"
begin
act = 51; end
hen 31 then
line 1 "NONE"
begin
te = p+1
end
line 1338 "lib/parser/lexer.rl"
begin
act = 52; end
hen 207 then
line 1 "NONE"
begin
te = p+1
end
line 1348 "lib/parser/lexer.rl"
begin
act = 53; end
hen 19 then
line 1 "NONE"
begin
te = p+1
end
line 1386 "lib/parser/lexer.rl"
begin
act = 58; end
hen 200 then
line 1 "NONE"
begin
te = p+1
end
line 1391 "lib/parser/lexer.rl"
begin
act = 59; end
hen 226 then
line 1 "NONE"
begin
te = p+1
end
line 1423 "lib/parser/lexer.rl"
begin
act = 65; end
hen 37 then
line 1 "NONE"
begin
te = p+1
end
line 1436 "lib/parser/lexer.rl"
begin
act = 66; end
hen 247 then
line 1 "NONE"
begin
te = p+1
end
line 1481 "lib/parser/lexer.rl"
begin
act = 73; end
hen 236 then
line 1 "NONE"
begin
te = p+1
end
line 1485 "lib/parser/lexer.rl"
begin
act = 74; end
hen 250 then
line 1 "NONE"
begin
te = p+1
end
line 1675 "lib/parser/lexer.rl"
begin
act = 95; end
hen 318 then
line 1 "NONE"
begin
te = p+1
end
line 1681 "lib/parser/lexer.rl"
begin
act = 96; end
hen 317 then
line 1 "NONE"
begin
te = p+1
end
line 1687 "lib/parser/lexer.rl"
begin
act = 97; end
hen 52 then
line 1 "NONE"
begin
te = p+1
end
line 1725 "lib/parser/lexer.rl"
begin
act = 99; end
hen 248 then
line 1 "NONE"
begin
te = p+1
end
line 1123 "lib/parser/lexer.rl"
begin
act = 100; end
hen 251 then
line 1 "NONE"
begin
te = p+1
end
line 1753 "lib/parser/lexer.rl"
begin
act = 103; end
hen 395 then
line 1 "NONE"
begin
te = p+1
end
line 1791 "lib/parser/lexer.rl"
begin
act = 111; end
hen 390 then
line 1 "NONE"
begin
te = p+1
end
line 1816 "lib/parser/lexer.rl"
begin
act = 112; end
hen 398 then
line 1 "NONE"
begin
te = p+1
end
line 1826 "lib/parser/lexer.rl"
begin
act = 114; end
hen 391 then
line 1 "NONE"
begin
te = p+1
end
line 1831 "lib/parser/lexer.rl"
begin
act = 115; end
hen 392 then
line 1 "NONE"
begin
te = p+1
end
line 1835 "lib/parser/lexer.rl"
begin
act = 116; end
hen 397 then
line 1 "NONE"
begin
te = p+1
end
line 1839 "lib/parser/lexer.rl"
begin
act = 117; end
hen 389 then
line 1 "NONE"
begin
te = p+1
end
line 1850 "lib/parser/lexer.rl"
begin
act = 118; end
hen 384 then
line 1 "NONE"
begin
te = p+1
end
line 1866 "lib/parser/lexer.rl"
begin
act = 119; end
hen 337 then
line 1 "NONE"
begin
te = p+1
end
line 1888 "lib/parser/lexer.rl"
begin
act = 120; end
hen 59 then
line 1 "NONE"
begin
te = p+1
end
line 1919 "lib/parser/lexer.rl"
begin
act = 122; end
hen 340 then
line 1 "NONE"
begin
te = p+1
end
line 1945 "lib/parser/lexer.rl"
begin
act = 124; end
hen 332 then
line 1 "NONE"
begin
te = p+1
end
line 1123 "lib/parser/lexer.rl"
begin
act = 128; end
hen 342 then
line 1 "NONE"
begin
te = p+1
end
line 1967 "lib/parser/lexer.rl"
begin
act = 129; end
hen 151 then
line 452 "lib/parser/lexer.rl"
begin
# Record position of a newline for precise location reporting on tNL
# tokens.
#
# This action is embedded directly into c_nl, as it is idempotent and
# there are no cases when we need to skip it.
@newline_s = p
end
line 829 "lib/parser/lexer.rl"
begin
te = p+1
egin
if @te == pe
diagnostic :fatal, Parser::ERRORS[:string_eof],
range(literal.str_s, literal.str_s + 1)
end
if literal.heredoc?
line = tok(@herebody_s, @ts).gsub(/\r+$/, '')
# Try ending the heredoc with the complete most recently
# scanned line. @herebody_s always refers to the start of such line.
if literal.nest_and_try_closing(line, @herebody_s, @ts)
# Adjust @herebody_s to point to the next line.
@herebody_s = @te
# Continue regular lexing after the heredoc reference (<<END).
p = literal.heredoc_e - 1
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
else
# Ditto.
@herebody_s = @te
end
else
# Try ending the literal with a newline.
if literal.nest_and_try_closing(tok, @ts, @te)
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
end
if @herebody_s
# This is a regular literal intertwined with a heredoc. Like:
#
# p <<-foo+"1
# bar
# foo
# 2"
#
# which, incidentally, evaluates to "bar\n12".
p = @herebody_s - 1
@herebody_s = nil
end
end
if literal.words? && !eof_codepoint?(@source_pts[p])
literal.extend_space @ts, @te
else
# A literal newline is appended if the heredoc was _not_ closed
# this time (see fbreak above). See also Literal#nest_and_try_closing
# for rationale of calling #flush_string here.
literal.extend_string tok, @ts, @te
literal.flush_string
end
end
end
line 722 "lib/parser/lexer.rl"
begin
@escape_s = p
@escape = nil
end
hen 99 then
line 609 "lib/parser/lexer.rl"
begin
@escape = {
'a' => "\a", 'b' => "\b", 'e' => "\e", 'f' => "\f",
'n' => "\n", 'r' => "\r", 's' => "\s", 't' => "\t",
'v' => "\v", '\\' => "\\"
}.fetch(@source[p - 1].chr, @source[p - 1].chr)
end
line 623 "lib/parser/lexer.rl"
begin
@escape = encode_escape(@escape[0].ord & 0x9f)
end
line 781 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
if literal.nest_and_try_closing('\\', @ts, @ts + 1)
# If the literal is actually closed by the backslash,
# rewind the input prior to consuming the escape sequence.
p = @escape_s - 1
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
else
# Get the first character after the backslash.
escaped_char = @source[@escape_s].chr
if literal.munge_escape? escaped_char
# If this particular literal uses this character as an opening
# or closing delimiter, it is an escape sequence for that
# particular character. Write it without the backslash.
if literal.regexp?
# Regular expressions should have every escape sequence in its
# raw form.
literal.extend_string(tok, @ts, @te)
else
literal.extend_string(escaped_char, @ts, @te)
end
else
# It does not. So this is an actual escape sequence, yay!
# Two things to consider here.
#
# 1. The `escape' rule should be pure and so won't raise any
# errors by itself. Instead, it stores them in lambdas.
#
# 2. Non-interpolated literals do not go through the aforementioned
# rule. As \\ and \' (and variants) are munged, the full token
# should always be written for such literals.
@escape.call if @escape.respond_to? :call
if literal.regexp?
# Ditto. Also, expand escaped newlines.
literal.extend_string(tok.gsub("\\\n", ''), @ts, @te)
else
literal.extend_string(@escape || tok, @ts, @te)
end
end
end
end
end
hen 126 then
line 609 "lib/parser/lexer.rl"
begin
@escape = {
'a' => "\a", 'b' => "\b", 'e' => "\e", 'f' => "\f",
'n' => "\n", 'r' => "\r", 's' => "\s", 't' => "\t",
'v' => "\v", '\\' => "\\"
}.fetch(@source[p - 1].chr, @source[p - 1].chr)
end
line 623 "lib/parser/lexer.rl"
begin
@escape = encode_escape(@escape[0].ord & 0x9f)
end
line 781 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
if literal.nest_and_try_closing('\\', @ts, @ts + 1)
# If the literal is actually closed by the backslash,
# rewind the input prior to consuming the escape sequence.
p = @escape_s - 1
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
else
# Get the first character after the backslash.
escaped_char = @source[@escape_s].chr
if literal.munge_escape? escaped_char
# If this particular literal uses this character as an opening
# or closing delimiter, it is an escape sequence for that
# particular character. Write it without the backslash.
if literal.regexp?
# Regular expressions should have every escape sequence in its
# raw form.
literal.extend_string(tok, @ts, @te)
else
literal.extend_string(escaped_char, @ts, @te)
end
else
# It does not. So this is an actual escape sequence, yay!
# Two things to consider here.
#
# 1. The `escape' rule should be pure and so won't raise any
# errors by itself. Instead, it stores them in lambdas.
#
# 2. Non-interpolated literals do not go through the aforementioned
# rule. As \\ and \' (and variants) are munged, the full token
# should always be written for such literals.
@escape.call if @escape.respond_to? :call
if literal.regexp?
# Ditto. Also, expand escaped newlines.
literal.extend_string(tok.gsub("\\\n", ''), @ts, @te)
else
literal.extend_string(@escape || tok, @ts, @te)
end
end
end
end
end
hen 301 then
line 609 "lib/parser/lexer.rl"
begin
@escape = {
'a' => "\a", 'b' => "\b", 'e' => "\e", 'f' => "\f",
'n' => "\n", 'r' => "\r", 's' => "\s", 't' => "\t",
'v' => "\v", '\\' => "\\"
}.fetch(@source[p - 1].chr, @source[p - 1].chr)
end
line 623 "lib/parser/lexer.rl"
begin
@escape = encode_escape(@escape[0].ord & 0x9f)
end
line 1611 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
# Show an error if memorized.
@escape.call if @escape.respond_to? :call
value = @escape || tok(@ts + 1)
if version?(18)
emit(:tINTEGER, value[0].ord)
else
emit(:tCHARACTER, value)
end
@cs = 736; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 104 then
line 609 "lib/parser/lexer.rl"
begin
@escape = {
'a' => "\a", 'b' => "\b", 'e' => "\e", 'f' => "\f",
'n' => "\n", 'r' => "\r", 's' => "\s", 't' => "\t",
'v' => "\v", '\\' => "\\"
}.fetch(@source[p - 1].chr, @source[p - 1].chr)
end
line 627 "lib/parser/lexer.rl"
begin
@escape = encode_escape(@escape[0].ord | 0x80)
end
line 781 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
if literal.nest_and_try_closing('\\', @ts, @ts + 1)
# If the literal is actually closed by the backslash,
# rewind the input prior to consuming the escape sequence.
p = @escape_s - 1
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
else
# Get the first character after the backslash.
escaped_char = @source[@escape_s].chr
if literal.munge_escape? escaped_char
# If this particular literal uses this character as an opening
# or closing delimiter, it is an escape sequence for that
# particular character. Write it without the backslash.
if literal.regexp?
# Regular expressions should have every escape sequence in its
# raw form.
literal.extend_string(tok, @ts, @te)
else
literal.extend_string(escaped_char, @ts, @te)
end
else
# It does not. So this is an actual escape sequence, yay!
# Two things to consider here.
#
# 1. The `escape' rule should be pure and so won't raise any
# errors by itself. Instead, it stores them in lambdas.
#
# 2. Non-interpolated literals do not go through the aforementioned
# rule. As \\ and \' (and variants) are munged, the full token
# should always be written for such literals.
@escape.call if @escape.respond_to? :call
if literal.regexp?
# Ditto. Also, expand escaped newlines.
literal.extend_string(tok.gsub("\\\n", ''), @ts, @te)
else
literal.extend_string(@escape || tok, @ts, @te)
end
end
end
end
end
hen 131 then
line 609 "lib/parser/lexer.rl"
begin
@escape = {
'a' => "\a", 'b' => "\b", 'e' => "\e", 'f' => "\f",
'n' => "\n", 'r' => "\r", 's' => "\s", 't' => "\t",
'v' => "\v", '\\' => "\\"
}.fetch(@source[p - 1].chr, @source[p - 1].chr)
end
line 627 "lib/parser/lexer.rl"
begin
@escape = encode_escape(@escape[0].ord | 0x80)
end
line 781 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
if literal.nest_and_try_closing('\\', @ts, @ts + 1)
# If the literal is actually closed by the backslash,
# rewind the input prior to consuming the escape sequence.
p = @escape_s - 1
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
else
# Get the first character after the backslash.
escaped_char = @source[@escape_s].chr
if literal.munge_escape? escaped_char
# If this particular literal uses this character as an opening
# or closing delimiter, it is an escape sequence for that
# particular character. Write it without the backslash.
if literal.regexp?
# Regular expressions should have every escape sequence in its
# raw form.
literal.extend_string(tok, @ts, @te)
else
literal.extend_string(escaped_char, @ts, @te)
end
else
# It does not. So this is an actual escape sequence, yay!
# Two things to consider here.
#
# 1. The `escape' rule should be pure and so won't raise any
# errors by itself. Instead, it stores them in lambdas.
#
# 2. Non-interpolated literals do not go through the aforementioned
# rule. As \\ and \' (and variants) are munged, the full token
# should always be written for such literals.
@escape.call if @escape.respond_to? :call
if literal.regexp?
# Ditto. Also, expand escaped newlines.
literal.extend_string(tok.gsub("\\\n", ''), @ts, @te)
else
literal.extend_string(@escape || tok, @ts, @te)
end
end
end
end
end
hen 306 then
line 609 "lib/parser/lexer.rl"
begin
@escape = {
'a' => "\a", 'b' => "\b", 'e' => "\e", 'f' => "\f",
'n' => "\n", 'r' => "\r", 's' => "\s", 't' => "\t",
'v' => "\v", '\\' => "\\"
}.fetch(@source[p - 1].chr, @source[p - 1].chr)
end
line 627 "lib/parser/lexer.rl"
begin
@escape = encode_escape(@escape[0].ord | 0x80)
end
line 1611 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
# Show an error if memorized.
@escape.call if @escape.respond_to? :call
value = @escape || tok(@ts + 1)
if version?(18)
emit(:tINTEGER, value[0].ord)
else
emit(:tCHARACTER, value)
end
@cs = 736; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 103 then
line 633 "lib/parser/lexer.rl"
begin
escape = @source[p - 1].chr end
line 627 "lib/parser/lexer.rl"
begin
@escape = encode_escape(@escape[0].ord | 0x80)
end
line 781 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
if literal.nest_and_try_closing('\\', @ts, @ts + 1)
# If the literal is actually closed by the backslash,
# rewind the input prior to consuming the escape sequence.
p = @escape_s - 1
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
else
# Get the first character after the backslash.
escaped_char = @source[@escape_s].chr
if literal.munge_escape? escaped_char
# If this particular literal uses this character as an opening
# or closing delimiter, it is an escape sequence for that
# particular character. Write it without the backslash.
if literal.regexp?
# Regular expressions should have every escape sequence in its
# raw form.
literal.extend_string(tok, @ts, @te)
else
literal.extend_string(escaped_char, @ts, @te)
end
else
# It does not. So this is an actual escape sequence, yay!
# Two things to consider here.
#
# 1. The `escape' rule should be pure and so won't raise any
# errors by itself. Instead, it stores them in lambdas.
#
# 2. Non-interpolated literals do not go through the aforementioned
# rule. As \\ and \' (and variants) are munged, the full token
# should always be written for such literals.
@escape.call if @escape.respond_to? :call
if literal.regexp?
# Ditto. Also, expand escaped newlines.
literal.extend_string(tok.gsub("\\\n", ''), @ts, @te)
else
literal.extend_string(@escape || tok, @ts, @te)
end
end
end
end
end
hen 130 then
line 633 "lib/parser/lexer.rl"
begin
escape = @source[p - 1].chr end
line 627 "lib/parser/lexer.rl"
begin
@escape = encode_escape(@escape[0].ord | 0x80)
end
line 781 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
if literal.nest_and_try_closing('\\', @ts, @ts + 1)
# If the literal is actually closed by the backslash,
# rewind the input prior to consuming the escape sequence.
p = @escape_s - 1
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
else
# Get the first character after the backslash.
escaped_char = @source[@escape_s].chr
if literal.munge_escape? escaped_char
# If this particular literal uses this character as an opening
# or closing delimiter, it is an escape sequence for that
# particular character. Write it without the backslash.
if literal.regexp?
# Regular expressions should have every escape sequence in its
# raw form.
literal.extend_string(tok, @ts, @te)
else
literal.extend_string(escaped_char, @ts, @te)
end
else
# It does not. So this is an actual escape sequence, yay!
# Two things to consider here.
#
# 1. The `escape' rule should be pure and so won't raise any
# errors by itself. Instead, it stores them in lambdas.
#
# 2. Non-interpolated literals do not go through the aforementioned
# rule. As \\ and \' (and variants) are munged, the full token
# should always be written for such literals.
@escape.call if @escape.respond_to? :call
if literal.regexp?
# Ditto. Also, expand escaped newlines.
literal.extend_string(tok.gsub("\\\n", ''), @ts, @te)
else
literal.extend_string(@escape || tok, @ts, @te)
end
end
end
end
end
hen 305 then
line 633 "lib/parser/lexer.rl"
begin
escape = @source[p - 1].chr end
line 627 "lib/parser/lexer.rl"
begin
@escape = encode_escape(@escape[0].ord | 0x80)
end
line 1611 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
# Show an error if memorized.
@escape.call if @escape.respond_to? :call
value = @escape || tok(@ts + 1)
if version?(18)
emit(:tINTEGER, value[0].ord)
else
emit(:tCHARACTER, value)
end
@cs = 736; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 101 then
line 638 "lib/parser/lexer.rl"
begin
escape = "\x7f" end
line 627 "lib/parser/lexer.rl"
begin
@escape = encode_escape(@escape[0].ord | 0x80)
end
line 781 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
if literal.nest_and_try_closing('\\', @ts, @ts + 1)
# If the literal is actually closed by the backslash,
# rewind the input prior to consuming the escape sequence.
p = @escape_s - 1
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
else
# Get the first character after the backslash.
escaped_char = @source[@escape_s].chr
if literal.munge_escape? escaped_char
# If this particular literal uses this character as an opening
# or closing delimiter, it is an escape sequence for that
# particular character. Write it without the backslash.
if literal.regexp?
# Regular expressions should have every escape sequence in its
# raw form.
literal.extend_string(tok, @ts, @te)
else
literal.extend_string(escaped_char, @ts, @te)
end
else
# It does not. So this is an actual escape sequence, yay!
# Two things to consider here.
#
# 1. The `escape' rule should be pure and so won't raise any
# errors by itself. Instead, it stores them in lambdas.
#
# 2. Non-interpolated literals do not go through the aforementioned
# rule. As \\ and \' (and variants) are munged, the full token
# should always be written for such literals.
@escape.call if @escape.respond_to? :call
if literal.regexp?
# Ditto. Also, expand escaped newlines.
literal.extend_string(tok.gsub("\\\n", ''), @ts, @te)
else
literal.extend_string(@escape || tok, @ts, @te)
end
end
end
end
end
hen 128 then
line 638 "lib/parser/lexer.rl"
begin
escape = "\x7f" end
line 627 "lib/parser/lexer.rl"
begin
@escape = encode_escape(@escape[0].ord | 0x80)
end
line 781 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
if literal.nest_and_try_closing('\\', @ts, @ts + 1)
# If the literal is actually closed by the backslash,
# rewind the input prior to consuming the escape sequence.
p = @escape_s - 1
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
else
# Get the first character after the backslash.
escaped_char = @source[@escape_s].chr
if literal.munge_escape? escaped_char
# If this particular literal uses this character as an opening
# or closing delimiter, it is an escape sequence for that
# particular character. Write it without the backslash.
if literal.regexp?
# Regular expressions should have every escape sequence in its
# raw form.
literal.extend_string(tok, @ts, @te)
else
literal.extend_string(escaped_char, @ts, @te)
end
else
# It does not. So this is an actual escape sequence, yay!
# Two things to consider here.
#
# 1. The `escape' rule should be pure and so won't raise any
# errors by itself. Instead, it stores them in lambdas.
#
# 2. Non-interpolated literals do not go through the aforementioned
# rule. As \\ and \' (and variants) are munged, the full token
# should always be written for such literals.
@escape.call if @escape.respond_to? :call
if literal.regexp?
# Ditto. Also, expand escaped newlines.
literal.extend_string(tok.gsub("\\\n", ''), @ts, @te)
else
literal.extend_string(@escape || tok, @ts, @te)
end
end
end
end
end
hen 303 then
line 638 "lib/parser/lexer.rl"
begin
escape = "\x7f" end
line 627 "lib/parser/lexer.rl"
begin
@escape = encode_escape(@escape[0].ord | 0x80)
end
line 1611 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
# Show an error if memorized.
@escape.call if @escape.respond_to? :call
value = @escape || tok(@ts + 1)
if version?(18)
emit(:tINTEGER, value[0].ord)
else
emit(:tCHARACTER, value)
end
@cs = 736; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 97 then
line 639 "lib/parser/lexer.rl"
begin
escape = @source[p - 1].chr end
line 623 "lib/parser/lexer.rl"
begin
@escape = encode_escape(@escape[0].ord & 0x9f)
end
line 781 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
if literal.nest_and_try_closing('\\', @ts, @ts + 1)
# If the literal is actually closed by the backslash,
# rewind the input prior to consuming the escape sequence.
p = @escape_s - 1
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
else
# Get the first character after the backslash.
escaped_char = @source[@escape_s].chr
if literal.munge_escape? escaped_char
# If this particular literal uses this character as an opening
# or closing delimiter, it is an escape sequence for that
# particular character. Write it without the backslash.
if literal.regexp?
# Regular expressions should have every escape sequence in its
# raw form.
literal.extend_string(tok, @ts, @te)
else
literal.extend_string(escaped_char, @ts, @te)
end
else
# It does not. So this is an actual escape sequence, yay!
# Two things to consider here.
#
# 1. The `escape' rule should be pure and so won't raise any
# errors by itself. Instead, it stores them in lambdas.
#
# 2. Non-interpolated literals do not go through the aforementioned
# rule. As \\ and \' (and variants) are munged, the full token
# should always be written for such literals.
@escape.call if @escape.respond_to? :call
if literal.regexp?
# Ditto. Also, expand escaped newlines.
literal.extend_string(tok.gsub("\\\n", ''), @ts, @te)
else
literal.extend_string(@escape || tok, @ts, @te)
end
end
end
end
end
hen 124 then
line 639 "lib/parser/lexer.rl"
begin
escape = @source[p - 1].chr end
line 623 "lib/parser/lexer.rl"
begin
@escape = encode_escape(@escape[0].ord & 0x9f)
end
line 781 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
if literal.nest_and_try_closing('\\', @ts, @ts + 1)
# If the literal is actually closed by the backslash,
# rewind the input prior to consuming the escape sequence.
p = @escape_s - 1
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
else
# Get the first character after the backslash.
escaped_char = @source[@escape_s].chr
if literal.munge_escape? escaped_char
# If this particular literal uses this character as an opening
# or closing delimiter, it is an escape sequence for that
# particular character. Write it without the backslash.
if literal.regexp?
# Regular expressions should have every escape sequence in its
# raw form.
literal.extend_string(tok, @ts, @te)
else
literal.extend_string(escaped_char, @ts, @te)
end
else
# It does not. So this is an actual escape sequence, yay!
# Two things to consider here.
#
# 1. The `escape' rule should be pure and so won't raise any
# errors by itself. Instead, it stores them in lambdas.
#
# 2. Non-interpolated literals do not go through the aforementioned
# rule. As \\ and \' (and variants) are munged, the full token
# should always be written for such literals.
@escape.call if @escape.respond_to? :call
if literal.regexp?
# Ditto. Also, expand escaped newlines.
literal.extend_string(tok.gsub("\\\n", ''), @ts, @te)
else
literal.extend_string(@escape || tok, @ts, @te)
end
end
end
end
end
hen 299 then
line 639 "lib/parser/lexer.rl"
begin
escape = @source[p - 1].chr end
line 623 "lib/parser/lexer.rl"
begin
@escape = encode_escape(@escape[0].ord & 0x9f)
end
line 1611 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
# Show an error if memorized.
@escape.call if @escape.respond_to? :call
value = @escape || tok(@ts + 1)
if version?(18)
emit(:tINTEGER, value[0].ord)
else
emit(:tCHARACTER, value)
end
@cs = 736; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 110 then
line 672 "lib/parser/lexer.rl"
begin
@escape = lambda do
diagnostic :error, Parser::ERRORS[:invalid_unicode_escape],
range(@escape_s - 1, p)
end
end
line 586 "lib/parser/lexer.rl"
begin
@escape = ""
codepoints = tok(@escape_s + 2, p - 1)
codepoint_s = @escape_s + 2
codepoints.split(/[ \t]/).each do |codepoint_str|
codepoint = codepoint_str.to_i(16)
if codepoint >= 0x110000
@escape = lambda do
diagnostic :error, Parser::ERRORS[:unicode_point_too_large],
range(codepoint_s, codepoint_s + codepoint_str.length)
end
break
end
@escape += codepoint.chr(Encoding::UTF_8)
codepoint_s += codepoint_str.length + 1
end
end
line 781 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
if literal.nest_and_try_closing('\\', @ts, @ts + 1)
# If the literal is actually closed by the backslash,
# rewind the input prior to consuming the escape sequence.
p = @escape_s - 1
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
else
# Get the first character after the backslash.
escaped_char = @source[@escape_s].chr
if literal.munge_escape? escaped_char
# If this particular literal uses this character as an opening
# or closing delimiter, it is an escape sequence for that
# particular character. Write it without the backslash.
if literal.regexp?
# Regular expressions should have every escape sequence in its
# raw form.
literal.extend_string(tok, @ts, @te)
else
literal.extend_string(escaped_char, @ts, @te)
end
else
# It does not. So this is an actual escape sequence, yay!
# Two things to consider here.
#
# 1. The `escape' rule should be pure and so won't raise any
# errors by itself. Instead, it stores them in lambdas.
#
# 2. Non-interpolated literals do not go through the aforementioned
# rule. As \\ and \' (and variants) are munged, the full token
# should always be written for such literals.
@escape.call if @escape.respond_to? :call
if literal.regexp?
# Ditto. Also, expand escaped newlines.
literal.extend_string(tok.gsub("\\\n", ''), @ts, @te)
else
literal.extend_string(@escape || tok, @ts, @te)
end
end
end
end
end
hen 137 then
line 672 "lib/parser/lexer.rl"
begin
@escape = lambda do
diagnostic :error, Parser::ERRORS[:invalid_unicode_escape],
range(@escape_s - 1, p)
end
end
line 586 "lib/parser/lexer.rl"
begin
@escape = ""
codepoints = tok(@escape_s + 2, p - 1)
codepoint_s = @escape_s + 2
codepoints.split(/[ \t]/).each do |codepoint_str|
codepoint = codepoint_str.to_i(16)
if codepoint >= 0x110000
@escape = lambda do
diagnostic :error, Parser::ERRORS[:unicode_point_too_large],
range(codepoint_s, codepoint_s + codepoint_str.length)
end
break
end
@escape += codepoint.chr(Encoding::UTF_8)
codepoint_s += codepoint_str.length + 1
end
end
line 781 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
if literal.nest_and_try_closing('\\', @ts, @ts + 1)
# If the literal is actually closed by the backslash,
# rewind the input prior to consuming the escape sequence.
p = @escape_s - 1
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
else
# Get the first character after the backslash.
escaped_char = @source[@escape_s].chr
if literal.munge_escape? escaped_char
# If this particular literal uses this character as an opening
# or closing delimiter, it is an escape sequence for that
# particular character. Write it without the backslash.
if literal.regexp?
# Regular expressions should have every escape sequence in its
# raw form.
literal.extend_string(tok, @ts, @te)
else
literal.extend_string(escaped_char, @ts, @te)
end
else
# It does not. So this is an actual escape sequence, yay!
# Two things to consider here.
#
# 1. The `escape' rule should be pure and so won't raise any
# errors by itself. Instead, it stores them in lambdas.
#
# 2. Non-interpolated literals do not go through the aforementioned
# rule. As \\ and \' (and variants) are munged, the full token
# should always be written for such literals.
@escape.call if @escape.respond_to? :call
if literal.regexp?
# Ditto. Also, expand escaped newlines.
literal.extend_string(tok.gsub("\\\n", ''), @ts, @te)
else
literal.extend_string(@escape || tok, @ts, @te)
end
end
end
end
end
hen 312 then
line 672 "lib/parser/lexer.rl"
begin
@escape = lambda do
diagnostic :error, Parser::ERRORS[:invalid_unicode_escape],
range(@escape_s - 1, p)
end
end
line 586 "lib/parser/lexer.rl"
begin
@escape = ""
codepoints = tok(@escape_s + 2, p - 1)
codepoint_s = @escape_s + 2
codepoints.split(/[ \t]/).each do |codepoint_str|
codepoint = codepoint_str.to_i(16)
if codepoint >= 0x110000
@escape = lambda do
diagnostic :error, Parser::ERRORS[:unicode_point_too_large],
range(codepoint_s, codepoint_s + codepoint_str.length)
end
break
end
@escape += codepoint.chr(Encoding::UTF_8)
codepoint_s += codepoint_str.length + 1
end
end
line 1611 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
# Show an error if memorized.
@escape.call if @escape.respond_to? :call
value = @escape || tok(@ts + 1)
if version?(18)
emit(:tINTEGER, value[0].ord)
else
emit(:tCHARACTER, value)
end
@cs = 736; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 107 then
line 672 "lib/parser/lexer.rl"
begin
@escape = lambda do
diagnostic :error, Parser::ERRORS[:invalid_unicode_escape],
range(@escape_s - 1, p)
end
end
line 686 "lib/parser/lexer.rl"
begin
@escape = lambda do
diagnostic :fatal, Parser::ERRORS[:unterminated_unicode],
range(p - 1, p)
end
end
line 781 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
if literal.nest_and_try_closing('\\', @ts, @ts + 1)
# If the literal is actually closed by the backslash,
# rewind the input prior to consuming the escape sequence.
p = @escape_s - 1
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
else
# Get the first character after the backslash.
escaped_char = @source[@escape_s].chr
if literal.munge_escape? escaped_char
# If this particular literal uses this character as an opening
# or closing delimiter, it is an escape sequence for that
# particular character. Write it without the backslash.
if literal.regexp?
# Regular expressions should have every escape sequence in its
# raw form.
literal.extend_string(tok, @ts, @te)
else
literal.extend_string(escaped_char, @ts, @te)
end
else
# It does not. So this is an actual escape sequence, yay!
# Two things to consider here.
#
# 1. The `escape' rule should be pure and so won't raise any
# errors by itself. Instead, it stores them in lambdas.
#
# 2. Non-interpolated literals do not go through the aforementioned
# rule. As \\ and \' (and variants) are munged, the full token
# should always be written for such literals.
@escape.call if @escape.respond_to? :call
if literal.regexp?
# Ditto. Also, expand escaped newlines.
literal.extend_string(tok.gsub("\\\n", ''), @ts, @te)
else
literal.extend_string(@escape || tok, @ts, @te)
end
end
end
end
end
hen 134 then
line 672 "lib/parser/lexer.rl"
begin
@escape = lambda do
diagnostic :error, Parser::ERRORS[:invalid_unicode_escape],
range(@escape_s - 1, p)
end
end
line 686 "lib/parser/lexer.rl"
begin
@escape = lambda do
diagnostic :fatal, Parser::ERRORS[:unterminated_unicode],
range(p - 1, p)
end
end
line 781 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
if literal.nest_and_try_closing('\\', @ts, @ts + 1)
# If the literal is actually closed by the backslash,
# rewind the input prior to consuming the escape sequence.
p = @escape_s - 1
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
else
# Get the first character after the backslash.
escaped_char = @source[@escape_s].chr
if literal.munge_escape? escaped_char
# If this particular literal uses this character as an opening
# or closing delimiter, it is an escape sequence for that
# particular character. Write it without the backslash.
if literal.regexp?
# Regular expressions should have every escape sequence in its
# raw form.
literal.extend_string(tok, @ts, @te)
else
literal.extend_string(escaped_char, @ts, @te)
end
else
# It does not. So this is an actual escape sequence, yay!
# Two things to consider here.
#
# 1. The `escape' rule should be pure and so won't raise any
# errors by itself. Instead, it stores them in lambdas.
#
# 2. Non-interpolated literals do not go through the aforementioned
# rule. As \\ and \' (and variants) are munged, the full token
# should always be written for such literals.
@escape.call if @escape.respond_to? :call
if literal.regexp?
# Ditto. Also, expand escaped newlines.
literal.extend_string(tok.gsub("\\\n", ''), @ts, @te)
else
literal.extend_string(@escape || tok, @ts, @te)
end
end
end
end
end
hen 309 then
line 672 "lib/parser/lexer.rl"
begin
@escape = lambda do
diagnostic :error, Parser::ERRORS[:invalid_unicode_escape],
range(@escape_s - 1, p)
end
end
line 686 "lib/parser/lexer.rl"
begin
@escape = lambda do
diagnostic :fatal, Parser::ERRORS[:unterminated_unicode],
range(p - 1, p)
end
end
line 1611 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
# Show an error if memorized.
@escape.call if @escape.respond_to? :call
value = @escape || tok(@ts + 1)
if version?(18)
emit(:tINTEGER, value[0].ord)
else
emit(:tCHARACTER, value)
end
@cs = 736; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 92 then
line 722 "lib/parser/lexer.rl"
begin
@escape_s = p
@escape = nil
end
line 715 "lib/parser/lexer.rl"
begin
diagnostic :fatal, Parser::ERRORS[:escape_eof],
range(p - 1, p)
end
line 781 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
if literal.nest_and_try_closing('\\', @ts, @ts + 1)
# If the literal is actually closed by the backslash,
# rewind the input prior to consuming the escape sequence.
p = @escape_s - 1
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
else
# Get the first character after the backslash.
escaped_char = @source[@escape_s].chr
if literal.munge_escape? escaped_char
# If this particular literal uses this character as an opening
# or closing delimiter, it is an escape sequence for that
# particular character. Write it without the backslash.
if literal.regexp?
# Regular expressions should have every escape sequence in its
# raw form.
literal.extend_string(tok, @ts, @te)
else
literal.extend_string(escaped_char, @ts, @te)
end
else
# It does not. So this is an actual escape sequence, yay!
# Two things to consider here.
#
# 1. The `escape' rule should be pure and so won't raise any
# errors by itself. Instead, it stores them in lambdas.
#
# 2. Non-interpolated literals do not go through the aforementioned
# rule. As \\ and \' (and variants) are munged, the full token
# should always be written for such literals.
@escape.call if @escape.respond_to? :call
if literal.regexp?
# Ditto. Also, expand escaped newlines.
literal.extend_string(tok.gsub("\\\n", ''), @ts, @te)
else
literal.extend_string(@escape || tok, @ts, @te)
end
end
end
end
end
hen 119 then
line 722 "lib/parser/lexer.rl"
begin
@escape_s = p
@escape = nil
end
line 715 "lib/parser/lexer.rl"
begin
diagnostic :fatal, Parser::ERRORS[:escape_eof],
range(p - 1, p)
end
line 781 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
if literal.nest_and_try_closing('\\', @ts, @ts + 1)
# If the literal is actually closed by the backslash,
# rewind the input prior to consuming the escape sequence.
p = @escape_s - 1
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
else
# Get the first character after the backslash.
escaped_char = @source[@escape_s].chr
if literal.munge_escape? escaped_char
# If this particular literal uses this character as an opening
# or closing delimiter, it is an escape sequence for that
# particular character. Write it without the backslash.
if literal.regexp?
# Regular expressions should have every escape sequence in its
# raw form.
literal.extend_string(tok, @ts, @te)
else
literal.extend_string(escaped_char, @ts, @te)
end
else
# It does not. So this is an actual escape sequence, yay!
# Two things to consider here.
#
# 1. The `escape' rule should be pure and so won't raise any
# errors by itself. Instead, it stores them in lambdas.
#
# 2. Non-interpolated literals do not go through the aforementioned
# rule. As \\ and \' (and variants) are munged, the full token
# should always be written for such literals.
@escape.call if @escape.respond_to? :call
if literal.regexp?
# Ditto. Also, expand escaped newlines.
literal.extend_string(tok.gsub("\\\n", ''), @ts, @te)
else
literal.extend_string(@escape || tok, @ts, @te)
end
end
end
end
end
hen 63 then
line 1035 "lib/parser/lexer.rl"
begin
sharp_s = p - 1 end
line 1038 "lib/parser/lexer.rl"
begin
mit_comment(@sharp_s, p == pe ? p - 2 : p) end
line 452 "lib/parser/lexer.rl"
begin
# Record position of a newline for precise location reporting on tNL
# tokens.
#
# This action is embedded directly into c_nl, as it is idempotent and
# there are no cases when we need to skip it.
@newline_s = p
end
hen 167 then
line 1035 "lib/parser/lexer.rl"
begin
sharp_s = p - 1 end
line 1038 "lib/parser/lexer.rl"
begin
mit_comment(@sharp_s, p == pe ? p - 2 : p) end
line 1214 "lib/parser/lexer.rl"
begin
te = p
= p - 1; end
hen 182 then
line 1035 "lib/parser/lexer.rl"
begin
sharp_s = p - 1 end
line 1038 "lib/parser/lexer.rl"
begin
mit_comment(@sharp_s, p == pe ? p - 2 : p) end
line 1232 "lib/parser/lexer.rl"
begin
te = p
= p - 1; end
hen 194 then
line 1035 "lib/parser/lexer.rl"
begin
sharp_s = p - 1 end
line 1038 "lib/parser/lexer.rl"
begin
mit_comment(@sharp_s, p == pe ? p - 2 : p) end
line 1264 "lib/parser/lexer.rl"
begin
te = p
= p - 1; end
hen 217 then
line 1035 "lib/parser/lexer.rl"
begin
sharp_s = p - 1 end
line 1038 "lib/parser/lexer.rl"
begin
mit_comment(@sharp_s, p == pe ? p - 2 : p) end
line 1394 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin begin
@cs = 736
_goto_level = _again
next
nd
end
end
hen 230 then
line 1035 "lib/parser/lexer.rl"
begin
sharp_s = p - 1 end
line 1038 "lib/parser/lexer.rl"
begin
mit_comment(@sharp_s, p == pe ? p - 2 : p) end
line 1466 "lib/parser/lexer.rl"
begin
te = p
= p - 1; end
hen 242 then
line 1035 "lib/parser/lexer.rl"
begin
sharp_s = p - 1 end
line 1038 "lib/parser/lexer.rl"
begin
mit_comment(@sharp_s, p == pe ? p - 2 : p) end
line 1487 "lib/parser/lexer.rl"
begin
te = p
= p - 1; end
hen 266 then
line 1035 "lib/parser/lexer.rl"
begin
sharp_s = p - 1 end
line 1038 "lib/parser/lexer.rl"
begin
mit_comment(@sharp_s, p == pe ? p - 2 : p) end
line 1737 "lib/parser/lexer.rl"
begin
te = p
= p - 1; end
hen 329 then
line 1035 "lib/parser/lexer.rl"
begin
sharp_s = p - 1 end
line 1038 "lib/parser/lexer.rl"
begin
mit_comment(@sharp_s, p == pe ? p - 2 : p) end
line 1766 "lib/parser/lexer.rl"
begin
te = p
= p - 1; end
hen 350 then
line 1035 "lib/parser/lexer.rl"
begin
sharp_s = p - 1 end
line 1038 "lib/parser/lexer.rl"
begin
mit_comment(@sharp_s, p == pe ? p - 2 : p) end
line 2016 "lib/parser/lexer.rl"
begin
te = p
= p - 1; end
hen 77 then
line 1035 "lib/parser/lexer.rl"
begin
sharp_s = p - 1 end
line 1038 "lib/parser/lexer.rl"
begin
mit_comment(@sharp_s, p == pe ? p - 2 : p) end
line 2074 "lib/parser/lexer.rl"
begin
te = p
= p - 1; end
hen 221 then
line 1 "NONE"
begin
te = p+1
end
line 452 "lib/parser/lexer.rl"
begin
# Record position of a newline for precise location reporting on tNL
# tokens.
#
# This action is embedded directly into c_nl, as it is idempotent and
# there are no cases when we need to skip it.
@newline_s = p
end
line 1391 "lib/parser/lexer.rl"
begin
act = 59; end
hen 26 then
line 1 "NONE"
begin
te = p+1
end
line 762 "lib/parser/lexer.rl"
begin
# After every heredoc was parsed, @herebody_s contains the
# position of next token after all heredocs.
if @herebody_s
p = @herebody_s
@herebody_s = nil
end
end
line 1338 "lib/parser/lexer.rl"
begin
act = 52; end
hen 22 then
line 1 "NONE"
begin
te = p+1
end
line 762 "lib/parser/lexer.rl"
begin
# After every heredoc was parsed, @herebody_s contains the
# position of next token after all heredocs.
if @herebody_s
p = @herebody_s
@herebody_s = nil
end
end
line 1386 "lib/parser/lexer.rl"
begin
act = 58; end
hen 38 then
line 1 "NONE"
begin
te = p+1
end
line 762 "lib/parser/lexer.rl"
begin
# After every heredoc was parsed, @herebody_s contains the
# position of next token after all heredocs.
if @herebody_s
p = @herebody_s
@herebody_s = nil
end
end
line 1436 "lib/parser/lexer.rl"
begin
act = 66; end
hen 66 then
line 1 "NONE"
begin
te = p+1
end
line 1038 "lib/parser/lexer.rl"
begin
mit_comment(@sharp_s, p == pe ? p - 2 : p) end
line 1820 "lib/parser/lexer.rl"
begin
act = 113; end
hen 28 then
line 1 "NONE"
begin
te = p+1
end
line 1347 "lib/parser/lexer.rl"
begin
m = p end
line 1348 "lib/parser/lexer.rl"
begin
act = 53; end
hen 321 then
line 1 "NONE"
begin
te = p+1
end
line 1680 "lib/parser/lexer.rl"
begin
m = p end
line 1725 "lib/parser/lexer.rl"
begin
act = 99; end
hen 320 then
line 1 "NONE"
begin
te = p+1
end
line 1680 "lib/parser/lexer.rl"
begin
m = p end
line 1123 "lib/parser/lexer.rl"
begin
act = 100; end
hen 380 then
line 1 "NONE"
begin
te = p+1
end
line 1882 "lib/parser/lexer.rl"
begin
num_base = 10; @num_digits_s = @ts end
line 1888 "lib/parser/lexer.rl"
begin
act = 120; end
hen 102 then
line 609 "lib/parser/lexer.rl"
begin
@escape = {
'a' => "\a", 'b' => "\b", 'e' => "\e", 'f' => "\f",
'n' => "\n", 'r' => "\r", 's' => "\s", 't' => "\t",
'v' => "\v", '\\' => "\\"
}.fetch(@source[p - 1].chr, @source[p - 1].chr)
end
line 623 "lib/parser/lexer.rl"
begin
@escape = encode_escape(@escape[0].ord & 0x9f)
end
line 627 "lib/parser/lexer.rl"
begin
@escape = encode_escape(@escape[0].ord | 0x80)
end
line 781 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
if literal.nest_and_try_closing('\\', @ts, @ts + 1)
# If the literal is actually closed by the backslash,
# rewind the input prior to consuming the escape sequence.
p = @escape_s - 1
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
else
# Get the first character after the backslash.
escaped_char = @source[@escape_s].chr
if literal.munge_escape? escaped_char
# If this particular literal uses this character as an opening
# or closing delimiter, it is an escape sequence for that
# particular character. Write it without the backslash.
if literal.regexp?
# Regular expressions should have every escape sequence in its
# raw form.
literal.extend_string(tok, @ts, @te)
else
literal.extend_string(escaped_char, @ts, @te)
end
else
# It does not. So this is an actual escape sequence, yay!
# Two things to consider here.
#
# 1. The `escape' rule should be pure and so won't raise any
# errors by itself. Instead, it stores them in lambdas.
#
# 2. Non-interpolated literals do not go through the aforementioned
# rule. As \\ and \' (and variants) are munged, the full token
# should always be written for such literals.
@escape.call if @escape.respond_to? :call
if literal.regexp?
# Ditto. Also, expand escaped newlines.
literal.extend_string(tok.gsub("\\\n", ''), @ts, @te)
else
literal.extend_string(@escape || tok, @ts, @te)
end
end
end
end
end
hen 129 then
line 609 "lib/parser/lexer.rl"
begin
@escape = {
'a' => "\a", 'b' => "\b", 'e' => "\e", 'f' => "\f",
'n' => "\n", 'r' => "\r", 's' => "\s", 't' => "\t",
'v' => "\v", '\\' => "\\"
}.fetch(@source[p - 1].chr, @source[p - 1].chr)
end
line 623 "lib/parser/lexer.rl"
begin
@escape = encode_escape(@escape[0].ord & 0x9f)
end
line 627 "lib/parser/lexer.rl"
begin
@escape = encode_escape(@escape[0].ord | 0x80)
end
line 781 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
if literal.nest_and_try_closing('\\', @ts, @ts + 1)
# If the literal is actually closed by the backslash,
# rewind the input prior to consuming the escape sequence.
p = @escape_s - 1
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
else
# Get the first character after the backslash.
escaped_char = @source[@escape_s].chr
if literal.munge_escape? escaped_char
# If this particular literal uses this character as an opening
# or closing delimiter, it is an escape sequence for that
# particular character. Write it without the backslash.
if literal.regexp?
# Regular expressions should have every escape sequence in its
# raw form.
literal.extend_string(tok, @ts, @te)
else
literal.extend_string(escaped_char, @ts, @te)
end
else
# It does not. So this is an actual escape sequence, yay!
# Two things to consider here.
#
# 1. The `escape' rule should be pure and so won't raise any
# errors by itself. Instead, it stores them in lambdas.
#
# 2. Non-interpolated literals do not go through the aforementioned
# rule. As \\ and \' (and variants) are munged, the full token
# should always be written for such literals.
@escape.call if @escape.respond_to? :call
if literal.regexp?
# Ditto. Also, expand escaped newlines.
literal.extend_string(tok.gsub("\\\n", ''), @ts, @te)
else
literal.extend_string(@escape || tok, @ts, @te)
end
end
end
end
end
hen 304 then
line 609 "lib/parser/lexer.rl"
begin
@escape = {
'a' => "\a", 'b' => "\b", 'e' => "\e", 'f' => "\f",
'n' => "\n", 'r' => "\r", 's' => "\s", 't' => "\t",
'v' => "\v", '\\' => "\\"
}.fetch(@source[p - 1].chr, @source[p - 1].chr)
end
line 623 "lib/parser/lexer.rl"
begin
@escape = encode_escape(@escape[0].ord & 0x9f)
end
line 627 "lib/parser/lexer.rl"
begin
@escape = encode_escape(@escape[0].ord | 0x80)
end
line 1611 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
# Show an error if memorized.
@escape.call if @escape.respond_to? :call
value = @escape || tok(@ts + 1)
if version?(18)
emit(:tINTEGER, value[0].ord)
else
emit(:tCHARACTER, value)
end
@cs = 736; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 100 then
line 639 "lib/parser/lexer.rl"
begin
escape = @source[p - 1].chr end
line 623 "lib/parser/lexer.rl"
begin
@escape = encode_escape(@escape[0].ord & 0x9f)
end
line 627 "lib/parser/lexer.rl"
begin
@escape = encode_escape(@escape[0].ord | 0x80)
end
line 781 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
if literal.nest_and_try_closing('\\', @ts, @ts + 1)
# If the literal is actually closed by the backslash,
# rewind the input prior to consuming the escape sequence.
p = @escape_s - 1
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
else
# Get the first character after the backslash.
escaped_char = @source[@escape_s].chr
if literal.munge_escape? escaped_char
# If this particular literal uses this character as an opening
# or closing delimiter, it is an escape sequence for that
# particular character. Write it without the backslash.
if literal.regexp?
# Regular expressions should have every escape sequence in its
# raw form.
literal.extend_string(tok, @ts, @te)
else
literal.extend_string(escaped_char, @ts, @te)
end
else
# It does not. So this is an actual escape sequence, yay!
# Two things to consider here.
#
# 1. The `escape' rule should be pure and so won't raise any
# errors by itself. Instead, it stores them in lambdas.
#
# 2. Non-interpolated literals do not go through the aforementioned
# rule. As \\ and \' (and variants) are munged, the full token
# should always be written for such literals.
@escape.call if @escape.respond_to? :call
if literal.regexp?
# Ditto. Also, expand escaped newlines.
literal.extend_string(tok.gsub("\\\n", ''), @ts, @te)
else
literal.extend_string(@escape || tok, @ts, @te)
end
end
end
end
end
hen 127 then
line 639 "lib/parser/lexer.rl"
begin
escape = @source[p - 1].chr end
line 623 "lib/parser/lexer.rl"
begin
@escape = encode_escape(@escape[0].ord & 0x9f)
end
line 627 "lib/parser/lexer.rl"
begin
@escape = encode_escape(@escape[0].ord | 0x80)
end
line 781 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
if literal.nest_and_try_closing('\\', @ts, @ts + 1)
# If the literal is actually closed by the backslash,
# rewind the input prior to consuming the escape sequence.
p = @escape_s - 1
@cs = (pop_literal); begin
p += 1
_goto_level = _out
next
nd
else
# Get the first character after the backslash.
escaped_char = @source[@escape_s].chr
if literal.munge_escape? escaped_char
# If this particular literal uses this character as an opening
# or closing delimiter, it is an escape sequence for that
# particular character. Write it without the backslash.
if literal.regexp?
# Regular expressions should have every escape sequence in its
# raw form.
literal.extend_string(tok, @ts, @te)
else
literal.extend_string(escaped_char, @ts, @te)
end
else
# It does not. So this is an actual escape sequence, yay!
# Two things to consider here.
#
# 1. The `escape' rule should be pure and so won't raise any
# errors by itself. Instead, it stores them in lambdas.
#
# 2. Non-interpolated literals do not go through the aforementioned
# rule. As \\ and \' (and variants) are munged, the full token
# should always be written for such literals.
@escape.call if @escape.respond_to? :call
if literal.regexp?
# Ditto. Also, expand escaped newlines.
literal.extend_string(tok.gsub("\\\n", ''), @ts, @te)
else
literal.extend_string(@escape || tok, @ts, @te)
end
end
end
end
end
hen 302 then
line 639 "lib/parser/lexer.rl"
begin
escape = @source[p - 1].chr end
line 623 "lib/parser/lexer.rl"
begin
@escape = encode_escape(@escape[0].ord & 0x9f)
end
line 627 "lib/parser/lexer.rl"
begin
@escape = encode_escape(@escape[0].ord | 0x80)
end
line 1611 "lib/parser/lexer.rl"
begin
te = p
= p - 1; begin
# Show an error if memorized.
@escape.call if @escape.respond_to? :call
value = @escape || tok(@ts + 1)
if version?(18)
emit(:tINTEGER, value[0].ord)
else
emit(:tCHARACTER, value)
end
@cs = 736; begin
p += 1
_goto_level = _out
next
nd
end
end
hen 23 then
line 1 "NONE"
begin
te = p+1
end
line 762 "lib/parser/lexer.rl"
begin
# After every heredoc was parsed, @herebody_s contains the
# position of next token after all heredocs.
if @herebody_s
p = @herebody_s
@herebody_s = nil
end
end
line 1347 "lib/parser/lexer.rl"
begin
m = p end
line 1348 "lib/parser/lexer.rl"
begin
act = 53; end
line 20133 "lib/parser/lexer.rb"
nd
nd
nd
f _goto_level <= _again
ase _lex_to_state_actions[ @cs]
hen 71 then
line 1 "NONE"
begin
ts = nil; end
line 20143 "lib/parser/lexer.rb"
nd
f @cs == 0
_goto_level = _out
next
nd
+= 1
f p != pe
_goto_level = _resume
next
nd
nd
f _goto_level <= _test_eof
f p == eof
f _lex_eof_trans[ @cs] > 0
_trans = _lex_eof_trans[ @cs] - 1;
_goto_level = _eof_trans
next;
nd
nd
nd
f _goto_level <= _out
break
nd
d
nd
line 253 "lib/parser/lexer.rl"
# %
@p = p
if @token_queue.any?
@token_queue.shift
elsif @cs == self.class.lex_error
[ false, [ '$error', range(p - 1, p) ] ]
else
[ false, [ '$eof', range(p - 1, p) ] ]
end
end