Class: Parser::LexerStrings

Inherits:

Object

Object
Parser::LexerStrings

show all

Defined in:: lib/parser/lexer-strings.rb

Overview

line 3 “lib/parser/lexer-strings.rl”

Constant Summary collapse

ESCAPES = %

{
  ?a.ord => "\a", ?b.ord  => "\b", ?e.ord => "\e", ?f.ord => "\f",
  ?n.ord => "\n", ?r.ord  => "\r", ?s.ord => "\s", ?t.ord => "\t",
  ?v.ord => "\v", ?\\.ord => "\\"
}.freeze

REGEXP_META_CHARACTERS =

Regexp.union(*"\\$()*+.<>?[]^{|}".chars).freeze

LEX_STATES =

{
  :interp_string => lex_en_interp_string,
  :interp_words  => lex_en_interp_words,
  :plain_string  => lex_en_plain_string,
  :plain_words   => lex_en_plain_string,
}

Class Attribute Summary collapse

Instance Attribute Summary collapse

#herebody_s ⇒ Object
#source_buffer ⇒ Object

Set by “main” lexer.
#source_pts ⇒ Object

Set by “main” lexer.

Instance Method Summary collapse

#advance(p) ⇒ Object
#close_interp_on_current_literal(p) ⇒ Object
#continue_lexing(current_literal) ⇒ Object
#dedent_level ⇒ Object
#initialize(lexer, version) ⇒ LexerStrings constructor

A new instance of LexerStrings.
#literal ⇒ Object
#next_state_for_literal(literal) ⇒ Object
#on_newline(p) ⇒ Object

This hook is triggered by “main” lexer on every newline character.
#pop_literal ⇒ Object
#push_literal(*args) ⇒ Object

LITERAL STACK ===.
#read_character_constant(p) ⇒ Object
#reset ⇒ Object

Constructor Details

#initialize(lexer, version) ⇒ `LexerStrings`

Returns a new instance of LexerStrings.

# File 'lib/parser/lexer-strings.rb', line 3300

def initialize(lexer, version)
  @lexer = lexer
  @version = version

  @_lex_actions =
    if self.class.respond_to?(:_lex_actions, true)
      self.class.send :_lex_actions
    else
      []
    end

  reset
end

Class Attribute Details

._lex_actions ⇒ `Object`



11
12
13

# File 'lib/parser/lexer-strings.rb', line 11

def _lex_actions
  @_lex_actions
end

._lex_eof_trans ⇒ `Object`



3184
3185
3186

# File 'lib/parser/lexer-strings.rb', line 3184

def _lex_eof_trans
  @_lex_eof_trans
end

._lex_from_state_actions ⇒ `Object`



3138
3139
3140

# File 'lib/parser/lexer-strings.rb', line 3138

def _lex_from_state_actions
  @_lex_from_state_actions
end

._lex_index_offsets ⇒ `Object`



244
245
246

# File 'lib/parser/lexer-strings.rb', line 244

def _lex_index_offsets
  @_lex_index_offsets
end

._lex_indicies ⇒ `Object`



290
291
292

# File 'lib/parser/lexer-strings.rb', line 290

def _lex_indicies
  @_lex_indicies
end

._lex_key_spans ⇒ `Object`



198
199
200

# File 'lib/parser/lexer-strings.rb', line 198

def _lex_key_spans
  @_lex_key_spans
end

._lex_to_state_actions ⇒ `Object`



3092
3093
3094

# File 'lib/parser/lexer-strings.rb', line 3092

def _lex_to_state_actions
  @_lex_to_state_actions
end

._lex_trans_actions ⇒ `Object`



3029
3030
3031

# File 'lib/parser/lexer-strings.rb', line 3029

def _lex_trans_actions
  @_lex_trans_actions
end

._lex_trans_keys ⇒ `Object`



76
77
78

# File 'lib/parser/lexer-strings.rb', line 76

def _lex_trans_keys
  @_lex_trans_keys
end

._lex_trans_targs ⇒ `Object`



2966
2967
2968

# File 'lib/parser/lexer-strings.rb', line 2966

def _lex_trans_targs
  @_lex_trans_targs
end

.lex_en_character ⇒ `Object`



3275
3276
3277

# File 'lib/parser/lexer-strings.rb', line 3275

def lex_en_character
  @lex_en_character
end

.lex_en_interp_backslash_delimited ⇒ `Object`



3255
3256
3257

# File 'lib/parser/lexer-strings.rb', line 3255

def lex_en_interp_backslash_delimited
  @lex_en_interp_backslash_delimited
end

.lex_en_interp_backslash_delimited_words ⇒ `Object`



3263
3264
3265

# File 'lib/parser/lexer-strings.rb', line 3263

def lex_en_interp_backslash_delimited_words
  @lex_en_interp_backslash_delimited_words
end

.lex_en_interp_string ⇒ `Object`



3243
3244
3245

# File 'lib/parser/lexer-strings.rb', line 3243

def lex_en_interp_string
  @lex_en_interp_string
end

.lex_en_interp_words ⇒ `Object`



3239
3240
3241

# File 'lib/parser/lexer-strings.rb', line 3239

def lex_en_interp_words
  @lex_en_interp_words
end

.lex_en_plain_backslash_delimited ⇒ `Object`



3259
3260
3261

# File 'lib/parser/lexer-strings.rb', line 3259

def lex_en_plain_backslash_delimited
  @lex_en_plain_backslash_delimited
end

.lex_en_plain_backslash_delimited_words ⇒ `Object`



3267
3268
3269

# File 'lib/parser/lexer-strings.rb', line 3267

def lex_en_plain_backslash_delimited_words
  @lex_en_plain_backslash_delimited_words
end

.lex_en_plain_string ⇒ `Object`



3251
3252
3253

# File 'lib/parser/lexer-strings.rb', line 3251

