Module: Regexp::Scanner

Defined in:: lib/regexp_parser/scanner.rb

Defined Under Namespace

Classes: PrematureEndError, ScannerError, UnknownUnicodePropertyError

Class Attribute Summary collapse

._re_scanner_eof_actions ⇒ Object

Returns the value of attribute _re_scanner_eof_actions.
._re_scanner_eof_trans ⇒ Object

Returns the value of attribute _re_scanner_eof_trans.
._re_scanner_from_state_actions ⇒ Object

Returns the value of attribute _re_scanner_from_state_actions.
._re_scanner_index_offsets ⇒ Object

Returns the value of attribute _re_scanner_index_offsets.
._re_scanner_indicies ⇒ Object

Returns the value of attribute _re_scanner_indicies.
._re_scanner_key_spans ⇒ Object

Returns the value of attribute _re_scanner_key_spans.
._re_scanner_to_state_actions ⇒ Object

Returns the value of attribute _re_scanner_to_state_actions.
._re_scanner_trans_actions ⇒ Object

Returns the value of attribute _re_scanner_trans_actions.
._re_scanner_trans_keys ⇒ Object

Returns the value of attribute _re_scanner_trans_keys.
._re_scanner_trans_targs ⇒ Object

Returns the value of attribute _re_scanner_trans_targs.
.re_scanner_en_character_set ⇒ Object

Returns the value of attribute re_scanner_en_character_set.
.re_scanner_en_escape_sequence ⇒ Object

Returns the value of attribute re_scanner_en_escape_sequence.
.re_scanner_en_main ⇒ Object

Returns the value of attribute re_scanner_en_main.
.re_scanner_en_set_escape_sequence ⇒ Object

Returns the value of attribute re_scanner_en_set_escape_sequence.
.re_scanner_en_unicode_property ⇒ Object

Returns the value of attribute re_scanner_en_unicode_property.
.re_scanner_error ⇒ Object

Returns the value of attribute re_scanner_error.
.re_scanner_first_final ⇒ Object

Returns the value of attribute re_scanner_first_final.
.re_scanner_start ⇒ Object

Returns the value of attribute re_scanner_start.

Class Method Summary collapse

.append_literal(data, ts, te) ⇒ Object

appends one or more characters to the literal buffer, to be emitted later by a call to emit_literal.
.emit(type, token, text, ts, te) ⇒ Object
.emit_literal ⇒ Object

emits the collected literal run collected by one or more calls to the append_literal method.
.scan(input, &block) ⇒ Object

Scans the given regular expression text, or Regexp object and collects the emitted token into an array that gets returned at the end.

Class Attribute Details

._re_scanner_eof_actions ⇒ `Object`

Returns the value of attribute _re_scanner_eof_actions.



1248
1249
1250

# File 'lib/regexp_parser/scanner.rb', line 1248

def _re_scanner_eof_actions
  @_re_scanner_eof_actions
end

._re_scanner_eof_trans ⇒ `Object`

Returns the value of attribute _re_scanner_eof_trans.



1279
1280
1281

# File 'lib/regexp_parser/scanner.rb', line 1279

def _re_scanner_eof_trans
  @_re_scanner_eof_trans
end

._re_scanner_from_state_actions ⇒ `Object`

Returns the value of attribute _re_scanner_from_state_actions.



1217
1218
1219

# File 'lib/regexp_parser/scanner.rb', line 1217

def _re_scanner_from_state_actions
  @_re_scanner_from_state_actions
end

._re_scanner_index_offsets ⇒ `Object`

Returns the value of attribute _re_scanner_index_offsets.



121
122
123

# File 'lib/regexp_parser/scanner.rb', line 121

def _re_scanner_index_offsets
  @_re_scanner_index_offsets
end

._re_scanner_indicies ⇒ `Object`

Returns the value of attribute _re_scanner_indicies.



152
153
154

# File 'lib/regexp_parser/scanner.rb', line 152

def _re_scanner_indicies
  @_re_scanner_indicies
end

._re_scanner_key_spans ⇒ `Object`

Returns the value of attribute _re_scanner_key_spans.



90
91
92

# File 'lib/regexp_parser/scanner.rb', line 90

def _re_scanner_key_spans
  @_re_scanner_key_spans
end

._re_scanner_to_state_actions ⇒ `Object`

Returns the value of attribute _re_scanner_to_state_actions.



1186
1187
1188

# File 'lib/regexp_parser/scanner.rb', line 1186

def _re_scanner_to_state_actions
  @_re_scanner_to_state_actions
end

._re_scanner_trans_actions ⇒ `Object`

Returns the value of attribute _re_scanner_trans_actions.



1147
1148
1149

# File 'lib/regexp_parser/scanner.rb', line 1147

def _re_scanner_trans_actions
  @_re_scanner_trans_actions
end

._re_scanner_trans_keys ⇒ `Object`

Returns the value of attribute _re_scanner_trans_keys.



12
13
14

# File 'lib/regexp_parser/scanner.rb', line 12

def _re_scanner_trans_keys
  @_re_scanner_trans_keys
end

._re_scanner_trans_targs ⇒ `Object`

Returns the value of attribute _re_scanner_trans_targs.



1108
1109
1110

# File 'lib/regexp_parser/scanner.rb', line 1108

def _re_scanner_trans_targs
  @_re_scanner_trans_targs
end

.re_scanner_en_character_set ⇒ `Object`

Returns the value of attribute re_scanner_en_character_set.



1327
1328
1329

# File 'lib/regexp_parser/scanner.rb', line 1327

def re_scanner_en_character_set
  @re_scanner_en_character_set
end

.re_scanner_en_escape_sequence ⇒ `Object`

Returns the value of attribute re_scanner_en_escape_sequence.



1335
1336
1337

# File 'lib/regexp_parser/scanner.rb', line 1335

def re_scanner_en_escape_sequence
  @re_scanner_en_escape_sequence
end

.re_scanner_en_main ⇒ `Object`

Returns the value of attribute re_scanner_en_main.



1339
1340
1341

# File 'lib/regexp_parser/scanner.rb', line 1339

def re_scanner_en_main
  @re_scanner_en_main
end

.re_scanner_en_set_escape_sequence ⇒ `Object`

Returns the value of attribute re_scanner_en_set_escape_sequence.



1331
1332
1333

# File 'lib/regexp_parser/scanner.rb', line 1331

def re_scanner_en_set_escape_sequence
  @re_scanner_en_set_escape_sequence
end

.re_scanner_en_unicode_property ⇒ `Object`

Returns the value of attribute re_scanner_en_unicode_property.



1323
1324
1325

# File 'lib/regexp_parser/scanner.rb', line 1323

def re_scanner_en_unicode_property
  @re_scanner_en_unicode_property
end

.re_scanner_error ⇒ `Object`

Returns the value of attribute re_scanner_error.



1318
1319
1320

# File 'lib/regexp_parser/scanner.rb', line 1318

def re_scanner_error
  @re_scanner_error
end

.re_scanner_first_final ⇒ `Object`

Returns the value of attribute re_scanner_first_final.



1314
1315
1316

# File 'lib/regexp_parser/scanner.rb', line 1314

def re_scanner_first_final
  @re_scanner_first_final
end

.re_scanner_start ⇒ `Object`

Returns the value of attribute re_scanner_start.



1310
1311
1312

# File 'lib/regexp_parser/scanner.rb', line 1310

def re_scanner_start
  @re_scanner_start
end

Class Method Details

.append_literal(data, ts, te) ⇒ `Object`

appends one or more characters to the literal buffer, to be emitted later by a call to emit_literal. contents a mix of ASCII and UTF-8

# File 'lib/regexp_parser/scanner.rb', line 3294

def self.append_literal(data, ts, te)
  @literal ||= []
  @literal << [data[ts..te-1].pack('c*'), ts, te]
end

.emit(type, token, text, ts, te) ⇒ `Object`

# File 'lib/regexp_parser/scanner.rb', line 3311

