module Regexp::Scanner

def self.append_literal(data, ts, te)

by a call to emit_literal. contents a mix of ASCII and UTF-8
appends one or more characters to the literal buffer, to be emitted later
def self.append_literal(data, ts, te)
  @literal ||= []
  @literal << [data[ts..te-1].pack('c*'), ts, te]
end

def self.emit(type, token, text, ts, te)

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

def self.emit_literal

append_literal method
emits the collected literal run collected by one or more calls to the
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

def self.scan(input, &block)

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

given, it gets called for each emitted token.
emitted token into an array that gets returned at the end. If a block is
Scans the given regular expression text, or Regexp object and collects the
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"
gin
 ||= 0
e ||= data.length
s = re_scanner_start
op = 0
s = nil
e = nil
ct = 0
d
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"
gin
estEof = false
slen, _trans, _keys, _inds, _acts, _nacts = nil
goto_level = 0
resume = 10
eof_trans = 15
again = 20
test_eof = 30
out = 40
hile true
f _goto_level <= 0
f p == pe
_goto_level = _test_eof
next
nd
f cs == 0
_goto_level = _out
next
nd
nd
f _goto_level <= _resume
ase _re_scanner_from_state_actions[cs] 
hen 29 then
line 1 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 = 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"
nd
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
nd
f _goto_level <= _eof_trans
s = _re_scanner_trans_targs[_trans]
f _re_scanner_trans_actions[_trans] != 0
ase _re_scanner_trans_actions[_trans]
hen 10 then
line 116 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
aise PrematureEndError 		end
line 116 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
hen 31 then
line 119 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
roup_depth += 1; in_group = true 		end
line 119 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
hen 4 then
line 120 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
roup_depth -= 1; in_group = group_depth > 0 ? true : false 		end
line 120 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
hen 14 then
line 1 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 = p+1
end
line 1 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
hen 12 then
line 60 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 = p+1
egin 
    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
nd
   end
end
line 60 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
hen 57 then
line 126 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 = p+1
egin 
    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
nd
    else
      	begin
top -= 1
cs = stack[top]
_goto_level = _again
next
nd
    end
   end
end
line 126 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
hen 61 then
line 139 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 = p+1
egin  # 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
nd
    else
      	begin
top -= 1
cs = stack[top]
_goto_level = _again
next
nd
    end
   end
end
line 139 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
hen 58 then
line 153 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 = p+1
egin 
    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"
hen 15 then
line 162 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 = p+1
egin 
    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"
hen 60 then
line 166 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 = p+1
egin 
    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"
hen 56 then
line 170 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 = p+1
egin 
    	begin
stack[top] = cs
top+= 1
cs = 174
_goto_level = _again
next
nd
   end
end
line 170 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
hen 19 then
line 182 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 = p+1
egin 
    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"
hen 18 then
line 194 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 = p+1
egin 
    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"
hen 20 then
line 198 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 = p+1
egin 
    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"
hen 55 then
line 204 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 = p+1
egin 
   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"
hen 54 then
line 212 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 = p+1
egin 
    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"
hen 63 then
line 174 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 = 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
nd
   end
end
line 174 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
hen 59 then
line 212 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 = 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"
hen 17 then
line 174 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
egin p = ((te))-1; end
egin 
    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
nd
   end
end
line 174 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
hen 13 then
line 212 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
egin p = ((te))-1; end
egin 
    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"
hen 72 then
line 239 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 = p+1
egin 
    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
nd
   end
end
line 239 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
hen 64 then
line 249 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 = p+1
egin 
    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
nd
   end
end
line 249 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
hen 67 then
line 254 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 = p+1
egin 
    p = p - 1;
    cs = 162;
    	begin
stack[top] = cs
top+= 1
cs = 161
_goto_level = _again
next
nd
    	begin
top -= 1
cs = stack[top]
_goto_level = _again
next
nd
   end
end
line 254 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
hen 71 then
line 239 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 = 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
nd
   end
end
line 239 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
hen 70 then
line 244 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 = 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
nd
   end
end
line 244 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
hen 69 then
line 266 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 = 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
nd
   end
end
line 266 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
hen 23 then
line 244 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
egin p = ((te))-1; end
egin 
    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
nd
   end
end
line 244 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
hen 21 then
line 1 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
ase act
hen 0 then
egin	begin
cs = 0
_goto_level = _again
next
nd
d
hen 14 then
egin 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
nd
  end
hen 15 then
egin 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
nd
  end
hen 18 then
egin 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
nd
  end
hen 20 then
egin 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
nd
  end
d 
	end
line 1 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
hen 77 then
line 276 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 = p+1
egin 
    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
nd
   end
end
line 276 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
hen 82 then
line 282 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 = p+1
egin 
    self.emit(:escape, :octal, data[ts-1..te-1].pack('c*'), ts-1, te)
    	begin
top -= 1
cs = stack[top]
_goto_level = _again
next
nd
   end
end
line 282 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
hen 74 then
line 287 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 = p+1
egin 
    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
nd
   end
end
line 287 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
hen 79 then
line 308 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 = p+1
egin 
    # \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
nd
   end
end
line 308 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
hen 26 then
line 324 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 = p+1
egin 
    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
nd
   end
end
line 324 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
hen 84 then
line 334 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 = p+1
egin 
    self.emit(:escape, :hex, data[ts-1..te-1].pack('c*'), ts-1, te)
    	begin