def lex_en_plain_string
  @lex_en_plain_string
end

.lex_en_plain_words ⇒ `Object`



3247
3248
3249

# File 'lib/parser/lexer-strings.rb', line 3247

def lex_en_plain_words
  @lex_en_plain_words
end

.lex_en_regexp_modifiers ⇒ `Object`



3271
3272
3273

# File 'lib/parser/lexer-strings.rb', line 3271

def lex_en_regexp_modifiers
  @lex_en_regexp_modifiers
end

.lex_en_unknown ⇒ `Object`



3279
3280
3281

# File 'lib/parser/lexer-strings.rb', line 3279

def lex_en_unknown
  @lex_en_unknown
end

.lex_error ⇒ `Object`



3234
3235
3236

# File 'lib/parser/lexer-strings.rb', line 3234

def lex_error
  @lex_error
end

.lex_start ⇒ `Object`



3230
3231
3232

# File 'lib/parser/lexer-strings.rb', line 3230

def lex_start
  @lex_start
end

Instance Attribute Details

#herebody_s ⇒ `Object`



3295
3296
3297

# File 'lib/parser/lexer-strings.rb', line 3295

def herebody_s
  @herebody_s
end

#source_buffer ⇒ `Object`

Set by “main” lexer



3298
3299
3300

# File 'lib/parser/lexer-strings.rb', line 3298

def source_buffer
  @source_buffer
end

#source_pts ⇒ `Object`

Set by “main” lexer



3298
3299
3300

# File 'lib/parser/lexer-strings.rb', line 3298

def source_pts
  @source_pts
end

Instance Method Details

#advance(p) ⇒ `Object`

# File 'lib/parser/lexer-strings.rb', line 3339

def advance(p)
  # Ugly, but dependent on Ragel output. Consider refactoring it somehow.
  klass = self.class
  _lex_trans_keys         = klass.send :_lex_trans_keys
  _lex_key_spans          = klass.send :_lex_key_spans
  _lex_index_offsets      = klass.send :_lex_index_offsets
  _lex_indicies           = klass.send :_lex_indicies
  _lex_trans_targs        = klass.send :_lex_trans_targs
  _lex_trans_actions      = klass.send :_lex_trans_actions
  _lex_to_state_actions   = klass.send :_lex_to_state_actions
  _lex_from_state_actions = klass.send :_lex_from_state_actions
  _lex_eof_trans          = klass.send :_lex_eof_trans
  _lex_actions            = @_lex_actions

  pe = source_pts.size + 2
  eof = pe

  
# line 3357 "lib/parser/lexer-strings.rb"
begin # ragel flat
	testEof = false
	_slen, _trans, _keys, _inds, _acts, _nacts = nil
	_goto_level = 0
	_resume = 10
	_eof_trans = 15
	_again = 20
	_test_eof = 30
	_out = 40
	while true
	_trigger_goto = false
	if _goto_level <= 0
	if p == pe
_goto_level = _test_eof
next
	end
	if  @cs == 0
_goto_level = _out
next
	end
	end
	if _goto_level <= _resume
	_acts = _lex_from_state_actions[ @cs]
	_nacts = _lex_actions[_acts]
	_acts += 1
	while _nacts > 0
_nacts -= 1
_acts += 1
case _lex_actions[_acts - 1]
	when 24 then
# line 1 "NONE"
begin
 @ts = p
end
# line 3392 "lib/parser/lexer-strings.rb"
end # from state action switch
	end
	if _trigger_goto
next
	end
	_keys =  @cs << 1
	_inds = _lex_index_offsets[ @cs]
	_slen = _lex_key_spans[ @cs]
	_wide = ( (source_pts[p] || 0))
	_trans = if (   _slen > 0 && 
	_lex_trans_keys[_keys] <= _wide && 
	_wide <= _lex_trans_keys[_keys + 1] 
    ) then
	_lex_indicies[ _inds + _wide - _lex_trans_keys[_keys] ] 
 else 
	_lex_indicies[ _inds + _slen ]
 end
	end
	if _goto_level <= _eof_trans
@cs = _lex_trans_targs[_trans]
	if _lex_trans_actions[_trans] != 0
_acts = _lex_trans_actions[_trans]
_nacts = _lex_actions[_acts]
_acts += 1
while _nacts > 0
	_nacts -= 1
	_acts += 1
	case _lex_actions[_acts - 1]
	when 0 then
# line 525 "lib/parser/lexer-strings.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
	when 1 then
# line 581 "lib/parser/lexer-strings.rl"
begin

  unicode_points(p)
		end
	when 2 then
# line 585 "lib/parser/lexer-strings.rl"
begin

  unescape_char(p)
		end
	when 3 then
# line 589 "lib/parser/lexer-strings.rl"
begin

  diagnostic :fatal, :invalid_escape
		end
	when 4 then
# line 593 "lib/parser/lexer-strings.rl"
begin

  read_post_meta_or_ctrl_char(p)
		end
	when 5 then
# line 597 "lib/parser/lexer-strings.rl"
begin

  slash_c_char
		end
	when 6 then
# line 601 "lib/parser/lexer-strings.rl"
begin

  slash_m_char
		end
	when 7 then
# line 607 "lib/parser/lexer-strings.rl"
begin
 encode_escaped_char(p) 		end
	when 8 then
# line 613 "lib/parser/lexer-strings.rl"
begin
 @escape = "\x7f" 		end
	when 9 then
# line 614 "lib/parser/lexer-strings.rl"
begin
 encode_escaped_char(p) 		end
	when 10 then
# line 621 "lib/parser/lexer-strings.rl"
begin
 @escape = encode_escape(tok(@escape_s, p).to_i(8) % 0x100) 		end
	when 11 then
# line 625 "lib/parser/lexer-strings.rl"
begin
 @escape = encode_escape(tok(@escape_s + 1, p).to_i(16)) 		end
	when 12 then
