review-peg 0.1.3 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0dc696d5bf81d76955a754d7f7e8b1c1f6160199
-  data.tar.gz: 550ffcce6822a8f998baaf33f33de445f17c9bec
+  metadata.gz: 02a8314cbab450277e8afa8b82587710657765c4
+  data.tar.gz: 2a1eb42ee5b296e430b1c8a4f24ca5aee7daa592
 SHA512:
-  metadata.gz: 00a1e008047bf22ef4565a33a9b95f6aa2ef218940dd08a47b5fadba5a2d86f52f52ca4c8bae6a75829350153e2d67ce84d6843fbf76d2045d16de61e148755d
-  data.tar.gz: 0438df61b57a4a90ffaed53009093ff9922a9d471e88a6bbe0f5bc8bf8cd1b2cae3095ca4a84a90cc68ab170ae955d2876c8822af794a20dfc76ffd1f5f1bc2f
+  metadata.gz: 5c9daa8c4e7649c01b8fd4579f1b894ad140ee6c6adba721c063cd4633bf3190e2f85bc0eed84aad79a9d1a1b28fd28e27f86a057099f9cbe6d9506dc21ac6ea
+  data.tar.gz: a94b8dcae6985bdef5bfc5e91a617d962f60003db27f7725029720b694a8309b627425410b56b8fed42be8e91e7fcc9e8b4ab4176453eb48e9d742c92aaef334

data/Rakefile

@@ -15,8 +15,6 @@ task :default => [:test]
 
 task :kpeg do
   FileUtils.rm_f "lib/review/compiler.rb"
-  FileUtils.rm_f "lib/review/compiler/literals_1_9.rb"
-  sh "kpeg -s lib/review/compiler/literals_1_9.kpeg -o lib/review/compiler/literals_1_9.rb"
   sh "kpeg -s lib/review/review.kpeg -o lib/review/compiler.rb"
 end
 

data/lib/review/compiler.rb

@@ -1,3 +1,4 @@
+# coding: UTF-8
 class ReVIEW::Compiler
   # :stopdoc:
 
@@ -35,22 +36,16 @@ class ReVIEW::Compiler
     end
 
     def current_line(target=pos)
-      cur_offset = 0
-      cur_line = 0
-
-      string.each_line do |line|
-        cur_line += 1
-        cur_offset += line.size
-        return cur_line if cur_offset >= target
-      end
+      offset = @sizes_memo.bsearch{|line, cur_offset| cur_offset >= target}
+      if offset
+        return offset[0]
+       end
 
       -1
     end
 
     def lines
-      lines = []
-      string.each_line { |l| lines << l }
-      lines
+      @lines_memo
     end
 
 
@@ -61,9 +56,22 @@ class ReVIEW::Compiler
 
     # Sets the string and current parsing position for the parser.
     def set_string string, pos
-      @string = string
-      @string_size = string ? string.size : 0
+      @string = string.freeze
       @pos = pos
+      @sizes_memo = []
+      if string
+        @string_size = string.size
+        @lines_memo = string.lines
+        cur_offset = cur_line = 0
+        @lines_memo.each do |line|
+          cur_line += 1
+          cur_offset += line.size
+          @sizes_memo << [cur_line, cur_offset]
+        end
+      else
+        @string_size = 0
+        @lines_memo = []
+      end
     end
 
     def show_pos
@@ -373,7 +381,7 @@ require 'review/preprocessor'
 require 'review/exception'
 require 'review/node'
   require 'lineinput'
-  require 'review/compiler/literals_1_9'
+  # require 'review/compiler/literals_1_9'
   # require 'review/compiler/literals_1_8'
 
   ## redifine Compiler.new
@@ -1194,9 +1202,7 @@ require 'review/node'
     end
   end
   include ::ReVIEWConstruction
-  def setup_foreign_grammar
-    @_grammar_literals = ReVIEW::Compiler::Literals.new(nil)
-  end
+  def setup_foreign_grammar; end
 
   # root = Start
   def _root
@@ -5036,48 +5042,40 @@ require 'review/node'
     return _tmp
   end
 
-  # Alphanumeric = %literals.Alphanumeric
-  def _Alphanumeric
-    _tmp = @_grammar_literals.external_invoke(self, :_Alphanumeric)
-    set_failed_rule :_Alphanumeric unless _tmp
-    return _tmp
-  end
-
-  # AlphanumericAscii = %literals.AlphanumericAscii
+  # AlphanumericAscii = /[A-Za-z0-9]/
   def _AlphanumericAscii