def self.emit(type, token, text, ts, te)
  #puts " > emit: #{type}:#{token} '#{text}' [#{ts}..#{te}]"

  if @literal and type != :literal
    self.emit_literal
  end

  if @block
    @block.call type, token, text, ts, te
  end

  @tokens << [type, token, text, ts, te]
end

.emit_literal ⇒ `Object`

emits the collected literal run collected by one or more calls to the append_literal method

# File 'lib/regexp_parser/scanner.rb', line 3301

def self.emit_literal
  ts, te = @literal.first[1], @literal.last[2]
  text = @literal.map {|t| t[0]}.join

  text.force_encoding('utf-8') if text.respond_to?(:force_encoding)

  self.emit(:literal, :literal, text, ts, te)
  @literal = nil
end

.scan(input, &block) ⇒ `Object`

Scans the given regular expression text, or Regexp object and collects the emitted token into an array that gets returned at the end. If a block is given, it gets called for each emitted token.

This method may raise errors if a syntax error is encountered.

Raises:

(PrematureEndError)

# File 'lib/regexp_parser/scanner.rb', line 1371

def self.scan(input, &block)
  top, stack = 0, []

  input = input.source if input.is_a?(Regexp)
  data  = input.unpack("c*") if input.is_a?(String)
  eof   = data.length

  @tokens = []
  @block  = block_given? ? block : nil

  in_group, group_depth = false, 0
  in_set,   set_depth, set_type   = false, 0, :set

  
# line 1386 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner.rb"
begin
	p ||= 0
	pe ||= data.length
	cs = re_scanner_start
	top = 0
	ts = nil
	te = nil
	act = 0
end

# line 666 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
  
# line 1399 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner.rb"
begin
	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
	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
	case _re_scanner_from_state_actions[cs] 
	when 29 then
# line 1 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
ts = p
end
# line 1 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
# line 1428 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner.rb"
	end
	_keys = cs << 1
	_inds = _re_scanner_index_offsets[cs]
	_slen = _re_scanner_key_spans[cs]
	_trans = if (   _slen > 0 && 
	_re_scanner_trans_keys[_keys] <= data[p] && 
	data[p] <= _re_scanner_trans_keys[_keys + 1] 
    ) then
	_re_scanner_indicies[ _inds + data[p] - _re_scanner_trans_keys[_keys] ] 
 else 
	_re_scanner_indicies[ _inds + _slen ]
 end
	end
	if _goto_level <= _eof_trans
	cs = _re_scanner_trans_targs[_trans]
	if _re_scanner_trans_actions[_trans] != 0
	case _re_scanner_trans_actions[_trans]
	when 10 then