# line 629 "lib/parser/lexer-strings.rl"
begin

      diagnostic :fatal, :invalid_hex_escape, nil, range(@escape_s - 1, p + 2)
    		end
	when 13 then
# line 635 "lib/parser/lexer-strings.rl"
begin
 @escape = tok(@escape_s + 1, p).to_i(16).chr(Encoding::UTF_8) 		end
	when 14 then
# line 639 "lib/parser/lexer-strings.rl"
begin

      check_invalid_escapes(p)
    		end
	when 15 then
# line 645 "lib/parser/lexer-strings.rl"
begin

      check_invalid_escapes(p)
    		end
	when 16 then
# line 659 "lib/parser/lexer-strings.rl"
begin

        diagnostic :fatal, :unterminated_unicode, nil, range(p - 1, p)
      		end
	when 17 then
# line 685 "lib/parser/lexer-strings.rl"
begin

    diagnostic :fatal, :escape_eof, nil, range(p - 1, p)
  		end
	when 18 then
# line 691 "lib/parser/lexer-strings.rl"
begin

  @escape_s = p
  @escape   = nil
		end
	when 19 then
# line 808 "lib/parser/lexer-strings.rl"
begin
 interp_var_kind = :gvar 		end
	when 20 then
# line 809 "lib/parser/lexer-strings.rl"
begin
 interp_var_kind = :cvar 		end
	when 21 then
# line 810 "lib/parser/lexer-strings.rl"
begin
 interp_var_kind = :ivar 		end
	when 22 then
# line 944 "lib/parser/lexer-strings.rl"
begin
 @escape = nil 		end
	when 25 then
# line 1 "NONE"
begin
 @te = p+1
end
	when 26 then
# line 842 "lib/parser/lexer-strings.rl"
begin
 @te = p+1
 begin 
  current_literal = literal
  extend_interp_code(current_literal)
  @root_lexer_state = @lexer.class.lex_en_expr_value;
  	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

 end
end
	when 27 then
# line 761 "lib/parser/lexer-strings.rl"
begin
 @te = p+1
 begin 
  current_literal = literal
  extend_string_eol_check_eof(current_literal, pe)

  if current_literal.heredoc?
    line = extend_string_eol_heredoc_line

    # Try ending the heredoc with the complete most recently
    # scanned line. @herebody_s always refers to the start of such line.
    if current_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 = current_literal.heredoc_e - 1
       @cs = (pop_literal); 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

    else
      # Calculate indentation level for <<~HEREDOCs.
      current_literal.infer_indent_level(line)

      # Ditto.
      @herebody_s = @te
    end
  else
    # Try ending the literal with a newline.
    if current_literal.nest_and_try_closing(tok, @ts, @te)
       @cs = (pop_literal); 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

    end

    p = extend_string_eol_heredoc_intertwined(p)
  end

  extend_string_eol_words(current_literal, p)
 end
end
	when 28 then
# line 731 "lib/parser/lexer-strings.rl"
begin
 @te = p+1
 begin 
  string = tok

  lookahead = extend_string_slice_end(lookahead)

  current_literal = literal
  if !current_literal.heredoc? &&
        (token = current_literal.nest_and_try_closing(string, @ts, @te, lookahead))
    if token[0] == :tLABEL_END
      p += 1
      pop_literal
      @root_lexer_state = @lexer.class.lex_en_expr_labelarg
    else
      if state = pop_literal
         @cs = (state);
      end
    end
    	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

  else
    extend_string_for_token_range(current_literal, string)
  end
 end
end
	when 29 then
# line 824 "lib/parser/lexer-strings.rl"
begin
 @te = p
p = p - 1; begin 
  extend_interp_digit_var
 end
end
	when 30 then
# line 813 "lib/parser/lexer-strings.rl"
begin
 @te = p
p = p - 1; begin 
  current_literal = literal
  extend_interp_var(current_literal)
  emit_interp_var(interp_var_kind)
 end
end
	when 31 then
# line 754 "lib/parser/lexer-strings.rl"
begin
 @te = p
p = p - 1; begin 
  extend_string_escaped
 end
end
	when 32 then
# line 796 "lib/parser/lexer-strings.rl"
begin
 @te = p
p = p - 1; begin 
  literal.extend_space @ts, @te
 end
end
	when 33 then
# line 731 "lib/parser/lexer-strings.rl"
begin
 @te = p
p = p - 1; begin 
  string = tok

  lookahead = extend_string_slice_end(lookahead)

  current_literal = literal
  if !current_literal.heredoc? &&
        (token = current_literal.nest_and_try_closing(string, @ts, @te, lookahead))
    if token[0] == :tLABEL_END
      p += 1
      pop_literal
      @root_lexer_state = @lexer.class.lex_en_expr_labelarg
    else
      if state = pop_literal
         @cs = (state);
      end
    end
    	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

  else
    extend_string_for_token_range(current_literal, string)
  end
 end
end
	when 34 then
# line 754 "lib/parser/lexer-strings.rl"
begin
 begin p = (( @te))-1; end
 begin 
  extend_string_escaped
 end
end
	when 35 then
# line 731 "lib/parser/lexer-strings.rl"
begin
 begin p = (( @te))-1; end
 begin 
  string = tok

  lookahead = extend_string_slice_end(lookahead)

  current_literal = literal
  if !current_literal.heredoc? &&
        (token = current_literal.nest_and_try_closing(string, @ts, @te, lookahead))
    if token[0] == :tLABEL_END
      p += 1
      pop_literal
      @root_lexer_state = @lexer.class.lex_en_expr_labelarg
    else
      if state = pop_literal
         @cs = (state);
      end
    end
    	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

  else
    extend_string_for_token_range(current_literal, string)
  end
 end
end
	when 36 then