-    _tmp = @_grammar_literals.external_invoke(self, :_AlphanumericAscii)
+    _tmp = scan(/\A(?-mix:[A-Za-z0-9])/)
     set_failed_rule :_AlphanumericAscii unless _tmp
     return _tmp
   end
 
-  # LowerAlphabetAscii = %literals.LowerAlphabetAscii
+  # LowerAlphabetAscii = /[a-z]/
   def _LowerAlphabetAscii
-    _tmp = @_grammar_literals.external_invoke(self, :_LowerAlphabetAscii)
+    _tmp = scan(/\A(?-mix:[a-z])/)
     set_failed_rule :_LowerAlphabetAscii unless _tmp
     return _tmp
   end
 
-  # Digit = %literals.Digit
+  # Digit = /[0-9]/
   def _Digit
-    _tmp = @_grammar_literals.external_invoke(self, :_Digit)
+    _tmp = scan(/\A(?-mix:[0-9])/)
     set_failed_rule :_Digit unless _tmp
     return _tmp
   end
 
-  # BOM = %literals.BOM
+  # BOM = "uFEFF"
   def _BOM
-    _tmp = @_grammar_literals.external_invoke(self, :_BOM)
+    _tmp = match_string("uFEFF")
     set_failed_rule :_BOM unless _tmp
     return _tmp
   end
 
-  # Newline = %literals.Newline:n {newline(self, position, "\n")}
+  # Newline = /\n|\r\n?|\p{Zl}|\p{Zp}/ {newline(self, position, "\n")}
   def _Newline
 
     _save = self.pos
     while true # sequence
-      _tmp = @_grammar_literals.external_invoke(self, :_Newline)
-      n = @result
+      _tmp = scan(/\A(?-mix:\n|\r\n?|\p{Zl}|\p{Zp})/)
       unless _tmp
         self.pos = _save
         break
@@ -5094,20 +5092,6 @@ require 'review/node'
     return _tmp
   end
 
-  # NonAlphanumeric = %literals.NonAlphanumeric
-  def _NonAlphanumeric
-    _tmp = @_grammar_literals.external_invoke(self, :_NonAlphanumeric)
-    set_failed_rule :_NonAlphanumeric unless _tmp
-    return _tmp
-  end
-
-  # Spacechar = %literals.Spacechar
-  def _Spacechar
-    _tmp = @_grammar_literals.external_invoke(self, :_Spacechar)
-    set_failed_rule :_Spacechar unless _tmp
-    return _tmp
-  end
-
   Rules = {}
   Rules[:_root] = rule_info("root", "Start")
   Rules[:_Start] = rule_info("Start", "&. { @list_stack = Array.new } Document:c { @strategy.ast = c }")
@@ -5171,13 +5155,10 @@ require 'review/node'
   Rules[:_EOL] = rule_info("EOL", "(Newline | EOF)")
   Rules[:_EOF] = rule_info("EOF", "!.")
   Rules[:_ElementName] = rule_info("ElementName", "< LowerAlphabetAscii+ > { text }")
-  Rules[:_Alphanumeric] = rule_info("Alphanumeric", "%literals.Alphanumeric")
-  Rules[:_AlphanumericAscii] = rule_info("AlphanumericAscii", "%literals.AlphanumericAscii")
-  Rules[:_LowerAlphabetAscii] = rule_info("LowerAlphabetAscii", "%literals.LowerAlphabetAscii")
-  Rules[:_Digit] = rule_info("Digit", "%literals.Digit")
-  Rules[:_BOM] = rule_info("BOM", "%literals.BOM")
-  Rules[:_Newline] = rule_info("Newline", "%literals.Newline:n {newline(self, position, \"\\n\")}")
-  Rules[:_NonAlphanumeric] = rule_info("NonAlphanumeric", "%literals.NonAlphanumeric")
-  Rules[:_Spacechar] = rule_info("Spacechar", "%literals.Spacechar")
+  Rules[:_AlphanumericAscii] = rule_info("AlphanumericAscii", "/[A-Za-z0-9]/")
+  Rules[:_LowerAlphabetAscii] = rule_info("LowerAlphabetAscii", "/[a-z]/")
+  Rules[:_Digit] = rule_info("Digit", "/[0-9]/")
+  Rules[:_BOM] = rule_info("BOM", "\"uFEFF\"")
+  Rules[:_Newline] = rule_info("Newline", "/\\n|\\r\\n?|\\p{Zl}|\\p{Zp}/ {newline(self, position, \"\\n\")}")
   # :startdoc:
 end