# line 116 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 raise PrematureEndError 		end
# line 116 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 31 then
# line 119 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 group_depth += 1; in_group = true 		end
# line 119 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 4 then
# line 120 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 group_depth -= 1; in_group = group_depth > 0 ? true : false 		end
# line 120 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 14 then
# line 1 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
te = p+1
end
# line 1 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 12 then
# line 60 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
te = p+1
 begin 
    text = data[ts-1..te-1].pack('c*')
    if in_set
      type = :set
    else
      type = text[1,1] == 'p' ? :property : :nonproperty
    end

    name = data[ts+2..te-2].pack('c*').gsub(/[\s_]/,'').downcase
    if name[0].chr == '^'
      name = name[1..-1]
      type = :nonproperty
    end

    case name
    # Named
    when 'alnum'
      self.emit(type, :alnum,       text, ts-1, te)
    when 'alpha'
      self.emit(type, :alpha,       text, ts-1, te)
    when 'ascii'
      self.emit(type, :ascii,       text, ts-1, te)
    when 'blank'
      self.emit(type, :blank,       text, ts-1, te)
    when 'cntrl'
      self.emit(type, :cntrl,       text, ts-1, te)
    when 'digit'
      self.emit(type, :digit,       text, ts-1, te)
    when 'graph'
      self.emit(type, :graph,       text, ts-1, te)
    when 'lower'
      self.emit(type, :lower,       text, ts-1, te)
    when 'print'
      self.emit(type, :print,       text, ts-1, te)
    when 'punct'
      self.emit(type, :punct,       text, ts-1, te)
    when 'space'
      self.emit(type, :space,       text, ts-1, te)
    when 'upper'
      self.emit(type, :upper,       text, ts-1, te)
    when 'xdigit'
      self.emit(type, :xdigit,      text, ts-1, te)

    when 'any'
      self.emit(type, :any,         text, ts-1, te)
    when 'assigned'
      self.emit(type, :assigned,    text, ts-1, te)
    when 'newline'
      self.emit(type, :newline,     text, ts-1, te)
    when 'word'
      self.emit(type, :word,        text, ts-1, te)

    # Letters
    when 'l', 'letter'
      self.emit(type, :letter_any,       text, ts-1, te)
    when 'lu', 'uppercaseletter'
      self.emit(type, :letter_uppercase, text, ts-1, te)
    when 'll', 'lowercaseletter'
      self.emit(type, :letter_lowercase, text, ts-1, te)
    when 'lt', 'titlecaseletter'
      self.emit(type, :letter_titlecase, text, ts-1, te)
    when 'lm', 'modifierletter'
      self.emit(type, :letter_modifier,  text, ts-1, te)
    when 'lo', 'otherletter'
      self.emit(type, :letter_other,     text, ts-1, te)

    # Marks
    when 'm', 'mark'
      self.emit(type, :mark_any,         text, ts-1, te)
    when 'mn', 'nonspacingmark'
      self.emit(type, :mark_nonspacing,  text, ts-1, te)
    when 'mc', 'spacingmark'
      self.emit(type, :mark_spacing,     text, ts-1, te)
    when 'me', 'enclosingmark'
      self.emit(type, :mark_enclosing,   text, ts-1, te)

    # Numbers
    when 'n', 'number'
      self.emit(type, :number_any,       text, ts-1, te)
    when 'nd', 'decimalnumber'
      self.emit(type, :number_decimal,   text, ts-1, te)
    when 'nl', 'letternumber'
      self.emit(type, :number_letter,    text, ts-1, te)
    when 'no', 'othernumber'
      self.emit(type, :number_other,     text, ts-1, te)

    # Punctuation
    when 'p', 'punctuation'
      self.emit(type, :punct_any,        text, ts-1, te)
    when 'pc', 'connectorpunctuation'
      self.emit(type, :punct_connector,  text, ts-1, te)
    when 'pd', 'dashpunctuation'
      self.emit(type, :punct_dash,       text, ts-1, te)
    when 'ps', 'openpunctuation'
      self.emit(type, :punct_open,       text, ts-1, te)
    when 'pe', 'closepunctuation'
      self.emit(type, :punct_close,      text, ts-1, te)
    when 'pi', 'initialpunctuation'
      self.emit(type, :punct_initial,    text, ts-1, te)
    when 'pf', 'finalpunctuation'
      self.emit(type, :punct_final,      text, ts-1, te)
    when 'po', 'otherpunctuation'
      self.emit(type, :punct_other,      text, ts-1, te)

    # Symbols
    when 's', 'symbol'
      self.emit(type, :symbol_any,       text, ts-1, te)
    when 'sm', 'mathsymbol'
      self.emit(type, :symbol_math,      text, ts-1, te)
    when 'sc', 'currencysymbol'
      self.emit(type, :symbol_currency,  text, ts-1, te)
    when 'sk', 'modifiersymbol'
      self.emit(type, :symbol_modifier,  text, ts-1, te)
    when 'so', 'othersymbol'
      self.emit(type, :symbol_other,     text, ts-1, te)

    # Separators
    when 'z', 'separator'
      self.emit(type, :separator_any,    text, ts-1, te)
    when 'zs', 'spaceseparator'
      self.emit(type, :separator_space,  text, ts-1, te)
    when 'zl', 'lineseparator'
      self.emit(type, :separator_line,   text, ts-1, te)
    when 'zp', 'paragraphseparator'
      self.emit(type, :separator_para,   text, ts-1, te)

    # Codepoints
    when 'c', 'other'
      self.emit(type, :other,         text, ts-1, te)
    when 'cc', 'control'
      self.emit(type, :control,       text, ts-1, te)
    when 'cf', 'format'
      self.emit(type, :format,        text, ts-1, te)
    when 'cs', 'surrogate'
      self.emit(type, :surrogate,     text, ts-1, te)
    when 'co', 'privateuse'
      self.emit(type, :private_use,   text, ts-1, te)
    when 'cn', 'unassigned'
      self.emit(type, :unassigned,    text, ts-1, te)

    # Age
    when 'age=1.1'
      self.emit(type, :age_1_1,     text, ts-1, te)
    when 'age=2.0'
      self.emit(type, :age_2_0,     text, ts-1, te)
    when 'age=2.1'
      self.emit(type, :age_2_1,     text, ts-1, te)
    when 'age=3.0'
      self.emit(type, :age_3_0,     text, ts-1, te)
    when 'age=3.1'
      self.emit(type, :age_3_1,     text, ts-1, te)
    when 'age=3.2'
      self.emit(type, :age_3_2,     text, ts-1, te)
    when 'age=4.0'
      self.emit(type, :age_4_0,     text, ts-1, te)
    when 'age=4.1'
      self.emit(type, :age_4_1,     text, ts-1, te)
    when 'age=5.0'
      self.emit(type, :age_5_0,     text, ts-1, te)
    when 'age=5.1'
      self.emit(type, :age_5_1,     text, ts-1, te)
    when 'age=5.2'
      self.emit(type, :age_5_2,     text, ts-1, te)
    when 'age=6.0'
      self.emit(type, :age_6_0,     text, ts-1, te)

    # Derived Properties
    when 'ahex', 'asciihexdigit'
      self.emit(type, :ascii_hex,                       text, ts-1, te)
    when 'alphabetic'
      self.emit(type, :alphabetic,                      text, ts-1, te)
    when 'cased'
      self.emit(type, :cased,                           text, ts-1, te)
    when 'cwcf', 'changeswhencasefolded'
      self.emit(type, :changes_when_casefolded,         text, ts-1, te)
    when 'cwcm', 'changeswhencasemapped'
      self.emit(type, :changes_when_casemapped,         text, ts-1, te)
    when 'cwl', 'changeswhenlowercased'
      self.emit(type, :changes_when_lowercased,         text, ts-1, te)
    when 'cwt', 'changeswhentitlecased'
      self.emit(type, :changes_when_titlecased,         text, ts-1, te)
    when 'cwu', 'changeswhenuppercased'
      self.emit(type, :changes_when_uppercased,         text, ts-1, te)
    when 'ci', 'caseignorable'
      self.emit(type, :case_ignorable,                  text, ts-1, te)
    when 'bidic', 'bidicontrol'
      self.emit(type, :bidi_control,                    text, ts-1, te)
    when 'dash'
      self.emit(type, :dash,                            text, ts-1, te)
    when 'dep', 'deprecated'
      self.emit(type, :deprecated,                      text, ts-1, te)
    when 'di', 'defaultignorablecodepoint'
      self.emit(type, :default_ignorable_cp,            text, ts-1, te)
    when 'dia', 'diacritic'
      self.emit(type, :diacritic,                       text, ts-1, te)
    when 'ext', 'extender'
      self.emit(type, :extender,                        text, ts-1, te)
    when 'grbase', 'graphemebase'
      self.emit(type, :grapheme_base,                   text, ts-1, te)
    when 'grext', 'graphemeextend'
      self.emit(type, :grapheme_extend,                 text, ts-1, te)
    when 'grlink', 'graphemelink' # NOTE: deprecated as of Unicode 5.0
      self.emit(type, :grapheme_link,                   text, ts-1, te)
    when 'hex', 'hexdigit'
      self.emit(type, :hex_digit,                       text, ts-1, te)
    when 'hyphen' # NOTE: deprecated as of Unicode 6.0
      self.emit(type, :hyphen,                          text, ts-1, te)
    when 'idc', 'idcontinue'
      self.emit(type, :id_continue,                     text, ts-1, te)
    when 'ideo', 'ideographic'
      self.emit(type, :ideographic,                     text, ts-1, te)
    when 'ids', 'idstart'
      self.emit(type, :id_start,                        text, ts-1, te)
    when 'idsb', 'idsbinaryoperator'
      self.emit(type, :ids_binary_op,                   text, ts-1, te)
    when 'idst', 'idstrinaryoperator'
      self.emit(type, :ids_trinary_op,                  text, ts-1, te)
    when 'joinc', 'joincontrol'
      self.emit(type, :join_control,                    text, ts-1, te)
    when 'loe', 'logicalorderexception'
      self.emit(type, :logical_order_exception,         text, ts-1, te)
    when 'lowercase'
      self.emit(type, :lowercase,                       text, ts-1, te)
    when 'math'
      self.emit(type, :math,                            text, ts-1, te)
    when 'nchar', 'noncharactercodepoint'
      self.emit(type, :non_character_cp,                text, ts-1, te)
    when 'oalpha', 'otheralphabetic'
      self.emit(type, :other_alphabetic,                text, ts-1, te)
    when 'odi', 'otherdefaultignorablecodepoint'
      self.emit(type, :other_default_ignorable_cp,      text, ts-1, te)
    when 'ogrext', 'othergraphemeextend'
      self.emit(type, :other_grapheme_extended,         text, ts-1, te)
    when 'oidc', 'otheridcontinue'
      self.emit(type, :other_id_continue,               text, ts-1, te)
    when 'oids', 'otheridstart'
      self.emit(type, :other_id_start,                  text, ts-1, te)
    when 'olower', 'otherlowercase'
      self.emit(type, :other_lowercase,                 text, ts-1, te)
    when 'omath', 'othermath'
      self.emit(type, :other_math,                      text, ts-1, te)
    when 'oupper', 'otheruppercase'
      self.emit(type, :other_uppercase,                 text, ts-1, te)
    when 'patsyn', 'patternsyntax'
      self.emit(type, :pattern_syntax,                  text, ts-1, te)
    when 'patws', 'patternwhitespace'
      self.emit(type, :pattern_whitespace,              text, ts-1, te)
    when 'qmark', 'quotationmark'
      self.emit(type, :quotation_mark,                  text, ts-1, te)
    when 'radical'
      self.emit(type, :radical,                         text, ts-1, te)
    when 'sd', 'softdotted'
      self.emit(type, :soft_dotted,                     text, ts-1, te)
    when 'sterm'
      self.emit(type, :sentence_terminal,               text, ts-1, te)
    when 'term', 'terminalpunctuation'
      self.emit(type, :terminal_punctuation,            text, ts-1, te)
    when 'uideo', 'unifiedideograph'
      self.emit(type, :unified_ideograph,               text, ts-1, te)
    when 'uppercase'
      self.emit(type, :uppercase,                       text, ts-1, te)
    when 'vs', 'variationselector'
      self.emit(type, :variation_selector,              text, ts-1, te)
    when 'wspace', 'whitespace'
      self.emit(type, :whitespace,                      text, ts-1, te)
    when 'xids', 'xidstart'
      self.emit(type, :xid_start,                       text, ts-1, te)
    when 'xidc', 'xidcontinue'
      self.emit(type, :xid_continue,                    text, ts-1, te)


    # Scripts
    when 'arab', 'arabic'
      self.emit(type, :script_arabic,                   text, ts-1, te)
    when 'armi', 'imperialaramaic'
      self.emit(type, :script_imperial_aramaic,         text, ts-1, te)
    when 'armn', 'armenian'
      self.emit(type, :script_armenian,                 text, ts-1, te)
    when 'avst', 'avestan'
      self.emit(type, :script_avestan,                  text, ts-1, te)
    when 'bali', 'balinese'
      self.emit(type, :script_balinese,                 text, ts-1, te)
    when 'bamu', 'bamum'
      self.emit(type, :script_bamum,                    text, ts-1, te)
    when 'batk', 'batak'
      self.emit(type, :script_batak,                    text, ts-1, te)
    when 'beng', 'bengali'
      self.emit(type, :script_bengali,                  text, ts-1, te)
    when 'bopo', 'bopomofo'
      self.emit(type, :script_bopomofo,                 text, ts-1, te)
    when 'brah', 'brahmi'
      self.emit(type, :script_brahmi,                   text, ts-1, te)
    when 'brai', 'braille'
      self.emit(type, :script_braille,                  text, ts-1, te)
    when 'bugi', 'buginese'
      self.emit(type, :script_buginese,                 text, ts-1, te)
    when 'buhd', 'buhid'
      self.emit(type, :script_buhid,                    text, ts-1, te)
    when 'cans', 'canadianaboriginal'
      self.emit(type, :script_canadian_aboriginal,      text, ts-1, te)
    when 'cari', 'carian'
      self.emit(type, :script_carian,                   text, ts-1, te)
    when 'cham'
      self.emit(type, :script_cham,                     text, ts-1, te)
    when 'cher', 'cherokee'
      self.emit(type, :script_cherokee,                 text, ts-1, te)
    when 'copt', 'coptic', 'qaac'
      self.emit(type, :script_coptic,                   text, ts-1, te)
    when 'cprt', 'cypriot'
      self.emit(type, :script_cypriot,                  text, ts-1, te)
    when 'cyrl', 'cyrillic'
      self.emit(type, :script_cyrillic,                 text, ts-1, te)
    when 'deva', 'devanagari'
      self.emit(type, :script_devanagari,               text, ts-1, te)
    when 'dsrt', 'deseret'
      self.emit(type, :script_deseret,                  text, ts-1, te)
    when 'egyp', 'egyptianhieroglyphs'
      self.emit(type, :script_egyptian_hieroglyphs,     text, ts-1, te)
    when 'ethi', 'ethiopic'
      self.emit(type, :script_ethiopic,                 text, ts-1, te)
    when 'geor', 'georgian'
      self.emit(type, :script_georgian,                 text, ts-1, te)
    when 'glag', 'glagolitic'
      self.emit(type, :script_glagolitic,               text, ts-1, te)
    when 'goth', 'gothic'
      self.emit(type, :script_gothic,                   text, ts-1, te)
    when 'grek', 'greek'
      self.emit(type, :script_greek,                    text, ts-1, te)
    when 'gujr', 'gujarati'
      self.emit(type, :script_gujarati,                 text, ts-1, te)
    when 'guru', 'gurmukhi'
      self.emit(type, :script_gurmukhi,                 text, ts-1, te)
    when 'hang', 'hangul'
      self.emit(type, :script_hangul,                   text, ts-1, te)
    when 'hani', 'han'
      self.emit(type, :script_han,                      text, ts-1, te)
    when 'hano', 'hanunoo'
      self.emit(type, :script_hanunoo,                  text, ts-1, te)
    when 'hebr', 'hebrew'
      self.emit(type, :script_hebrew,                   text, ts-1, te)
    when 'hira', 'hiragana'
      self.emit(type, :script_hiragana,                 text, ts-1, te)
    when 'hrkt', 'katakanaorhiragana'
      self.emit(type, :script_katakana_or_hiragana,     text, ts-1, te)
    when 'ital', 'olditalic'
      self.emit(type, :script_old_italic,               text, ts-1, te)
    when 'java', 'javanese'
      self.emit(type, :script_javanese,                 text, ts-1, te)
    when 'kali', 'kayahli'
      self.emit(type, :script_kayah_li,                 text, ts-1, te)
    when 'kana', 'katakana'
      self.emit(type, :script_katakana,                 text, ts-1, te)
    when 'khar', 'kharoshthi'
      self.emit(type, :script_kharoshthi,               text, ts-1, te)
    when 'khmr', 'khmer'
      self.emit(type, :script_khmer,                    text, ts-1, te)
    when 'knda', 'kannada'
      self.emit(type, :script_kannada,                  text, ts-1, te)
    when 'kthi', 'kaithi'
      self.emit(type, :script_kaithi,                   text, ts-1, te)
    when 'lana', 'taitham'
      self.emit(type, :script_tai_tham,                 text, ts-1, te)
    when 'laoo', 'lao'
      self.emit(type, :script_lao,                      text, ts-1, te)
    when 'latn', 'latin'
      self.emit(type, :script_latin,                    text, ts-1, te)
    when 'lepc', 'lepcha'
      self.emit(type, :script_lepcha,                   text, ts-1, te)
    when 'limb', 'limbu'
      self.emit(type, :script_limbu,                    text, ts-1, te)
    when 'linb', 'linearb'
      self.emit(type, :script_linear_b,                 text, ts-1, te)
    when 'lisu'
      self.emit(type, :script_lisu,                     text, ts-1, te)
    when 'lyci', 'lycian'
      self.emit(type, :script_lycian,                   text, ts-1, te)
    when 'lydi', 'lydian'
      self.emit(type, :script_lydian,                   text, ts-1, te)
    when 'mlym', 'malayalam'
      self.emit(type, :script_malayalam,                text, ts-1, te)
    when 'mand', 'mandaic'
      self.emit(type, :script_mandaic,                  text, ts-1, te)
    when 'mong', 'mongolian'
      self.emit(type, :script_mongolian,                text, ts-1, te)
    when 'mtei', 'meeteimayek'
      self.emit(type, :script_meetei_mayek,             text, ts-1, te)
    when 'mymr', 'myanmar'
      self.emit(type, :script_myanmar,                  text, ts-1, te)
    when 'nkoo', 'nko'
      self.emit(type, :script_nko,                      text, ts-1, te)
    when 'ogam', 'ogham'
      self.emit(type, :script_ogham,                    text, ts-1, te)
    when 'olck', 'olchiki'
      self.emit(type, :script_ol_chiki,                 text, ts-1, te)
    when 'orkh', 'oldturkic'
      self.emit(type, :script_old_turkic,               text, ts-1, te)
    when 'orya', 'oriya'
      self.emit(type, :script_oriya,                    text, ts-1, te)
    when 'osma', 'osmanya'
      self.emit(type, :script_osmanya,                  text, ts-1, te)
    when 'phag', 'phagspa'
      self.emit(type, :script_phags_pa,                 text, ts-1, te)
    when 'phli', 'inscriptionalpahlavi'
      self.emit(type, :script_inscriptional_pahlavi,    text, ts-1, te)
    when 'phnx', 'phoenician'
      self.emit(type, :script_phoenician,               text, ts-1, te)
    when 'prti', 'inscriptionalparthian'
      self.emit(type, :script_inscriptional_parthian,   text, ts-1, te)
    when 'rjng', 'rejang'
      self.emit(type, :script_rejang,                   text, ts-1, te)
    when 'runr', 'runic'
      self.emit(type, :script_runic,                    text, ts-1, te)
    when 'samr', 'samaritan'
      self.emit(type, :script_samaritan,                text, ts-1, te)
    when 'sarb', 'oldsoutharabian'
      self.emit(type, :script_old_south_arabian,        text, ts-1, te)
    when 'saur', 'saurashtra'
      self.emit(type, :script_saurashtra,               text, ts-1, te)
    when 'shaw', 'shavian'
      self.emit(type, :script_shavian,                  text, ts-1, te)
    when 'sinh', 'sinhala'
      self.emit(type, :script_sinhala,                  text, ts-1, te)
    when 'sund', 'sundanese'
      self.emit(type, :script_sundanese,                text, ts-1, te)
    when 'sylo', 'sylotinagri'
      self.emit(type, :script_syloti_nagri,             text, ts-1, te)
    when 'syrc', 'syriac'
      self.emit(type, :script_syriac,                   text, ts-1, te)
    when 'tagb', 'tagbanwa'
      self.emit(type, :script_tagbanwa,                 text, ts-1, te)
    when 'tale', 'taile'
      self.emit(type, :script_tai_le,                   text, ts-1, te)
    when 'talu', 'newtailue'
      self.emit(type, :script_new_tai_lue,              text, ts-1, te)
    when 'taml', 'tamil'
      self.emit(type, :script_tamil,                    text, ts-1, te)
    when 'tavt', 'taiviet'
      self.emit(type, :script_tai_viet,                 text, ts-1, te)
    when 'telu', 'telugu'
      self.emit(type, :script_telugu,                   text, ts-1, te)
    when 'tfng', 'tifinagh'
      self.emit(type, :script_tifinagh,                 text, ts-1, te)
    when 'tglg', 'tagalog'
      self.emit(type, :script_tagalog,                  text, ts-1, te)
    when 'thaa', 'thaana'
      self.emit(type, :script_thaana,                   text, ts-1, te)
    when 'thai' 
      self.emit(type, :script_thai,                     text, ts-1, te)
    when 'tibt', 'tibetan'
      self.emit(type, :script_tibetan,                  text, ts-1, te)
    when 'ugar', 'ugaritic'
      self.emit(type, :script_ugaritic,                 text, ts-1, te)
    when 'vaii', 'vai'
      self.emit(type, :script_vai,                      text, ts-1, te)
    when 'xpeo', 'oldpersian'
      self.emit(type, :script_old_persian,              text, ts-1, te)
    when 'xsux', 'cuneiform'
      self.emit(type, :script_cuneiform,                text, ts-1, te)
    when 'yiii', 'yi'
      self.emit(type, :script_yi,                       text, ts-1, te)
    when 'zinh', 'inherited', 'qaai'
      self.emit(type, :script_inherited,                text, ts-1, te)
    when 'zyyy', 'common'
      self.emit(type, :script_common,                   text, ts-1, te)
    when 'zzzz', 'unknown'
      self.emit(type, :script_unknown,                  text, ts-1, te)

    else
      raise UnknownUnicodePropertyError.new(name)

    end
    	begin