# line 842 "lib/parser/lexer-strings.rl"
begin
 @te = p+1
 begin 
  current_literal = literal
  extend_interp_code(current_literal)
  @root_lexer_state = @lexer.class.lex_en_expr_value;
  	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

 end
end
	when 37 then
# line 761 "lib/parser/lexer-strings.rl"
begin
 @te = p+1
 begin 
  current_literal = literal
  extend_string_eol_check_eof(current_literal, pe)

  if current_literal.heredoc?
    line = extend_string_eol_heredoc_line

    # Try ending the heredoc with the complete most recently
    # scanned line. @herebody_s always refers to the start of such line.
    if current_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 = current_literal.heredoc_e - 1
       @cs = (pop_literal); 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

    else
      # Calculate indentation level for <<~HEREDOCs.
      current_literal.infer_indent_level(line)

      # Ditto.
      @herebody_s = @te
    end
  else
    # Try ending the literal with a newline.
    if current_literal.nest_and_try_closing(tok, @ts, @te)
       @cs = (pop_literal); 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

    end

    p = extend_string_eol_heredoc_intertwined(p)
  end

  extend_string_eol_words(current_literal, p)
 end
end
	when 38 then
# line 731 "lib/parser/lexer-strings.rl"
begin
 @te = p+1
 begin 
  string = tok

  lookahead = extend_string_slice_end(lookahead)

  current_literal = literal
  if !current_literal.heredoc? &&
        (token = current_literal.nest_and_try_closing(string, @ts, @te, lookahead))
    if token[0] == :tLABEL_END
      p += 1
      pop_literal
      @root_lexer_state = @lexer.class.lex_en_expr_labelarg
    else
      if state = pop_literal
         @cs = (state);
      end
    end
    	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

  else
    extend_string_for_token_range(current_literal, string)
  end
 end
end
	when 39 then
# line 824 "lib/parser/lexer-strings.rl"
begin
 @te = p
p = p - 1; begin 
  extend_interp_digit_var
 end
end
	when 40 then
# line 813 "lib/parser/lexer-strings.rl"
begin
 @te = p
p = p - 1; begin 
  current_literal = literal
  extend_interp_var(current_literal)
  emit_interp_var(interp_var_kind)
 end
end
	when 41 then
# line 754 "lib/parser/lexer-strings.rl"
begin
 @te = p
p = p - 1; begin 
  extend_string_escaped
 end
end
	when 42 then
# line 731 "lib/parser/lexer-strings.rl"
begin
 @te = p
p = p - 1; begin 
  string = tok

  lookahead = extend_string_slice_end(lookahead)

  current_literal = literal
  if !current_literal.heredoc? &&
        (token = current_literal.nest_and_try_closing(string, @ts, @te, lookahead))
    if token[0] == :tLABEL_END
      p += 1
      pop_literal
      @root_lexer_state = @lexer.class.lex_en_expr_labelarg
    else
      if state = pop_literal
         @cs = (state);
      end
    end
    	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

  else
    extend_string_for_token_range(current_literal, string)
  end
 end
end
	when 43 then
# line 754 "lib/parser/lexer-strings.rl"
begin
 begin p = (( @te))-1; end
 begin 
  extend_string_escaped
 end
end
	when 44 then
# line 731 "lib/parser/lexer-strings.rl"
begin
 begin p = (( @te))-1; end
 begin 
  string = tok

  lookahead = extend_string_slice_end(lookahead)

  current_literal = literal
  if !current_literal.heredoc? &&
        (token = current_literal.nest_and_try_closing(string, @ts, @te, lookahead))
    if token[0] == :tLABEL_END
      p += 1
      pop_literal
      @root_lexer_state = @lexer.class.lex_en_expr_labelarg
    else
      if state = pop_literal
         @cs = (state);
      end
    end
    	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

  else
    extend_string_for_token_range(current_literal, string)
  end
 end
end
	when 45 then
# line 754 "lib/parser/lexer-strings.rl"
begin
 @te = p+1
 begin 
  extend_string_escaped
 end
end
	when 46 then
# line 761 "lib/parser/lexer-strings.rl"
begin
 @te = p+1
 begin 
  current_literal = literal
  extend_string_eol_check_eof(current_literal, pe)

  if current_literal.heredoc?
    line = extend_string_eol_heredoc_line

    # Try ending the heredoc with the complete most recently
    # scanned line. @herebody_s always refers to the start of such line.
    if current_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 = current_literal.heredoc_e - 1
       @cs = (pop_literal); 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

    else
      # Calculate indentation level for <<~HEREDOCs.
      current_literal.infer_indent_level(line)

      # Ditto.
      @herebody_s = @te
    end
  else
    # Try ending the literal with a newline.
    if current_literal.nest_and_try_closing(tok, @ts, @te)
       @cs = (pop_literal); 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

    end

    p = extend_string_eol_heredoc_intertwined(p)
  end

  extend_string_eol_words(current_literal, p)
 end
end
	when 47 then
# line 731 "lib/parser/lexer-strings.rl"
begin
 @te = p+1
 begin 
  string = tok

  lookahead = extend_string_slice_end(lookahead)

  current_literal = literal
  if !current_literal.heredoc? &&
        (token = current_literal.nest_and_try_closing(string, @ts, @te, lookahead))
    if token[0] == :tLABEL_END
      p += 1
      pop_literal
      @root_lexer_state = @lexer.class.lex_en_expr_labelarg
    else
      if state = pop_literal
         @cs = (state);
      end
    end
    	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

  else
    extend_string_for_token_range(current_literal, string)
  end
 end
end
	when 48 then
# line 796 "lib/parser/lexer-strings.rl"
begin
 @te = p
p = p - 1; begin 
  literal.extend_space @ts, @te
 end
end
	when 49 then
# line 731 "lib/parser/lexer-strings.rl"
begin
 @te = p