top -= 1
cs = stack[top]
_goto_level = _again
next
nd
   end
end
line 334 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
hen 27 then
line 339 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 = p+1
egin 
    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
nd
   end
end
line 339 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
hen 24 then
line 344 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 = p+1
egin 
    self.emit(:escape, :control, data[ts-1..te-1].pack('c*'), ts-1, te)
    	begin
top -= 1
cs = stack[top]
_goto_level = _again
next
nd
   end
end
line 344 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
hen 25 then
line 349 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 = p+1
egin 
    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"
hen 78 then
line 353 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 = p+1
egin 
    p = p - 1;
    cs = 142;
    	begin
stack[top] = cs
top+= 1
cs = 161
_goto_level = _again
next
nd
begin
top -= 1
cs = stack[top]
_goto_level = _again
next
nd
   end
end
line 353 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
hen 73 then
line 359 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 = p+1
egin 
    self.emit(:escape, :literal, data[ts-1..te-1].pack('c*'), ts-1, te)
    	begin
top -= 1
cs = stack[top]
_goto_level = _again
next
nd
   end
end
line 359 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
hen 81 then
line 282 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 = 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
nd
   end
end
line 282 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
hen 83 then
line 334 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 = 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
nd
   end
end
line 334 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
hen 80 then
line 1 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
ase act
hen 21 then
egin 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
nd
  end
hen 22 then
egin 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
nd
  end
d 
	end
line 1 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
hen 33 then
line 372 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 = p+1
egin 
    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"
hen 36 then
line 376 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 = p+1
egin 
    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"
hen 35 then
line 382 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 = p+1
egin 
    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"
hen 30 then
line 386 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 = p+1
egin 
    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"
hen 49 then
line 390 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 = p+1
egin 
    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"
hen 50 then
line 408 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 = p+1
egin 
    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"
hen 34 then
line 424 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 = p+1
egin 
    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
nd
   end
end
line 424 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
hen 41 then
line 449 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 = p+1
egin 
    # 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"
hen 7 then
line 473 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 = p+1
egin 
    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"
hen 6 then
line 489 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 = p+1
egin 
    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"
hen 9 then
line 513 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 = p+1
egin 
    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"
hen 47 then
line 575 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 = p+1
egin 
    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"
hen 43 then
line 583 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 = p+1
egin 
    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"
hen 45 then
line 591 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 = p+1
egin 
    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"
hen 52 then
line 599 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 = p+1
egin 
    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"
hen 40 then
line 449 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 = 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"
hen 38 then
line 501 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 = 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"
hen 46 then
line 575 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 = 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"
hen 42 then
line 583 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 = 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"
hen 44 then
line 591 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 = 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"
hen 51 then
line 599 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 = 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"
hen 48 then
line 605 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 = p
= p - 1; begin 
    	begin
stack[top] = cs
top+= 1
cs = 184
_goto_level = _again
next
nd
   end
end
line 605 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
hen 37 then
line 616 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 = 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"
hen 3 then
line 449 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
egin p = ((te))-1; end
egin 
    # 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"
hen 8 then
line 605 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
egin p = ((te))-1; end
egin 
    	begin
stack[top] = cs
top+= 1
cs = 184
_goto_level = _again
next
nd
   end
end
line 605 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
hen 1 then
line 1 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
ase act
hen 0 then
egin	begin
cs = 0
_goto_level = _again
next
nd
d
hen 51 then
egin begin p = ((te))-1; end
    self.append_literal(data, ts, te)
  end
d 
	end
line 1 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
hen 62 then
line 116 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
aise 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
 = 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
nd
   end
end
line 174 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
hen 16 then
line 116 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
aise 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
egin p = ((te))-1; end
egin 
    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
nd
   end
end
line 174 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
hen 5 then
line 120 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
roup_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
 = p+1
egin 
    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"
hen 32 then
line 120 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
roup_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
 = p+1
egin 
    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"
hen 68 then
line 1 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 = 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
t = 14;		end
line 220 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
hen 66 then
line 1 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 = 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
t = 15;		end
line 225 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
hen 65 then
line 1 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 = 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
t = 18;		end
line 249 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
hen 22 then
line 1 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 = 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
t = 20;		end
line 266 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
hen 76 then
line 1 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 = 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
t = 21;		end
line 276 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
hen 75 then
line 1 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 = 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
t = 22;		end
line 282 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
hen 2 then
line 1 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 = 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
t = 51;		end
line 616 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
hen 39 then
line 1 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 = 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
roup_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
roup_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"
nd
nd
nd
f _goto_level <= _again
ase _re_scanner_to_state_actions[cs] 
hen 53 then
line 1 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 = nil;		end
line 1 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
hen 28 then
line 1 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
 = 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
t = 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"
nd
f cs == 0
_goto_level = _out
next
nd
 += 1
f p != pe
_goto_level = _resume
next
nd
nd
f _goto_level <= _test_eof
f p == eof
f _re_scanner_eof_trans[cs] > 0
_trans = _re_scanner_eof_trans[cs] - 1;
_goto_level = _eof_trans
next;
nd
 case _re_scanner_eof_actions[cs]
hen 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"
hen 10 then
line 116 "/ama/src/ruby/regexp_parser/lib/regexp_parser/scanner/scanner.rl"
begin
aise 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
nd
nd
f _goto_level <= _out
break
nd
d
nd
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