top -= 1
cs = stack[top]
_goto_level = _again
next
	end

   end
end
# line 60 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 57 then
# line 126 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
te = p+1
 begin 
    set_type  = set_depth > 1 ? :subset : :set
    set_depth -= 1; in_set = set_depth > 0 ? true : false

    self.emit(set_type, :close, data[ts..te-1].pack('c*'), ts, te)

    if set_depth == 0
      	begin
cs = 142
_goto_level = _again
next
	end

    else
      	begin
top -= 1
cs = stack[top]
_goto_level = _again
next
	end

    end
   end
end
# line 126 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 61 then
# line 139 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
te = p+1
 begin  # special case, emits two tokens
    set_type  = set_depth > 1 ? :subset : :set
    set_depth -= 1; in_set = set_depth > 0 ? true : false

    self.emit(set_type, :member, data[ts..te-2].pack('c*'), ts, te)
    self.emit(set_type, :close,  data[ts+1..te-1].pack('c*'), ts, te)

    if set_depth == 0
      	begin
cs = 142
_goto_level = _again
next
	end

    else
      	begin
top -= 1
cs = stack[top]
_goto_level = _again
next
	end

    end
   end
end
# line 139 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 58 then
# line 153 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
te = p+1
 begin 
    text = data[ts..te-1].pack('c*')
    if @tokens.last[1] == :open
      self.emit(set_type, :negate, text, ts, te)
    else
      self.emit(set_type, :member, text, ts, te)
    end
   end