p = p - 1; begin 
  string = tok

  lookahead = extend_string_slice_end(lookahead)

  current_literal = literal
  if !current_literal.heredoc? &&
        (token = current_literal.nest_and_try_closing(string, @ts, @te, lookahead))
    if token[0] == :tLABEL_END
      p += 1
      pop_literal
      @root_lexer_state = @lexer.class.lex_en_expr_labelarg
    else
      if state = pop_literal
         @cs = (state);
      end
    end
    	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

  else
    extend_string_for_token_range(current_literal, string)
  end
 end
end
	when 50 then
# line 761 "lib/parser/lexer-strings.rl"
begin
 @te = p+1
 begin 
  current_literal = literal
  extend_string_eol_check_eof(current_literal, pe)

  if current_literal.heredoc?
    line = extend_string_eol_heredoc_line

    # Try ending the heredoc with the complete most recently
    # scanned line. @herebody_s always refers to the start of such line.
    if current_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 = current_literal.heredoc_e - 1
       @cs = (pop_literal); 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

    else
      # Calculate indentation level for <<~HEREDOCs.
      current_literal.infer_indent_level(line)

      # Ditto.
      @herebody_s = @te
    end
  else
    # Try ending the literal with a newline.
    if current_literal.nest_and_try_closing(tok, @ts, @te)
       @cs = (pop_literal); 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

    end

    p = extend_string_eol_heredoc_intertwined(p)
  end

  extend_string_eol_words(current_literal, p)
 end
end
	when 51 then
# line 754 "lib/parser/lexer-strings.rl"
begin
 @te = p+1
 begin 
  extend_string_escaped
 end
end
	when 52 then
# line 761 "lib/parser/lexer-strings.rl"
begin
 @te = p+1
 begin 
  current_literal = literal
  extend_string_eol_check_eof(current_literal, pe)

  if current_literal.heredoc?
    line = extend_string_eol_heredoc_line

    # Try ending the heredoc with the complete most recently
    # scanned line. @herebody_s always refers to the start of such line.
    if current_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 = current_literal.heredoc_e - 1
       @cs = (pop_literal); 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

    else
      # Calculate indentation level for <<~HEREDOCs.
      current_literal.infer_indent_level(line)

      # Ditto.
      @herebody_s = @te
    end
  else
    # Try ending the literal with a newline.
    if current_literal.nest_and_try_closing(tok, @ts, @te)
       @cs = (pop_literal); 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

    end

    p = extend_string_eol_heredoc_intertwined(p)
  end

  extend_string_eol_words(current_literal, p)
 end
end
	when 53 then
# line 731 "lib/parser/lexer-strings.rl"
begin
 @te = p+1
 begin 
  string = tok

  lookahead = extend_string_slice_end(lookahead)

  current_literal = literal
  if !current_literal.heredoc? &&
        (token = current_literal.nest_and_try_closing(string, @ts, @te, lookahead))
    if token[0] == :tLABEL_END
      p += 1
      pop_literal
      @root_lexer_state = @lexer.class.lex_en_expr_labelarg
    else
      if state = pop_literal
         @cs = (state);
      end
    end
    	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

  else
    extend_string_for_token_range(current_literal, string)
  end
 end
end
	when 54 then
# line 731 "lib/parser/lexer-strings.rl"
begin
 @te = p
p = p - 1; begin 
  string = tok

  lookahead = extend_string_slice_end(lookahead)

  current_literal = literal
  if !current_literal.heredoc? &&
        (token = current_literal.nest_and_try_closing(string, @ts, @te, lookahead))
    if token[0] == :tLABEL_END
      p += 1
      pop_literal
      @root_lexer_state = @lexer.class.lex_en_expr_labelarg
    else
      if state = pop_literal
         @cs = (state);
      end
    end
    	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

  else
    extend_string_for_token_range(current_literal, string)
  end
 end
end
	when 55 then
# line 842 "lib/parser/lexer-strings.rl"
begin
 @te = p+1
 begin 
  current_literal = literal
  extend_interp_code(current_literal)
  @root_lexer_state = @lexer.class.lex_en_expr_value;
  	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

 end
end
	when 56 then
# line 761 "lib/parser/lexer-strings.rl"
begin
 @te = p+1
 begin 
  current_literal = literal
  extend_string_eol_check_eof(current_literal, pe)

  if current_literal.heredoc?
    line = extend_string_eol_heredoc_line

    # Try ending the heredoc with the complete most recently
    # scanned line. @herebody_s always refers to the start of such line.
    if current_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 = current_literal.heredoc_e - 1
       @cs = (pop_literal); 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

    else
      # Calculate indentation level for <<~HEREDOCs.
      current_literal.infer_indent_level(line)

      # Ditto.
      @herebody_s = @te
    end
  else
    # Try ending the literal with a newline.
    if current_literal.nest_and_try_closing(tok, @ts, @te)
       @cs = (pop_literal); 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

    end

    p = extend_string_eol_heredoc_intertwined(p)
  end

  extend_string_eol_words(current_literal, p)
 end
end
	when 57 then
# line 731 "lib/parser/lexer-strings.rl"
begin
 @te = p+1
 begin 
  string = tok

  lookahead = extend_string_slice_end(lookahead)

  current_literal = literal
  if !current_literal.heredoc? &&
        (token = current_literal.nest_and_try_closing(string, @ts, @te, lookahead))
    if token[0] == :tLABEL_END
      p += 1
      pop_literal
      @root_lexer_state = @lexer.class.lex_en_expr_labelarg
    else
      if state = pop_literal
         @cs = (state);
      end
    end
    	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

  else
    extend_string_for_token_range(current_literal, string)
  end
 end
end
	when 58 then
# line 824 "lib/parser/lexer-strings.rl"
begin
 @te = p
p = p - 1; begin 
  extend_interp_digit_var
 end
end
	when 59 then