data/lib/review/latexbuilder.rb

@@ -654,8 +654,9 @@ module ReVIEW
       '\noindent'
     end
 
-    def inline_chapref(id)
-      title = super
+    def node_inline_chapref(node)
+      id = node[0].to_raw
+      title = @book.chapter_index.display_string(id)
       if @book.config["chapterlink"]
         "\\hyperref[chap:#{id}]{#{title}}"
       else
@@ -666,7 +667,8 @@ module ReVIEW
       nofunc_text("[UnknownChapter:#{id}]")
     end
 
-    def inline_chap(id)
+    def node_inline_chap(node)
+      id = node[0].to_raw
       if @book.config["chapterlink"]
         "\\hyperref[chap:#{id}]{#{@book.chapter_index.number(id)}}"
       else
@@ -677,7 +679,8 @@ module ReVIEW
       nofunc_text("[UnknownChapter:#{id}]")
     end
 
-    def inline_title(id)
+    def node_inline_title(node)
+      id = node[0].to_raw
       title = super
       if @book.config["chapterlink"]
         "\\hyperref[chap:#{id}]{#{title}}"
@@ -697,12 +700,14 @@ module ReVIEW
       macro('reviewlistref', "#{chapter.number}.#{chapter.list(id).number}")
     end
 
-    def inline_table(id)
+    def node_inline_table(node)
+      id = node[0].to_raw
       chapter, id = extract_chapter_id(id)
       macro('reviewtableref', "#{chapter.number}.#{chapter.table(id).number}", table_label(id, chapter))
     end
 
-    def inline_img(id)
+    def node_inline_img(node)
+      id = node[0].to_raw
       chapter, id = extract_chapter_id(id)
       macro('reviewimageref', "#{chapter.number}.#{chapter.image(id).number}", image_label(id, chapter))
     end
@@ -812,7 +817,8 @@ module ReVIEW
       macro('texttt', macro('textbf', str))
     end
 
-    def inline_bib(id)
+    def node_inline_bib(node)
+      id = node[0].to_raw
       macro('reviewbibref', "[#{@chapter.bibpaper(id).number}]", bib_label(id))
     end
 
@@ -831,7 +837,8 @@ module ReVIEW
       end
     end
 
-    def inline_column(id)
+    def node_inline_column(node)
+      id = node[0].to_raw
       macro('reviewcolumnref', "#{@chapter.column(id).caption}", column_label(id))
     end
 
@@ -863,7 +870,8 @@ module ReVIEW
       macro('reviewami', str)
     end
 
-    def inline_icon(id)
+    def node_inline_icon(node)
+      id = node[0].to_raw
       macro('includegraphics', @chapter.image(id).path)
     end
 

data/lib/review/review.kpeg

@@ -1,5 +1,10 @@
 %% name = ReVIEW::Compiler
 