end
# line 153 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 15 then
# line 162 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
te = p+1
 begin 
    self.emit(set_type, :range, data[ts..te-1].pack('c*'), ts, te)
   end
end
# line 162 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 60 then
# line 166 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
te = p+1
 begin 
    self.emit(set_type, :intersection, data[ts..te-1].pack('c*'), ts, te)
   end
end
# line 166 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 56 then
# line 170 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
te = p+1
 begin 
    	begin
stack[top] = cs
top+= 1
cs = 174
_goto_level = _again
next
	end

   end
end
# line 170 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 19 then
# line 182 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
te = p+1
 begin 
    text = data[ts..te-1].pack('c*')

    class_name = text[2..-3]
    if class_name[0].chr == '^'
      class_name = "non#{class_name[1..-1]}"
    end

    token_sym = "class_#{class_name}".to_sym
    self.emit(set_type, token_sym, text, ts, te)
   end
end
# line 182 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 18 then
# line 194 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
te = p+1
 begin 
    self.emit(set_type, :collation, data[ts..te-1].pack('c*'), ts, te)
   end
end
# line 194 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 20 then
# line 198 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
te = p+1
 begin 
    self.emit(set_type, :equivalent, data[ts..te-1].pack('c*'), ts, te)
   end
end
# line 198 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 55 then
# line 204 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
te = p+1
 begin 
   self.emit(set_type, :member, data[ts..te-1].pack('c*'), ts, te)
   end
end
# line 204 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 54 then
# line 212 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
te = p+1
 begin 
    self.emit(set_type, :member, data[ts..te-1].pack('c*'), ts, te)
   end
end
# line 212 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 63 then
# line 174 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
te = p
p = p - 1; begin 
    set_depth += 1; in_set = true
    set_type  = set_depth > 1 ? :subset : :set

    self.emit(set_type, :open, data[ts..te-1].pack('c*'), ts, te)
    	begin
stack[top] = cs
top+= 1
cs = 162
_goto_level = _again
next
	end

   end
end
# line 174 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 59 then
# line 212 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
te = p
p = p - 1; begin 
    self.emit(set_type, :member, data[ts..te-1].pack('c*'), ts, te)
   end
end
# line 212 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 17 then
# line 174 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 begin p = ((te))-1; end
 begin 
    set_depth += 1; in_set = true
    set_type  = set_depth > 1 ? :subset : :set

    self.emit(set_type, :open, data[ts..te-1].pack('c*'), ts, te)
    	begin
stack[top] = cs
top+= 1
cs = 162
_goto_level = _again
next
	end

   end
end
# line 174 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 13 then
# line 212 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 begin p = ((te))-1; end
 begin 
    self.emit(set_type, :member, data[ts..te-1].pack('c*'), ts, te)
   end
end
# line 212 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 72 then
# line 239 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
te = p+1
 begin 
    self.emit(set_type, :range_hex, data[ts-1..te-1].pack('c*'), ts-1, te)
    	begin
top -= 1
cs = stack[top]
_goto_level = _again
next
	end

   end
end
# line 239 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 64 then
# line 249 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
te = p+1
 begin 
    self.emit(set_type, :escape, data[ts-1..te-1].pack('c*'), ts-1, te)
    	begin
top -= 1
cs = stack[top]
_goto_level = _again
next
	end

   end
end
# line 249 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 67 then
# line 254 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
te = p+1
 begin 
    p = p - 1;
    cs = 162;
    	begin
stack[top] = cs
top+= 1
cs = 161
_goto_level = _again
next
	end

    	begin
top -= 1
cs = stack[top]
_goto_level = _again
next
	end

   end
end
# line 254 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 71 then
# line 239 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
te = p
p = p - 1; begin 
    self.emit(set_type, :range_hex, data[ts-1..te-1].pack('c*'), ts-1, te)
    	begin
top -= 1
cs = stack[top]
_goto_level = _again
next
	end

   end
end
# line 239 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 70 then
# line 244 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
te = p
p = p - 1; begin 
    self.emit(set_type, :member_hex, data[ts-1..te-1].pack('c*'), ts-1, te)
    	begin
top -= 1
cs = stack[top]
_goto_level = _again
next
	end

   end
end
# line 244 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 69 then
# line 266 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
te = p
p = p - 1; begin 
    self.emit(set_type, :escape, data[ts-1..te-1].pack('c*'), ts-1, te)
    	begin
top -= 1
cs = stack[top]
_goto_level = _again
next
	end

   end
end
# line 266 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 23 then
# line 244 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 begin p = ((te))-1; end
 begin 
    self.emit(set_type, :member_hex, data[ts-1..te-1].pack('c*'), ts-1, te)
    	begin
top -= 1
cs = stack[top]
_goto_level = _again
next
	end

   end
end
# line 244 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 21 then
# line 1 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
	case act
	when 0 then
	begin	begin
cs = 0
_goto_level = _again
next
	end