# line 813 "lib/parser/lexer-strings.rl"
begin
 @te = p
p = p - 1; begin 
  current_literal = literal
  extend_interp_var(current_literal)
  emit_interp_var(interp_var_kind)
 end
end
	when 60 then
# line 731 "lib/parser/lexer-strings.rl"
begin
 @te = p
p = p - 1; begin 
  string = tok

  lookahead = extend_string_slice_end(lookahead)

  current_literal = literal
  if !current_literal.heredoc? &&
        (token = current_literal.nest_and_try_closing(string, @ts, @te, lookahead))
    if token[0] == :tLABEL_END
      p += 1
      pop_literal
      @root_lexer_state = @lexer.class.lex_en_expr_labelarg
    else
      if state = pop_literal
         @cs = (state);
      end
    end
    	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

  else
    extend_string_for_token_range(current_literal, string)
  end
 end
end
	when 61 then
# line 731 "lib/parser/lexer-strings.rl"
begin
 begin p = (( @te))-1; end
 begin 
  string = tok

  lookahead = extend_string_slice_end(lookahead)

  current_literal = literal
  if !current_literal.heredoc? &&
        (token = current_literal.nest_and_try_closing(string, @ts, @te, lookahead))
    if token[0] == :tLABEL_END
      p += 1
      pop_literal
      @root_lexer_state = @lexer.class.lex_en_expr_labelarg
    else
      if state = pop_literal
         @cs = (state);
      end
    end
    	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

  else
    extend_string_for_token_range(current_literal, string)
  end
 end
end
	when 62 then
# line 761 "lib/parser/lexer-strings.rl"
begin
 @te = p+1
 begin 
  current_literal = literal
  extend_string_eol_check_eof(current_literal, pe)

  if current_literal.heredoc?
    line = extend_string_eol_heredoc_line

    # Try ending the heredoc with the complete most recently
    # scanned line. @herebody_s always refers to the start of such line.
    if current_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 = current_literal.heredoc_e - 1
       @cs = (pop_literal); 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

    else
      # Calculate indentation level for <<~HEREDOCs.
      current_literal.infer_indent_level(line)

      # Ditto.
      @herebody_s = @te
    end
  else
    # Try ending the literal with a newline.
    if current_literal.nest_and_try_closing(tok, @ts, @te)
       @cs = (pop_literal); 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

    end

    p = extend_string_eol_heredoc_intertwined(p)
  end

  extend_string_eol_words(current_literal, p)
 end
end
	when 63 then
# line 731 "lib/parser/lexer-strings.rl"
begin
 @te = p+1
 begin 
  string = tok

  lookahead = extend_string_slice_end(lookahead)

  current_literal = literal
  if !current_literal.heredoc? &&
        (token = current_literal.nest_and_try_closing(string, @ts, @te, lookahead))
    if token[0] == :tLABEL_END
      p += 1
      pop_literal
      @root_lexer_state = @lexer.class.lex_en_expr_labelarg
    else
      if state = pop_literal
         @cs = (state);
      end
    end
    	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

  else
    extend_string_for_token_range(current_literal, string)
  end
 end
end
	when 64 then
# line 842 "lib/parser/lexer-strings.rl"
begin
 @te = p+1
 begin 
  current_literal = literal
  extend_interp_code(current_literal)
  @root_lexer_state = @lexer.class.lex_en_expr_value;
  	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

 end
end
	when 65 then
# line 761 "lib/parser/lexer-strings.rl"
begin
 @te = p+1
 begin 
  current_literal = literal
  extend_string_eol_check_eof(current_literal, pe)

  if current_literal.heredoc?
    line = extend_string_eol_heredoc_line

    # Try ending the heredoc with the complete most recently
    # scanned line. @herebody_s always refers to the start of such line.
    if current_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 = current_literal.heredoc_e - 1
       @cs = (pop_literal); 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

    else
      # Calculate indentation level for <<~HEREDOCs.
      current_literal.infer_indent_level(line)

      # Ditto.
      @herebody_s = @te
    end
  else
    # Try ending the literal with a newline.
    if current_literal.nest_and_try_closing(tok, @ts, @te)
       @cs = (pop_literal); 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

    end

    p = extend_string_eol_heredoc_intertwined(p)
  end

  extend_string_eol_words(current_literal, p)
 end
end
	when 66 then
# line 731 "lib/parser/lexer-strings.rl"
begin
 @te = p+1
 begin 
  string = tok

  lookahead = extend_string_slice_end(lookahead)

  current_literal = literal
  if !current_literal.heredoc? &&
        (token = current_literal.nest_and_try_closing(string, @ts, @te, lookahead))
    if token[0] == :tLABEL_END
      p += 1
      pop_literal
      @root_lexer_state = @lexer.class.lex_en_expr_labelarg
    else
      if state = pop_literal
         @cs = (state);
      end
    end
    	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

  else
    extend_string_for_token_range(current_literal, string)
  end
 end
end
	when 67 then
# line 824 "lib/parser/lexer-strings.rl"
begin
 @te = p
p = p - 1; begin 
  extend_interp_digit_var
 end
end
	when 68 then
# line 813 "lib/parser/lexer-strings.rl"
begin
 @te = p
p = p - 1; begin 
  current_literal = literal
  extend_interp_var(current_literal)
  emit_interp_var(interp_var_kind)
 end
end
	when 69 then
# line 796 "lib/parser/lexer-strings.rl"
begin
 @te = p
p = p - 1; begin 
  literal.extend_space @ts, @te
 end
end
	when 70 then
# line 731 "lib/parser/lexer-strings.rl"
begin
 @te = p