+%% header {
+# coding: UTF-8
+
+}
+
 %% {
   class Error; end
   class Position
@@ -18,7 +23,7 @@ require 'review/preprocessor'
 require 'review/exception'
 require 'review/node'
   require 'lineinput'
-  require 'review/compiler/literals_1_9'
+  # require 'review/compiler/literals_1_9'
   # require 'review/compiler/literals_1_8'
 
   ## redifine Compiler.new
@@ -734,12 +739,8 @@ EOF = !.
 
 ElementName = < LowerAlphabetAscii+ > { text }
 
-%literals         = ReVIEW::Compiler::Literals
-Alphanumeric      = %literals.Alphanumeric
-AlphanumericAscii = %literals.AlphanumericAscii
-LowerAlphabetAscii = %literals.LowerAlphabetAscii
-Digit              = %literals.Digit
-BOM               = %literals.BOM
-Newline           = %literals.Newline:n ~newline(self, position, "\n")
-NonAlphanumeric   = %literals.NonAlphanumeric
-Spacechar         = %literals.Spacechar
+AlphanumericAscii = /[A-Za-z0-9]/
+LowerAlphabetAscii = /[a-z]/
+Digit             = /[0-9]/
+BOM               = "\uFEFF"
+Newline           = /\n|\r\n?|\p{Zl}|\p{Zp}/ ~newline(self, position, "\n")

data/lib/review/version.rb

@@ -1,3 +1,3 @@
 module ReVIEW
-  VERSION = "0.1.3"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: review-peg
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors:
 - kmuto
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-10 00:00:00.000000000 Z
+date: 2015-11-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -171,8 +171,6 @@ files:
 - lib/review/builder.rb
 - lib/review/catalog.rb
 - lib/review/compiler.rb
-- lib/review/compiler/literals_1_9.kpeg
-- lib/review/compiler/literals_1_9.rb
 - lib/review/configure.rb
 - lib/review/epubbuilder.rb
 - lib/review/epubmaker.rb

data/lib/review/compiler/literals_1_9.kpeg

@@ -1,22 +0,0 @@
-%% name = ReVIEW::Compiler::Literals
-
-%% header {
-# coding: UTF-8
-
-##
-#--
-# This set of literals is for Ruby 1.9 regular expressions and gives full
-# unicode support.
-#
-# Unlike peg-markdown, this set of literals recognizes Unicode alphanumeric
-# characters, newlines and spaces.
-}
-
-Alphanumeric      = /\p{Word}/
-AlphanumericAscii = /[A-Za-z0-9]/
-LowerAlphabetAscii = /[a-z]/
-Digit             = /[0-9]/
-BOM               = "\uFEFF"
-Newline           = /\n|\r\n?|\p{Zl}|\p{Zp}/
-NonAlphanumeric   = /\p{^Word}/
-Spacechar         = /\t|\p{Zs}/

data/lib/review/compiler/literals_1_9.rb

@@ -1,435 +0,0 @@
-# coding: UTF-8
-
-##
-#--
-# This set of literals is for Ruby 1.9 regular expressions and gives full
-# unicode support.
-#
-# Unlike peg-markdown, this set of literals recognizes Unicode alphanumeric
-# characters, newlines and spaces.
-class ReVIEW::Compiler::Literals
-  # :stopdoc:
-
-    # This is distinct from setup_parser so that a standalone parser
-    # can redefine #initialize and still have access to the proper
-    # parser setup code.
-    def initialize(str, debug=false)
-      setup_parser(str, debug)
-    end
-
-
-
-    # Prepares for parsing +str+.  If you define a custom initialize you must
-    # call this method before #parse
-    def setup_parser(str, debug=false)
-      set_string str, 0
-      @memoizations = Hash.new { |h,k| h[k] = {} }
-      @result = nil
-      @failed_rule = nil
-      @failing_rule_offset = -1
-
-      setup_foreign_grammar
-    end
-
-    attr_reader :string
-    attr_reader :failing_rule_offset
-    attr_accessor :result, :pos
-
-    def current_column(target=pos)
-      if c = string.rindex("\n", target-1)
-        return target - c - 1
-      end
-
-      target + 1
-    end
-
-    def current_line(target=pos)
-      cur_offset = 0
-      cur_line = 0
-
-      string.each_line do |line|
-        cur_line += 1
-        cur_offset += line.size
-        return cur_line if cur_offset >= target
-      end
-
-      -1
-    end
-
-    def lines
-      lines = []
-      string.each_line { |l| lines << l }
-      lines
-    end
-
-
-
-    def get_text(start)
-      @string[start..@pos-1]
-    end
-
-    # Sets the string and current parsing position for the parser.
-    def set_string string, pos
-      @string = string
-      @string_size = string ? string.size : 0
-      @pos = pos
-    end
-
-    def show_pos
-      width = 10
-      if @pos < width
-        "#{@pos} (\"#{@string[0,@pos]}\" @ \"#{@string[@pos,width]}\")"
-      else
-        "#{@pos} (\"... #{@string[@pos - width, width]}\" @ \"#{@string[@pos,width]}\")"
-      end
-    end
-
-    def failure_info
-      l = current_line @failing_rule_offset
-      c = current_column @failing_rule_offset
-
-      if @failed_rule.kind_of? Symbol
-        info = self.class::Rules[@failed_rule]
-        "line #{l}, column #{c}: failed rule '#{info.name}' = '#{info.rendered}'"
-      else
-        "line #{l}, column #{c}: failed rule '#{@failed_rule}'"
-      end
-    end
-
-    def failure_caret
-      l = current_line @failing_rule_offset
-      c = current_column @failing_rule_offset
-
-      line = lines[l-1]
-      "#{line}\n#{' ' * (c - 1)}^"
-    end
-
-    def failure_character
-      l = current_line @failing_rule_offset
-      c = current_column @failing_rule_offset
-      lines[l-1][c-1, 1]
-    end
-
-    def failure_oneline
-      l = current_line @failing_rule_offset
-      c = current_column @failing_rule_offset
-
-      char = lines[l-1][c-1, 1]
-
-      if @failed_rule.kind_of? Symbol
-        info = self.class::Rules[@failed_rule]
-        "@#{l}:#{c} failed rule '#{info.name}', got '#{char}'"
-      else
-        "@#{l}:#{c} failed rule '#{@failed_rule}', got '#{char}'"
-      end
-    end
-
-    class ParseError < RuntimeError
-    end
-
-    def raise_error
-      raise ParseError, failure_oneline
-    end
-
-    def show_error(io=STDOUT)
-      error_pos = @failing_rule_offset
-      line_no = current_line(error_pos)
-      col_no = current_column(error_pos)
-
-      io.puts "On line #{line_no}, column #{col_no}:"
-
-      if @failed_rule.kind_of? Symbol
-        info = self.class::Rules[@failed_rule]
-        io.puts "Failed to match '#{info.rendered}' (rule '#{info.name}')"
-      else
-        io.puts "Failed to match rule '#{@failed_rule}'"
-      end
-
-      io.puts "Got: #{string[error_pos,1].inspect}"
-      line = lines[line_no-1]
-      io.puts "=> #{line}"
-      io.print(" " * (col_no + 3))
-      io.puts "^"
-    end
-
-    def set_failed_rule(name)
-      if @pos > @failing_rule_offset
-        @failed_rule = name
-        @failing_rule_offset = @pos
-      end
-    end
-
-    attr_reader :failed_rule
-
-    def match_string(str)
-      len = str.size
-      if @string[pos,len] == str
-        @pos += len
-        return str
-      end
-
-      return nil
-    end
-
-    def scan(reg)
-      if m = reg.match(@string[@pos..-1])
-        width = m.end(0)
-        @pos += width
-        return true
-      end
-
-      return nil
-    end
-
-    if "".respond_to? :ord
-      def get_byte
-        if @pos >= @string_size
-          return nil
-        end
-
-        s = @string[@pos].ord
-        @pos += 1
-        s
-      end
-    else
-      def get_byte
-        if @pos >= @string_size
-          return nil
-        end
-
-        s = @string[@pos]
-        @pos += 1
-        s
-      end
-    end
-
-    def parse(rule=nil)
-      # We invoke the rules indirectly via apply
-      # instead of by just calling them as methods because
-      # if the rules use left recursion, apply needs to
-      # manage that.
-
-      if !rule
-        apply(:_root)
-      else
-        method = rule.gsub("-","_hyphen_")
-        apply :"_#{method}"
-      end
-    end
-
-    class MemoEntry
-      def initialize(ans, pos)
-        @ans = ans
-        @pos = pos
-        @result = nil
-        @set = false
-        @left_rec = false
-      end
-
-      attr_reader :ans, :pos, :result, :set
-      attr_accessor :left_rec
-
-      def move!(ans, pos, result)
-        @ans = ans
-        @pos = pos
-        @result = result
-        @set = true
-        @left_rec = false
-      end
-    end
-
-    def external_invoke(other, rule, *args)
-      old_pos = @pos
-      old_string = @string
-
-      set_string other.string, other.pos
-
-      begin
-        if val = __send__(rule, *args)
-          other.pos = @pos
-          other.result = @result
-        else
-          other.set_failed_rule "#{self.class}##{rule}"
-        end
-        val
-      ensure
-        set_string old_string, old_pos
-      end
-    end
-
-    def apply_with_args(rule, *args)
-      memo_key = [rule, args]
-      if m = @memoizations[memo_key][@pos]
-        @pos = m.pos
-        if !m.set
-          m.left_rec = true
-          return nil
-        end
-
-        @result = m.result
-
-        return m.ans
-      else
-        m = MemoEntry.new(nil, @pos)
-        @memoizations[memo_key][@pos] = m
-        start_pos = @pos
-
-        ans = __send__ rule, *args
-
-        lr = m.left_rec
-
-        m.move! ans, @pos, @result
-
-        # Don't bother trying to grow the left recursion
-        # if it's failing straight away (thus there is no seed)
-        if ans and lr
-          return grow_lr(rule, args, start_pos, m)
-        else
-          return ans
-        end
-
-        return ans
-      end
-    end
-
-    def apply(rule)
-      if m = @memoizations[rule][@pos]
-        @pos = m.pos
-        if !m.set
-          m.left_rec = true
-          return nil
-        end
-
-        @result = m.result
-
-        return m.ans
-      else
-        m = MemoEntry.new(nil, @pos)
-        @memoizations[rule][@pos] = m
-        start_pos = @pos
-
-        ans = __send__ rule
-
-        lr = m.left_rec
-
-        m.move! ans, @pos, @result
-
-        # Don't bother trying to grow the left recursion
-        # if it's failing straight away (thus there is no seed)
-        if ans and lr
-          return grow_lr(rule, nil, start_pos, m)
-        else
-          return ans
-        end
-
-        return ans
-      end
-    end
-
-    def grow_lr(rule, args, start_pos, m)
-      while true
-        @pos = start_pos
-        @result = m.result
-
-        if args
-          ans = __send__ rule, *args
-        else
-          ans = __send__ rule
-        end
-        return nil unless ans
-
-        break if @pos <= m.pos
-
-        m.move! ans, @pos, @result
-      end
-
-      @result = m.result
-      @pos = m.pos
-      return m.ans
-    end
-
-    class RuleInfo
-      def initialize(name, rendered)
-        @name = name
-        @rendered = rendered
-      end
-
-      attr_reader :name, :rendered
-    end
-
-    def self.rule_info(name, rendered)
-      RuleInfo.new(name, rendered)
-    end
-
-
-  # :startdoc:
-  # :stopdoc:
-  def setup_foreign_grammar; end
-
-  # Alphanumeric = /\p{Word}/
-  def _Alphanumeric
-    _tmp = scan(/\A(?-mix:\p{Word})/)
-    set_failed_rule :_Alphanumeric unless _tmp
-    return _tmp
-  end
-
-  # AlphanumericAscii = /[A-Za-z0-9]/
-  def _AlphanumericAscii
-    _tmp = scan(/\A(?-mix:[A-Za-z0-9])/)
-    set_failed_rule :_AlphanumericAscii unless _tmp
-    return _tmp
-  end
-
-  # LowerAlphabetAscii = /[a-z]/
-  def _LowerAlphabetAscii
-    _tmp = scan(/\A(?-mix:[a-z])/)
-    set_failed_rule :_LowerAlphabetAscii unless _tmp
-    return _tmp
-  end
-
-  # Digit = /[0-9]/
-  def _Digit
-    _tmp = scan(/\A(?-mix:[0-9])/)
-    set_failed_rule :_Digit unless _tmp
-    return _tmp
-  end
-
-  # BOM = "uFEFF"
-  def _BOM
-    _tmp = match_string("uFEFF")
-    set_failed_rule :_BOM unless _tmp
-    return _tmp
-  end
-
-  # Newline = /\n|\r\n?|\p{Zl}|\p{Zp}/
-  def _Newline
-    _tmp = scan(/\A(?-mix:\n|\r\n?|\p{Zl}|\p{Zp})/)
-    set_failed_rule :_Newline unless _tmp
-    return _tmp
-  end
-
-  # NonAlphanumeric = /\p{^Word}/
-  def _NonAlphanumeric
-    _tmp = scan(/\A(?-mix:\p{^Word})/)
-    set_failed_rule :_NonAlphanumeric unless _tmp
-    return _tmp
-  end
-
-  # Spacechar = /\t|\p{Zs}/
-  def _Spacechar
-    _tmp = scan(/\A(?-mix:\t|\p{Zs})/)
-    set_failed_rule :_Spacechar unless _tmp
-    return _tmp
-  end
-
-  Rules = {}
-  Rules[:_Alphanumeric] = rule_info("Alphanumeric", "/\\p{Word}/")
-  Rules[:_AlphanumericAscii] = rule_info("AlphanumericAscii", "/[A-Za-z0-9]/")
-  Rules[:_LowerAlphabetAscii] = rule_info("LowerAlphabetAscii", "/[a-z]/")
-  Rules[:_Digit] = rule_info("Digit", "/[0-9]/")
-  Rules[:_BOM] = rule_info("BOM", "\"uFEFF\"")
-  Rules[:_Newline] = rule_info("Newline", "/\\n|\\r\\n?|\\p{Zl}|\\p{Zp}/")
-  Rules[:_NonAlphanumeric] = rule_info("NonAlphanumeric", "/\\p{^Word}/")
-  Rules[:_Spacechar] = rule_info("Spacechar", "/\\t|\\p{Zs}/")
-  # :startdoc:
-end