end
	when 14 then
	begin begin p = ((te))-1; end

    self.emit(set_type, :backspace, data[ts-1..te-1].pack('c*'), ts-1, te)
    	begin
top -= 1
cs = stack[top]
_goto_level = _again
next
	end

  end
	when 15 then
	begin begin p = ((te))-1; end

    case text = data[ts-1..te-1].pack('c*')
    when '\d'; self.emit(set_type, :type_digit,     text, ts-1, te)
    when '\D'; self.emit(set_type, :type_nondigit,  text, ts-1, te)
    when '\h'; self.emit(set_type, :type_hex,       text, ts-1, te)
    when '\H'; self.emit(set_type, :type_nonhex,    text, ts-1, te)
    when '\s'; self.emit(set_type, :type_space,     text, ts-1, te)
    when '\S'; self.emit(set_type, :type_nonspace,  text, ts-1, te)
    when '\w'; self.emit(set_type, :type_word,      text, ts-1, te)
    when '\W'; self.emit(set_type, :type_nonword,   text, ts-1, te)
    end
    	begin
top -= 1
cs = stack[top]
_goto_level = _again
next
	end

  end
	when 18 then
	begin begin p = ((te))-1; end

    self.emit(set_type, :escape, data[ts-1..te-1].pack('c*'), ts-1, te)
    	begin
top -= 1
cs = stack[top]
_goto_level = _again
next
	end

  end
	when 20 then
	begin begin p = ((te))-1; end

    self.emit(set_type, :escape, data[ts-1..te-1].pack('c*'), ts-1, te)
    	begin
top -= 1
cs = stack[top]
_goto_level = _again
next
	end

  end
end 
	end
# line 1 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 77 then
# line 276 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
te = p+1
 begin 
    text = data[ts-1..te-1].pack('c*')
    self.emit(:backref, :number, text, ts-1, te)
    	begin
top -= 1
cs = stack[top]
_goto_level = _again
next
	end

   end
end
# line 276 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 82 then
# line 282 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
te = p+1
 begin 
    self.emit(:escape, :octal, data[ts-1..te-1].pack('c*'), ts-1, te)
    	begin
top -= 1
cs = stack[top]
_goto_level = _again
next
	end

   end
end
# line 282 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 74 then
# line 287 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
te = p+1
 begin 
    case text = data[ts-1..te-1].pack('c*')
    when '\.';  self.emit(:escape, :dot,               text, ts-1, te)
    when '\|';  self.emit(:escape, :alternation,       text, ts-1, te)
    when '\^';  self.emit(:escape, :beginning_of_line, text, ts-1, te)
    when '\$';  self.emit(:escape, :end_of_line,       text, ts-1, te)
    when '\?';  self.emit(:escape, :zero_or_one,       text, ts-1, te)
    when '\*';  self.emit(:escape, :zero_or_more,      text, ts-1, te)
    when '\+';  self.emit(:escape, :one_or_more,       text, ts-1, te)
    when '\(';  self.emit(:escape, :group_open,        text, ts-1, te)
    when '\)';  self.emit(:escape, :group_close,       text, ts-1, te)
    when '\{';  self.emit(:escape, :interval_open,     text, ts-1, te)
    when '\}';  self.emit(:escape, :interval_close,    text, ts-1, te)
    when '\[';  self.emit(:escape, :set_open,          text, ts-1, te)
    when '\]';  self.emit(:escape, :set_close,         text, ts-1, te)
    when "\\\\";
      self.emit(:escape, :backslash, text, ts-1, te)
    end
    	begin
top -= 1
cs = stack[top]
_goto_level = _again
next
	end

   end
end
# line 287 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 79 then
# line 308 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
te = p+1
 begin 
    # \b is emitted as backspace only when inside a character set, otherwise
    # it is a word boundary anchor. A syntax might "normalize" it if needed.
    case text = data[ts-1..te-1].pack('c*')
    when '\a'; self.emit(:escape, :bell,           text, ts-1, te)
    when '\e'; self.emit(:escape, :escape,         text, ts-1, te)
    when '\f'; self.emit(:escape, :form_feed,      text, ts-1, te)
    when '\n'; self.emit(:escape, :newline,        text, ts-1, te)
    when '\r'; self.emit(:escape, :carriage,       text, ts-1, te)
    when '\s'; self.emit(:escape, :space,          text, ts-1, te)
    when '\t'; self.emit(:escape, :tab,            text, ts-1, te)
    when '\v'; self.emit(:escape, :vertical_tab,   text, ts-1, te)
    end
    	begin
top -= 1
cs = stack[top]
_goto_level = _again
next
	end

   end
end
# line 308 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 26 then
# line 324 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
te = p+1
 begin 
    text = data[ts-1..te-1].pack('c*')
    if text[2].chr == '{'
      self.emit(:escape, :codepoint_list, text, ts-1, te)
    else
      self.emit(:escape, :codepoint,      text, ts-1, te)
    end
    	begin
top -= 1
cs = stack[top]
_goto_level = _again
next
	end

   end
end
# line 324 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 84 then
# line 334 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
te = p+1
 begin 
    self.emit(:escape, :hex, data[ts-1..te-1].pack('c*'), ts-1, te)
    	begin
top -= 1
cs = stack[top]
_goto_level = _again
next
	end

   end
end
# line 334 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 27 then
# line 339 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
te = p+1
 begin 
    self.emit(:escape, :hex_wide, data[ts-1..te-1].pack('c*'), ts-1, te)
    	begin
top -= 1
cs = stack[top]
_goto_level = _again
next
	end

   end
end
# line 339 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 24 then
# line 344 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
te = p+1
 begin 
    self.emit(:escape, :control, data[ts-1..te-1].pack('c*'), ts-1, te)
    	begin
top -= 1
cs = stack[top]
_goto_level = _again
next
	end

   end
end
# line 344 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 25 then
# line 349 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
te = p+1
 begin 
    self.emit(:escape, :meta_sequence, data[ts-1..te-1].pack('c*'), ts-1, te)
   end
end
# line 349 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 78 then
# line 353 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
te = p+1
 begin 
    p = p - 1;
    cs = 142;
    	begin
stack[top] = cs
top+= 1
cs = 161
_goto_level = _again
next
	end
begin
top -= 1
cs = stack[top]
_goto_level = _again
next
	end

   end
end
# line 353 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 73 then
# line 359 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
te = p+1
 begin 
    self.emit(:escape, :literal, data[ts-1..te-1].pack('c*'), ts-1, te)
    	begin
top -= 1
cs = stack[top]
_goto_level = _again
next
	end

   end
end
# line 359 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 81 then
# line 282 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
te = p
p = p - 1; begin 
    self.emit(:escape, :octal, data[ts-1..te-1].pack('c*'), ts-1, te)
    	begin
top -= 1
cs = stack[top]
_goto_level = _again
next
	end

   end
end
# line 282 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 83 then
# line 334 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
te = p
p = p - 1; begin 
    self.emit(:escape, :hex, data[ts-1..te-1].pack('c*'), ts-1, te)
    	begin
top -= 1
cs = stack[top]
_goto_level = _again
next
	end

   end
end
# line 334 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 80 then
# line 1 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
	case act
	when 21 then
	begin begin p = ((te))-1; end

    text = data[ts-1..te-1].pack('c*')
    self.emit(:backref, :number, text, ts-1, te)
    	begin
top -= 1
cs = stack[top]
_goto_level = _again
next
	end

  end
	when 22 then
	begin begin p = ((te))-1; end

    self.emit(:escape, :octal, data[ts-1..te-1].pack('c*'), ts-1, te)
    	begin
top -= 1
cs = stack[top]
_goto_level = _again
next
	end

  end
end 
	end
# line 1 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 33 then
# line 372 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
te = p+1
 begin 
    self.emit(:meta, :dot, data[ts..te-1].pack('c*'), ts, te)
   end
end
# line 372 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 36 then
# line 376 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
te = p+1
 begin 
    self.emit(:meta, :alternation, data[ts..te-1].pack('c*'), ts, te)
   end