p = p - 1; begin 
  string = tok

  lookahead = extend_string_slice_end(lookahead)

  current_literal = literal
  if !current_literal.heredoc? &&
        (token = current_literal.nest_and_try_closing(string, @ts, @te, lookahead))
    if token[0] == :tLABEL_END
      p += 1
      pop_literal
      @root_lexer_state = @lexer.class.lex_en_expr_labelarg
    else
      if state = pop_literal
         @cs = (state);
      end
    end
    	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

  else
    extend_string_for_token_range(current_literal, string)
  end
 end
end
	when 71 then
# line 731 "lib/parser/lexer-strings.rl"
begin
 begin p = (( @te))-1; end
 begin 
  string = tok

  lookahead = extend_string_slice_end(lookahead)

  current_literal = literal
  if !current_literal.heredoc? &&
        (token = current_literal.nest_and_try_closing(string, @ts, @te, lookahead))
    if token[0] == :tLABEL_END
      p += 1
      pop_literal
      @root_lexer_state = @lexer.class.lex_en_expr_labelarg
    else
      if state = pop_literal
         @cs = (state);
      end
    end
    	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

  else
    extend_string_for_token_range(current_literal, string)
  end
 end
end
	when 72 then
# line 761 "lib/parser/lexer-strings.rl"
begin
 @te = p+1
 begin 
  current_literal = literal
  extend_string_eol_check_eof(current_literal, pe)

  if current_literal.heredoc?
    line = extend_string_eol_heredoc_line

    # Try ending the heredoc with the complete most recently
    # scanned line. @herebody_s always refers to the start of such line.
    if current_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 = current_literal.heredoc_e - 1
       @cs = (pop_literal); 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

    else
      # Calculate indentation level for <<~HEREDOCs.
      current_literal.infer_indent_level(line)

      # Ditto.
      @herebody_s = @te
    end
  else
    # Try ending the literal with a newline.
    if current_literal.nest_and_try_closing(tok, @ts, @te)
       @cs = (pop_literal); 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

    end

    p = extend_string_eol_heredoc_intertwined(p)
  end

  extend_string_eol_words(current_literal, p)
 end
end
	when 73 then
# line 731 "lib/parser/lexer-strings.rl"
begin
 @te = p+1
 begin 
  string = tok

  lookahead = extend_string_slice_end(lookahead)

  current_literal = literal
  if !current_literal.heredoc? &&
        (token = current_literal.nest_and_try_closing(string, @ts, @te, lookahead))
    if token[0] == :tLABEL_END
      p += 1
      pop_literal
      @root_lexer_state = @lexer.class.lex_en_expr_labelarg
    else
      if state = pop_literal
         @cs = (state);
      end
    end
    	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

  else
    extend_string_for_token_range(current_literal, string)
  end
 end
end
	when 74 then
# line 796 "lib/parser/lexer-strings.rl"
begin
 @te = p
p = p - 1; begin 
  literal.extend_space @ts, @te
 end
end
	when 75 then
# line 928 "lib/parser/lexer-strings.rl"
begin
 @te = p+1
 begin 
      emit(:tREGEXP_OPT, tok(@ts, @te - 1), @ts, @te - 1)
      p = p - 1;
      @root_lexer_state = @lexer.class.lex_en_expr_end;
      	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

     end
end
	when 76 then
# line 915 "lib/parser/lexer-strings.rl"
begin
 @te = p
p = p - 1; begin 
      unknown_options = tok.scan(/[^imxouesn]/)
      if unknown_options.any?
        diagnostic :error, :regexp_options,
                   { :options => unknown_options.join }
      end

      emit(:tREGEXP_OPT)
      @root_lexer_state = @lexer.class.lex_en_expr_end;
      	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

     end
end
	when 77 then
# line 953 "lib/parser/lexer-strings.rl"
begin
 @te = p+1
 begin 
      escape = ESCAPE_WHITESPACE[source_buffer.slice(@ts + 1, 1)]
      diagnostic :warning, :invalid_escape_use, { :escape => escape }, range

      p = @ts - 1
      @root_lexer_state = @lexer.class.lex_en_expr_end;
      	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

     end
end
	when 78 then
# line 946 "lib/parser/lexer-strings.rl"
begin
 @te = p
p = p - 1; begin 
      emit_character_constant

      @root_lexer_state = @lexer.class.lex_en_expr_end; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

     end
end
	when 79 then
# line 964 "lib/parser/lexer-strings.rl"
begin
 @te = p
p = p - 1; begin 
      p = @ts - 1
      @root_lexer_state = @lexer.class.lex_en_expr_end;
      	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

     end
end
	when 80 then
# line 946 "lib/parser/lexer-strings.rl"
begin
 begin p = (( @te))-1; end
 begin 
      emit_character_constant

      @root_lexer_state = @lexer.class.lex_en_expr_end; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

     end
end
	when 81 then
# line 972 "lib/parser/lexer-strings.rl"
begin
 @te = p+1
 begin  raise 'bug'  end
end
# line 4935 "lib/parser/lexer-strings.rb"
	end # action switch
end
	end
	if _trigger_goto
next
	end
	end
	if _goto_level <= _again
	_acts = _lex_to_state_actions[ @cs]
	_nacts = _lex_actions[_acts]
	_acts += 1
	while _nacts > 0
_nacts -= 1
_acts += 1
case _lex_actions[_acts - 1]
	when 23 then
# line 1 "NONE"
begin
 @ts = nil;		end
# line 4955 "lib/parser/lexer-strings.rb"
end # to state action switch
	end
	if _trigger_goto
next
	end
	if  @cs == 0
_goto_level = _out
next
	end
	p += 1
	if p != pe
_goto_level = _resume
next
	end
	end
	if _goto_level <= _test_eof
	if p == eof
	if _lex_eof_trans[ @cs] > 0
_trans = _lex_eof_trans[ @cs] - 1;
_goto_level = _eof_trans
next;
	end
	end
	end
	if _goto_level <= _out
break
	end
	end
	end