end
# line 376 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 35 then
# line 382 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
te = p+1
 begin 
    self.emit(:anchor, :beginning_of_line, data[ts..te-1].pack('c*'), ts, te)
   end
end
# line 382 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 30 then
# line 386 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
te = p+1
 begin 
    self.emit(:anchor, :end_of_line, data[ts..te-1].pack('c*'), ts, te)
   end
end
# line 386 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 49 then
# line 390 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
te = p+1
 begin 
    case text = data[ts..te-1].pack('c*')
    when '\\A'; self.emit(:anchor, :bos,                text, ts, te)
    when '\\z'; self.emit(:anchor, :eos,                text, ts, te)
    when '\\Z'; self.emit(:anchor, :eos_ob_eol,         text, ts, te)
    when '\\b'; self.emit(:anchor, :word_boundary,      text, ts, te)
    when '\\B'; self.emit(:anchor, :nonword_boundary,   text, ts, te)
    when '\\G'; self.emit(:anchor, :match_start,        text, ts, te)
    else raise ScannerError.new("Unsupported anchor at #{text} (char #{ts})")
    end
   end
end
# line 390 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 50 then
# line 408 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
te = p+1
 begin 
    case text = data[ts..te-1].pack('c*')
    when '\\d'; self.emit(:type, :digit,      text, ts, te)
    when '\\D'; self.emit(:type, :nondigit,   text, ts, te)
    when '\\h'; self.emit(:type, :hex,        text, ts, te)
    when '\\H'; self.emit(:type, :nonhex,     text, ts, te)
    when '\\s'; self.emit(:type, :space,      text, ts, te)
    when '\\S'; self.emit(:type, :nonspace,   text, ts, te)
    when '\\w'; self.emit(:type, :word,       text, ts, te)
    when '\\W'; self.emit(:type, :nonword,    text, ts, te)
    end
   end
end
# line 408 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 34 then
# line 424 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
te = p+1
 begin 
    set_depth += 1; in_set = true
    set_type  = set_depth > 1 ? :subset : :set

    self.emit(set_type, :open, data[ts..te-1].pack('c*'), ts, te)
    	begin
stack[top] = cs
top+= 1
cs = 162
_goto_level = _again
next
	end

   end
end
# line 424 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 41 then
# line 449 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
te = p+1
 begin 
    # special handling to resolve ambiguity with passive groups
    if data[te]
      c = data[te].chr
      if c == ':' # include the ':'
        self.emit(:group, :options, data[ts..te].pack('c*'), ts, te+1)
        p += 1
      elsif c == ')' # just options by themselves
        self.emit(:group, :options, data[ts..te-1].pack('c*'), ts, te)
      else
        raise ScannerError.new(
          "Unexpected '#{c}' in options sequence, ':' or ')' expected")
      end
    else
      raise PrematureEndError.new("options") unless data[te]
    end
   end
end
# line 449 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 7 then
# line 473 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
te = p+1
 begin 
    case text =  data[ts..te-1].pack('c*')
    when '(?=';  self.emit(:assertion, :lookahead,    text, ts, te)
    when '(?!';  self.emit(:assertion, :nlookahead,   text, ts, te)
    when '(?<='; self.emit(:assertion, :lookbehind,   text, ts, te)
    when '(?<!'; self.emit(:assertion, :nlookbehind,  text, ts, te)
    end
   end
end
# line 473 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 6 then
# line 489 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
te = p+1
 begin 
    case text =  data[ts..te-1].pack('c*')
    when '(?:';  self.emit(:group, :passive,      text, ts, te)
    when '(?>';  self.emit(:group, :atomic,       text, ts, te)

    when /\(\?<\w+>/
      self.emit(:group, :named_ab,  text, ts, te)
    when /\(\?'\w+'/
      self.emit(:group, :named_sq,  text, ts, te)
    end
   end
end
# line 489 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 9 then
# line 513 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
te = p+1
 begin 
    case text = data[ts..te-1].pack('c*')
    when /\\([gk])<[^\d-](\w+)?>/ # angle-brackets
      if $1 == 'k'
        self.emit(:backref, :name_ref_ab,  text, ts, te)
      else
        self.emit(:backref, :name_call_ab,  text, ts, te)
      end

    when /\\([gk])'[^\d-](\w+)?'/ #single quotes
      if $1 == 'k'
        self.emit(:backref, :name_ref_sq,  text, ts, te)
      else
        self.emit(:backref, :name_call_sq,  text, ts, te)
      end

    when /\\([gk])<\d+>/ # angle-brackets
      if $1 == 'k'
        self.emit(:backref, :number_ref_ab,  text, ts, te)
      else
        self.emit(:backref, :number_call_ab,  text, ts, te)
      end

    when /\\([gk])'\d+'/ # single quotes
      if $1 == 'k'
        self.emit(:backref, :number_ref_sq,  text, ts, te)
      else
        self.emit(:backref, :number_call_sq,  text, ts, te)
      end

    when /\\([gk])<-\d+>/ # angle-brackets
      if $1 == 'k'
        self.emit(:backref, :number_rel_ref_ab,  text, ts, te)
      else
        self.emit(:backref, :number_rel_call_ab,  text, ts, te)
      end

    when /\\([gk])'-\d+'/ # single quotes
      if $1 == 'k'
        self.emit(:backref, :number_rel_ref_sq,  text, ts, te)
      else
        self.emit(:backref, :number_rel_call_sq,  text, ts, te)
      end

    when /\\k<[^\d-](\w+)?[+\-]\d+>/ # angle-brackets
      self.emit(:backref, :name_nest_ref_ab,  text, ts, te)

    when /\\k'[^\d-](\w+)?[+\-]\d+'/ # single-quotes
      self.emit(:backref, :name_nest_ref_sq,  text, ts, te)

    when /\\([gk])<\d+[+\-]\d+>/ # angle-brackets
      self.emit(:backref, :number_nest_ref_ab,  text, ts, te)

    when /\\([gk])'\d+[+\-]\d+'/ # single-quotes
      self.emit(:backref, :number_nest_ref_sq,  text, ts, te)

    end
   end
end
# line 513 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 47 then
# line 575 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
te = p+1
 begin 
    case text =  data[ts..te-1].pack('c*')
    when '?' ;  self.emit(:quantifier, :zero_or_one,            text, ts, te)
    when '??';  self.emit(:quantifier, :zero_or_one_reluctant,  text, ts, te)
    when '?+';  self.emit(:quantifier, :zero_or_one_possessive, text, ts, te)
    end
   end
end
# line 575 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 43 then
# line 583 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
te = p+1
 begin 
    case text =  data[ts..te-1].pack('c*')
    when '*' ;  self.emit(:quantifier, :zero_or_more,            text, ts, te)
    when '*?';  self.emit(:quantifier, :zero_or_more_reluctant,  text, ts, te)
    when '*+';  self.emit(:quantifier, :zero_or_more_possessive, text, ts, te)
    end
   end
end
# line 583 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 45 then
# line 591 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
te = p+1
 begin 
    case text =  data[ts..te-1].pack('c*')
    when '+' ;  self.emit(:quantifier, :one_or_more,            text, ts, te)
    when '+?';  self.emit(:quantifier, :one_or_more_reluctant,  text, ts, te)
    when '++';  self.emit(:quantifier, :one_or_more_possessive, text, ts, te)
    end
   end
end
# line 591 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 52 then
# line 599 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
te = p+1
 begin 
    self.emit(:quantifier, :interval, data[ts..te-1].pack('c*'), ts, te)
   end
end
# line 599 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 40 then
# line 449 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
te = p
p = p - 1; begin 
    # special handling to resolve ambiguity with passive groups
    if data[te]
      c = data[te].chr
      if c == ':' # include the ':'
        self.emit(:group, :options, data[ts..te].pack('c*'), ts, te+1)
        p += 1
      elsif c == ')' # just options by themselves
        self.emit(:group, :options, data[ts..te-1].pack('c*'), ts, te)
      else
        raise ScannerError.new(
          "Unexpected '#{c}' in options sequence, ':' or ')' expected")
      end
    else
      raise PrematureEndError.new("options") unless data[te]
    end
   end
end
# line 449 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 38 then
# line 501 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
te = p
p = p - 1; begin 
    text =  data[ts..te-1].pack('c*')
    self.emit(:group, :capture, text, ts, te)
   end
end
# line 501 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 46 then
# line 575 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
te = p
p = p - 1; begin 
    case text =  data[ts..te-1].pack('c*')
    when '?' ;  self.emit(:quantifier, :zero_or_one,            text, ts, te)
    when '??';  self.emit(:quantifier, :zero_or_one_reluctant,  text, ts, te)
    when '?+';  self.emit(:quantifier, :zero_or_one_possessive, text, ts, te)
    end
   end
end
# line 575 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 42 then
# line 583 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
te = p
p = p - 1; begin 
    case text =  data[ts..te-1].pack('c*')
    when '*' ;  self.emit(:quantifier, :zero_or_more,            text, ts, te)
    when '*?';  self.emit(:quantifier, :zero_or_more_reluctant,  text, ts, te)
    when '*+';  self.emit(:quantifier, :zero_or_more_possessive, text, ts, te)
    end
   end
end
# line 583 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 44 then
# line 591 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
te = p
p = p - 1; begin 
    case text =  data[ts..te-1].pack('c*')
    when '+' ;  self.emit(:quantifier, :one_or_more,            text, ts, te)
    when '+?';  self.emit(:quantifier, :one_or_more_reluctant,  text, ts, te)
    when '++';  self.emit(:quantifier, :one_or_more_possessive, text, ts, te)
    end
   end
end
# line 591 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 51 then
# line 599 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
te = p
p = p - 1; begin 
    self.emit(:quantifier, :interval, data[ts..te-1].pack('c*'), ts, te)
   end
end
# line 599 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 48 then
# line 605 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
te = p
p = p - 1; begin 
    	begin
stack[top] = cs
top+= 1
cs = 184
_goto_level = _again
next
	end

   end
end
# line 605 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 37 then
# line 616 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
te = p
p = p - 1; begin 
    self.append_literal(data, ts, te)
   end
end
# line 616 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 3 then
# line 449 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 begin p = ((te))-1; end
 begin 
    # special handling to resolve ambiguity with passive groups
    if data[te]
      c = data[te].chr
      if c == ':' # include the ':'
        self.emit(:group, :options, data[ts..te].pack('c*'), ts, te+1)
        p += 1
      elsif c == ')' # just options by themselves
        self.emit(:group, :options, data[ts..te-1].pack('c*'), ts, te)
      else
        raise ScannerError.new(
          "Unexpected '#{c}' in options sequence, ':' or ')' expected")
      end
    else
      raise PrematureEndError.new("options") unless data[te]
    end
   end
end
# line 449 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 8 then
# line 605 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 begin p = ((te))-1; end
 begin 
    	begin
stack[top] = cs
top+= 1
cs = 184
_goto_level = _again
next
	end

   end
end
# line 605 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 1 then
# line 1 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
	case act
	when 0 then
	begin	begin
cs = 0
_goto_level = _again
next
	end
end
	when 51 then
	begin begin p = ((te))-1; end

    self.append_literal(data, ts, te)
  end
end 
	end
# line 1 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 62 then
# line 116 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 raise PrematureEndError 		end
# line 116 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
# line 174 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
te = p
p = p - 1; begin 
    set_depth += 1; in_set = true
    set_type  = set_depth > 1 ? :subset : :set

    self.emit(set_type, :open, data[ts..te-1].pack('c*'), ts, te)
    	begin
stack[top] = cs
top+= 1
cs = 162
_goto_level = _again
next
	end

   end
end
# line 174 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 16 then
# line 116 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 raise PrematureEndError 		end
# line 116 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
# line 174 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 begin p = ((te))-1; end
 begin 
    set_depth += 1; in_set = true
    set_type  = set_depth > 1 ? :subset : :set

    self.emit(set_type, :open, data[ts..te-1].pack('c*'), ts, te)
    	begin
stack[top] = cs
top+= 1
cs = 162
_goto_level = _again
next
	end

   end
end
# line 174 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 5 then
# line 120 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 group_depth -= 1; in_group = group_depth > 0 ? true : false 		end
# line 120 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
# line 437 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
te = p+1
 begin 
    self.emit(:group, :comment, data[ts..te-1].pack('c*'), ts, te)
   end
end
# line 437 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 32 then
# line 120 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 group_depth -= 1; in_group = group_depth > 0 ? true : false 		end
# line 120 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
# line 506 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
te = p+1
 begin 
    self.emit(:group, :close, data[ts..te-1].pack('c*'), ts, te)
   end
end
# line 506 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 68 then
# line 1 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
te = p+1
end
# line 1 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
# line 220 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
act = 14;		end
# line 220 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 66 then
# line 1 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
te = p+1
end
# line 1 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
# line 225 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
act = 15;		end
# line 225 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 65 then
# line 1 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
te = p+1
end
# line 1 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
# line 249 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
act = 18;		end
# line 249 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 22 then
# line 1 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
te = p+1
end
# line 1 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
# line 266 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
act = 20;		end
# line 266 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 76 then
# line 1 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
te = p+1
end
# line 1 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
# line 276 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
act = 21;		end
# line 276 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 75 then
# line 1 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
te = p+1
end
# line 1 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
# line 282 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
act = 22;		end
# line 282 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 2 then
# line 1 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
te = p+1
end
# line 1 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
# line 616 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
act = 51;		end
# line 616 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 39 then
# line 1 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
te = p+1
end
# line 1 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
# line 120 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 group_depth -= 1; in_group = group_depth > 0 ? true : false 		end
# line 120 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
# line 119 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 group_depth += 1; in_group = true 		end
# line 119 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
# line 3215 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner.rb"
	end
	end
	end
	if _goto_level <= _again
	case _re_scanner_to_state_actions[cs] 
	when 53 then
# line 1 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
ts = nil;		end
# line 1 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 28 then
# line 1 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
ts = nil;		end
# line 1 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
# line 1 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
act = 0
end
# line 1 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
# line 3236 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner.rb"
	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 _re_scanner_eof_trans[cs] > 0
_trans = _re_scanner_eof_trans[cs] - 1;
_goto_level = _eof_trans
next;
	end
 case _re_scanner_eof_actions[cs]
	when 11 then
# line 52 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin

  raise PrematureEndError.new('unicode property')
		end
# line 52 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
	when 10 then
# line 116 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 raise PrematureEndError 		end
# line 116 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
# line 3269 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner.rb"
 end
	end

	end
	if _goto_level <= _out
break
	end
end
	end

# line 667 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"

  raise PrematureEndError.new("(missing group closing paranthesis) "+
        "[#{in_group}:#{group_depth}]") if in_group
  raise PrematureEndError.new("(missing set closing bracket) "+
        "[#{in_set}:#{set_depth}]") if in_set

  # when the entire expression is a literal run
  self.emit_literal if @literal

  @tokens
end

Module: Regexp::Scanner

Defined Under Namespace

Class Attribute Summary collapse

Class Method Summary collapse

Class Attribute Details

._re_scanner_eof_actions ⇒ Object

._re_scanner_eof_trans ⇒ Object

._re_scanner_from_state_actions ⇒ Object

._re_scanner_index_offsets ⇒ Object

._re_scanner_indicies ⇒ Object

._re_scanner_key_spans ⇒ Object

._re_scanner_to_state_actions ⇒ Object

._re_scanner_trans_actions ⇒ Object

._re_scanner_trans_keys ⇒ Object

._re_scanner_trans_targs ⇒ Object

.re_scanner_en_character_set ⇒ Object

.re_scanner_en_escape_sequence ⇒ Object

.re_scanner_en_main ⇒ Object

.re_scanner_en_set_escape_sequence ⇒ Object

.re_scanner_en_unicode_property ⇒ Object

.re_scanner_error ⇒ Object

.re_scanner_first_final ⇒ Object

.re_scanner_start ⇒ Object