# line 78 "lib/parser/lexer-strings.rl"
  # %

  # Ragel creates a local variable called `testEof` but it doesn't use
  # it in any assignment. This dead code is here to swallow the warning.
  # It has no runtime cost because Ruby doesn't produce any instructions from it.
  if false
    testEof
  end

  [p, @root_lexer_state]
end

#close_interp_on_current_literal(p) ⇒ `Object`

# File 'lib/parser/lexer-strings.rb', line 5069

def close_interp_on_current_literal(p)
  current_literal = literal
  if current_literal
    if current_literal.end_interp_brace_and_try_closing
      if version?(18, 19)
        emit(:tRCURLY, '}'.freeze, p - 1, p)
        @lexer.cond.lexpop
        @lexer.cmdarg.lexpop
      else
        emit(:tSTRING_DEND, '}'.freeze, p - 1, p)
      end

      if current_literal.saved_herebody_s
        @herebody_s = current_literal.saved_herebody_s
      end

      continue_lexing(current_literal)

      return true
    end
  end
end

#continue_lexing(current_literal) ⇒ `Object`



5043
5044
5045

# File 'lib/parser/lexer-strings.rb', line 5043

def continue_lexing(current_literal)
  @cs = next_state_for_literal(current_literal)
end

#dedent_level ⇒ `Object`

# File 'lib/parser/lexer-strings.rb', line 5092

def dedent_level
  # We erase @dedent_level as a precaution to avoid accidentally
  # using a stale value.
  dedent_level, @dedent_level = @dedent_level, nil
  dedent_level
end

#literal ⇒ `Object`



5047
5048
5049

# File 'lib/parser/lexer-strings.rb', line 5047

def literal
  @literal_stack.last
end

#next_state_for_literal(literal) ⇒ `Object`

# File 'lib/parser/lexer-strings.rb', line 5015

def next_state_for_literal(literal)
  if literal.words? && literal.backslash_delimited?
    if literal.interpolate?
      self.class.lex_en_interp_backslash_delimited_words
    else
      self.class.lex_en_plain_backslash_delimited_words
    end
  elsif literal.words? && !literal.backslash_delimited?
    if literal.interpolate?
      self.class.lex_en_interp_words
    else
      self.class.lex_en_plain_words
    end
  elsif !literal.words? && literal.backslash_delimited?
    if literal.interpolate?
      self.class.lex_en_interp_backslash_delimited
    else
      self.class.lex_en_plain_backslash_delimited
    end
  else
    if literal.interpolate?
      self.class.lex_en_interp_string
    else
      self.class.lex_en_plain_string
    end
  end
end

#on_newline(p) ⇒ `Object`

This hook is triggered by “main” lexer on every newline character

# File 'lib/parser/lexer-strings.rb', line 5100

def on_newline(p)
  # 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
  p
end

#pop_literal ⇒ `Object`

# File 'lib/parser/lexer-strings.rb', line 5051

def pop_literal
  old_literal = @literal_stack.pop

  @dedent_level = old_literal.dedent_level

  if old_literal.type == :tREGEXP_BEG
    @root_lexer_state = @lexer.class.lex_en_inside_string

    # Fetch modifiers.
    self.class.lex_en_regexp_modifiers
  else
    @root_lexer_state = @lexer.class.lex_en_expr_end

    # Do nothing, yield to main lexer
    nil
  end
end

#push_literal(*args) ⇒ `Object`

LITERAL STACK ===

# File 'lib/parser/lexer-strings.rb', line 5009

def push_literal(*args)
  new_literal = Parser::Lexer::Literal.new(self, *args)
  @literal_stack.push(new_literal)
  @cs = next_state_for_literal(new_literal)
end

#read_character_constant(p) ⇒ `Object`

# File 'lib/parser/lexer-strings.rb', line 4999

def read_character_constant(p)
  @cs = self.class.lex_en_character

  advance(p)
end

#reset ⇒ `Object`

# File 'lib/parser/lexer-strings.rb', line 3314

def reset
  @cs            = self.class.lex_en_unknown
  @literal_stack = []

  @escape_s      = nil # starting position of current sequence
  @escape        = nil # last escaped sequence, as string

  @herebody_s    = nil # starting position of current heredoc line

  # After encountering the closing line of <<~SQUIGGLY_HEREDOC,
  # we store the indentation level and give it out to the parser
  # on request. It is not possible to infer indentation level just
  # from the AST because escape sequences such as `\ ` or `\t` are
  # expanded inside the lexer, but count as non-whitespace for
  # indentation purposes.
  @dedent_level  = nil
end

Class: Parser::LexerStrings

Overview

Constant Summary collapse

Class Attribute Summary collapse

Instance Attribute Summary collapse

Instance Method Summary collapse

LITERAL STACK ===.

Constructor Details

#initialize(lexer, version) ⇒ LexerStrings

Class Attribute Details

._lex_actions ⇒ Object

._lex_eof_trans ⇒ Object

._lex_from_state_actions ⇒ Object

._lex_index_offsets ⇒ Object

._lex_indicies ⇒ Object

._lex_key_spans ⇒ Object

._lex_to_state_actions ⇒ Object

._lex_trans_actions ⇒ Object

._lex_trans_keys ⇒ Object

._lex_trans_targs ⇒ Object

.lex_en_character ⇒ Object

.lex_en_interp_backslash_delimited ⇒ Object

.lex_en_interp_backslash_delimited_words ⇒ Object

.lex_en_interp_string ⇒ Object

.lex_en_interp_words ⇒ Object

.lex_en_plain_backslash_delimited ⇒ Object

.lex_en_plain_backslash_delimited_words ⇒ Object

.lex_en_plain_string ⇒ Object

.lex_en_plain_words ⇒ Object

.lex_en_regexp_modifiers ⇒ Object

.lex_en_unknown ⇒ Object

.lex_error ⇒ Object

.lex_start ⇒ Object