myco 0.1.8 → 0.1.9

data/lib/myco/code_tools/parser/pegleromyces/lib/pegleromyces/Common.my

@@ -0,0 +1,84 @@
+
+Common < EmptyObject {
+  Patterns < EmptyObject {
+    Base < BasicObject { var name: parent_meme.name }
+    UnaryBase  < Base { var inner }
+    BinaryBase < Base { var first, var second }
+    
+    UnaryBase << {
+      construct: construct_type.new(inner: inner.construct)
+    }
+    
+    BinaryBase << {
+      construct: construct_type.new(first: first.construct, second: second.construct)
+    }
+  }
+  
+  Constructions < EmptyObject {
+    Base < BasicObject { }
+    UnaryBase  < Base { var inner }
+    BinaryBase < Base { var first, var second }
+  }
+  
+  Constructions << {
+    Base       << { const bytecode_can_capture?: false }
+    UnaryBase  << { bytecode_can_capture?: inner.bytecode_can_capture? }
+    BinaryBase << { bytecode_can_capture?: first.bytecode_can_capture?
+                                       || second.bytecode_can_capture? }
+  }
+  
+  Patterns << {
+    ##
+    # Shorthand methods for creating primitive patterns
+    
+    ShorthandMethods < EmptyObject {
+      any:   ||                 String::Patterns::AnyCharacter   .new
+      char:  |character|        String::Patterns::Character      .new(code:character.ord)
+      str:   |string|           String::Patterns::CharacterString.new(codes:string.each_char.map(&:ord))
+      set:   |string|           String::Patterns::CharacterSet   .new(codes:string.each_char.map(&:ord))
+      range: |start, stop|      String::Patterns::CharacterRange .new(start:start.ord, stop:stop.ord)
+      r:     |pattern, &block| Capture::Patterns::Reduction      .new(inner:pattern, block:block)
+      si:    |*checks|          Stream::Patterns::Item           .new(checks:checks)
+      esi:   ||                 Stream::Patterns::End            .new
+    }
+    
+    ##
+    # Operator overloading for combining and modifying patterns.
+    #
+    # Each operation returns a new Pattern object composed of the operands
+    # so that complex grammars can be specified with relatively succint syntax.
+    
+    Base << {
+      "!":         Composite::Patterns::NegativePredicate .new(inner:self)
+      "/": |other| Composite::Patterns::OrderedChoice     .new(first:self, second:other)
+      "+": |other=false|
+        other &? Composite::Patterns::Concatenation       .new(first:self, second:other)
+              ?? Composite::Patterns::OneOrMore           .new(inner:self)
+      "-": |other=false|
+        other &? raise("binary '-' operator not implemented")
+              ?? Composite::Patterns::ZeroOrOne           .new(inner:self)
+      "*": |other=false|
+        other &? raise("binary '*' operator not implemented")
+              ?? Composite::Patterns::ZeroOrMore          .new(inner:self)
+      
+      "[]": |name| Capture::Patterns::NamedCapture        .new(inner:self, name:name)
+      text: |name=:text|
+                   Capture::Patterns::NamedTextCapture    .new(inner:self, name:name)
+      token: |name|
+                   Capture::Patterns::NamedTokenCapture   .new(inner:self, name:name)
+      
+      [private]
+      
+      # Add |other| to |orig| in a right-associative tree of type |type|
+      binary_right_assoc: |orig, other, type| {
+        cursor = orig
+        loop {
+          unless(cursor.second.is_a?(type)) { break }
+          cursor = cursor.second
+        }
+        cursor.second = type.new(first:cursor.second, second:other)
+        orig
+      }
+    }
+  }
+}

data/lib/myco/code_tools/parser/pegleromyces/lib/pegleromyces/Common.my.rb

@@ -0,0 +1,114 @@
+
+::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.cscope.for_method_definition::Common = ::Myco::Component.new([::Myco.find_constant(:EmptyObject)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+  ::Myco.cscope.for_method_definition::Patterns = ::Myco::Component.new([::Myco.find_constant(:EmptyObject)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {(
+    ::Myco.cscope.for_method_definition::Base = ::Myco::Component.new([::Myco.find_constant(:BasicObject)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+    .tap { |__c__| __c__.__last__ = __c__.component_eval {(declare_meme(:name, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (self.parent_meme.name)})}}
+    .tap { |__c__| __c__.__name__ = :Base }
+    ::Myco.cscope.for_method_definition::UnaryBase = ::Myco::Component.new([::Myco.find_constant(:Base)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+    .tap { |__c__| __c__.__last__ = __c__.component_eval {(declare_meme(:inner, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil})}}
+    .tap { |__c__| __c__.__name__ = :UnaryBase }
+    ::Myco.cscope.for_method_definition::BinaryBase = ::Myco::Component.new([::Myco.find_constant(:Base)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+    .tap { |__c__| __c__.__last__ = __c__.component_eval {(
+      declare_meme(:first, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+      declare_meme(:second, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+    )}}
+    .tap { |__c__| __c__.__name__ = :BinaryBase }
+    ::Myco.find_constant(:UnaryBase).component_eval {(declare_meme(:construct, [], nil, ::Myco.cscope.dup) { |*| (self.construct_type.new({:inner => self.inner.construct}))})}
+    ::Myco.find_constant(:BinaryBase).component_eval {(declare_meme(:construct, [], nil, ::Myco.cscope.dup) { |*| (self.construct_type.new({
+      :first => self.first.construct,
+      :second => self.second.construct
+    }))})}
+  )}}
+  .tap { |__c__| __c__.__name__ = :Patterns }
+  ::Myco.cscope.for_method_definition::Constructions = ::Myco::Component.new([::Myco.find_constant(:EmptyObject)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {(
+    ::Myco.cscope.for_method_definition::Base = ::Myco::Component.new([::Myco.find_constant(:BasicObject)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+    .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}}
+    .tap { |__c__| __c__.__name__ = :Base }
+    ::Myco.cscope.for_method_definition::UnaryBase = ::Myco::Component.new([::Myco.find_constant(:Base)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+    .tap { |__c__| __c__.__last__ = __c__.component_eval {(declare_meme(:inner, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil})}}
+    .tap { |__c__| __c__.__name__ = :UnaryBase }
+    ::Myco.cscope.for_method_definition::BinaryBase = ::Myco::Component.new([::Myco.find_constant(:Base)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+    .tap { |__c__| __c__.__last__ = __c__.component_eval {(
+      declare_meme(:first, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+      declare_meme(:second, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+    )}}
+    .tap { |__c__| __c__.__name__ = :BinaryBase }
+  )}}
+  .tap { |__c__| __c__.__name__ = :Constructions }
+  ::Myco.find_constant(:Constructions).component_eval {(
+    ::Myco.find_constant(:Base).component_eval {(declare_meme(:bytecode_can_capture?, [[:const, []]], nil, ::Myco.cscope.dup) { |*| (false)})}
+    ::Myco.find_constant(:UnaryBase).component_eval {(declare_meme(:bytecode_can_capture?, [], nil, ::Myco.cscope.dup) { |*| (self.inner.__send__(:bytecode_can_capture?))})}
+    ::Myco.find_constant(:BinaryBase).component_eval {(declare_meme(:bytecode_can_capture?, [], nil, ::Myco.cscope.dup) { |*| (::Myco.branch_op(:"||", self.first.__send__(:bytecode_can_capture?)) {self.second.__send__(:bytecode_can_capture?)})})}
+  )}
+  ::Myco.find_constant(:Patterns).component_eval {(
+    ::Myco.cscope.for_method_definition::ShorthandMethods = ::Myco::Component.new([::Myco.find_constant(:EmptyObject)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+    .tap { |__c__| __c__.__last__ = __c__.component_eval {(
+      declare_meme(:any, [], nil, ::Myco.cscope.dup) { || (::Myco.find_constant(:String)::Patterns::AnyCharacter.new)}
+      declare_meme(:char, [], nil, ::Myco.cscope.dup) { |character| (::Myco.find_constant(:String)::Patterns::Character.new({:code => character.ord}))}
+      declare_meme(:str, [], nil, ::Myco.cscope.dup) { |string| (::Myco.find_constant(:String)::Patterns::CharacterString.new({:codes => string.each_char.map(&:ord)}))}
+      declare_meme(:set, [], nil, ::Myco.cscope.dup) { |string| (::Myco.find_constant(:String)::Patterns::CharacterSet.new({:codes => string.each_char.map(&:ord)}))}
+      declare_meme(:range, [], nil, ::Myco.cscope.dup) { |start, stop| (::Myco.find_constant(:String)::Patterns::CharacterRange.new({
+        :start => start.ord,
+        :stop => stop.ord
+      }))}
+      declare_meme(:r, [], nil, ::Myco.cscope.dup) { |pattern, &block| (::Myco.find_constant(:Capture)::Patterns::Reduction.new({
+        :inner => pattern,
+        :block => block
+      }))}
+      declare_meme(:si, [], nil, ::Myco.cscope.dup) { |*checks| (::Myco.find_constant(:Stream)::Patterns::Item.new({:checks => checks}))}
+      declare_meme(:esi, [], nil, ::Myco.cscope.dup) { || (::Myco.find_constant(:Stream)::Patterns::End.new)}
+    )}}
+    .tap { |__c__| __c__.__name__ = :ShorthandMethods }
+    ::Myco.find_constant(:Base).component_eval {(
+      declare_meme(:!, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:Composite)::Patterns::NegativePredicate.new({:inner => self}))}
+      declare_meme(:/, [], nil, ::Myco.cscope.dup) { |other| (::Myco.find_constant(:Composite)::Patterns::OrderedChoice.new({
+        :first => self,
+        :second => other
+      }))}
+      declare_meme(:+, [], nil, ::Myco.cscope.dup) { |other=false| (::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", other) {::Myco.find_constant(:Composite)::Patterns::Concatenation.new({
+        :first => self,
+        :second => other
+      })}) {::Myco.find_constant(:Composite)::Patterns::OneOrMore.new({:inner => self})})}
+      declare_meme(:-, [], nil, ::Myco.cscope.dup) { |other=false| (::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", other) {self.raise("binary '-' operator not implemented")}) {::Myco.find_constant(:Composite)::Patterns::ZeroOrOne.new({:inner => self})})}
+      declare_meme(:*, [], nil, ::Myco.cscope.dup) { |other=false| (::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", other) {self.raise("binary '*' operator not implemented")}) {::Myco.find_constant(:Composite)::Patterns::ZeroOrMore.new({:inner => self})})}
+      declare_meme(:[], [], nil, ::Myco.cscope.dup) { |name| (::Myco.find_constant(:Capture)::Patterns::NamedCapture.new({
+        :inner => self,
+        :name => name
+      }))}
+      declare_meme(:text, [], nil, ::Myco.cscope.dup) { |name=:text| (::Myco.find_constant(:Capture)::Patterns::NamedTextCapture.new({
+        :inner => self,
+        :name => name
+      }))}
+      declare_meme(:token, [], nil, ::Myco.cscope.dup) { |name| (::Myco.find_constant(:Capture)::Patterns::NamedTokenCapture.new({
+        :inner => self,
+        :name => name
+      }))}
+      __category__(:private).component_eval {(declare_meme(:binary_right_assoc, [], nil, ::Myco.cscope.dup) { |orig, other, type| (
+        cursor = orig
+        self.loop { || (
+          self.__send__(
+            :unless,
+            cursor.second.__send__(
+              :is_a?,
+              type
+            )
+          ) { || (self.__send__(:break))}
+          cursor = cursor.second
+        )}
+        cursor.__send__(
+          :second=,
+          type.new({
+            :first => cursor.second,
+            :second => other
+          })
+        )
+        orig
+      )})}
+    )}
+  )}
+)}}
+.tap { |__c__| __c__.__name__ = :Common })}}.instance

data/lib/myco/code_tools/parser/pegleromyces/lib/pegleromyces/Common/Parser.my

@@ -0,0 +1,139 @@
+
+Common << {
+  Parser < BasicObject {
+    State < BasicObject {
+      var start_idx
+      var end_idx
+      var rule
+      var result
+      
+      var error_idx
+      
+      raise_error: self.error_idx && raise(SyntaxError
+        "Syntax error with parser: "self.rule" at index: "self.error_idx""
+      )
+    }
+    
+    var debug_mode: false
+    
+    var grammar: Grammar.new
+    var builder: null
+    
+    new_worker: set_up_worker(prototype.new)
+    new_processor: Processor.new(builder: builder)
+    
+    var prototype: compile_prototype
+    
+    refresh: self.prototype = compile_prototype
+    
+    compile_prototype: {
+      proto = Component.new
+      grammar.construct_all_rules
+      grammar.rule_table.each |name, rule| {
+        compile_rule_into(proto, name, rule)
+      }
+      proto
+    }
+    
+    compile_rule_into: |proto, name, rule| {
+      construct = rule.inner.construct
+      
+      Myco.add_dynamic_method(proto, name, "(compiled parser)") |g| {
+        g.extend(BytecodeHelpers)
+        g.debug_mode = self.debug_mode
+        g.rule_start
+        construct.bytecode(g)
+        g.rule_finish
+      }
+    }
+    
+    compile_generator: |name, file, line=1, &block| {
+      g = Myco::ToolSet::Generator.new
+      g.name = name
+      g.file = file
+      g.set_line(line)
+      
+      block.call(g)
+      
+      g.ret
+      g.close
+      g.use_detected
+      g
+    }
+    
+    compile_code: |name, file, line=1, &block| {
+      g = compile_generator(name, file, line, &block)
+      g.encode
+      g.package(Rubinius::CompiledCode)
+    }
+    
+    save_prototype: |filename| {
+      code = compile_code(:__script__, :"(snippet)") |g| {
+        g.push_cpath_top; g.find_const(:Class)
+        g.create_block(compile_generator(:__block__, :"(snippet)") |g| {
+          prototype.instance_methods.each |name| {
+            code = prototype.instance_method(name).executable
+            if(code.is_a?(Rubinius::CompiledCode)) {
+              g.push_rubinius
+                g.push_literal(name)
+                g.push_literal(code)
+                g.push_scope
+                g.push_variables; g.send(:method_visibility, 0)
+              g.send(:add_defn_method, 4)
+            }
+          }
+        })
+        g.send_with_block(:new, 0)
+      }
+      
+      Myco::ToolSet::CompiledFile.dump(code, filename, Rubinius::Signature, Rubinius::RUBY_LIB_VERSION)
+    }
+    
+    load_prototype: |filename| {
+      loader = Myco::CodeLoader::BytecodeLoader.new(filename)
+      loader.bind_to(call_depth:1)
+      self.prototype = loader.load
+    }
+    
+    set_up_worker: |worker| {
+      worker.__set_ivar__(:"@captures", [])
+      worker.__set_ivar__(:"@highest_idx", 0)
+      worker
+    }
+    
+    captures_of_worker: |worker|
+      worker.__get_ivar__(:"@captures")
+    
+    highest_idx_of_worker: |worker|
+      worker.__get_ivar__(:"@highest_idx")
+    
+    parse: {
+      raise("The parse method is not implemented for "self"")
+    }
+    # Match and process the given string using the current grammar
+    parse: |string, rule:"root", start_idx:0| {
+      worker    = new_worker
+      processor = new_processor
+      state     = State.new(
+        string:    string.to_s
+        rule:      rule.to_sym
+        start_idx: start_idx.to_i
+      )
+      
+      state.end_idx = worker.__send__(state.rule, state.string, state.start_idx)
+      
+      state.end_idx &? (
+        processor.string = state.string
+        processor.capture_items = captures_of_worker(worker)
+        grammar.?tokenizer && (processor.tokenizer = grammar.tokenizer)
+        state.result = processor.process
+      ) ?? (
+        state.error_idx = highest_idx_of_worker(worker)
+        pos = processor.position_of(state.error_idx, state.string)
+        state.error_row = pos.first
+        state.error_col = pos.last
+      )
+      state
+    }
+  }
+}

data/lib/myco/code_tools/parser/pegleromyces/lib/pegleromyces/{BytecodeParser.my.rb → Common/Parser.my.rb}

@@ -1,41 +1,23 @@
 
 ::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.cscope.for_method_definition::BytecodeParser = ::Myco::Component.new([::Myco.find_constant(:BasicObject)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.find_constant(:Common).component_eval {(::Myco.cscope.for_method_definition::Parser = ::Myco::Component.new([::Myco.find_constant(:BasicObject)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
   ::Myco.cscope.for_method_definition::State = ::Myco::Component.new([::Myco.find_constant(:BasicObject)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
   .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-    declare_meme(:string, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
     declare_meme(:start_idx, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
     declare_meme(:end_idx, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
     declare_meme(:rule, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
     declare_meme(:result, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
     declare_meme(:error_idx, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-    declare_meme(:error_row, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-    declare_meme(:error_col, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-    declare_meme(:error_string, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
     declare_meme(:raise_error, [], nil, ::Myco.cscope.dup) { |*| (::Myco.branch_op(:"&&", self.error_idx) {self.raise(
       ::Myco.find_constant(:SyntaxError),
-      "Unexpected character with parser: #{self.rule} near line: #{self.error_row}, column: #{self.error_col}.\n#{self.string.each_line.to_a.__send__(
-        :[],
-        self.error_row.__send__(
-          :-,
-          1
-        )
-      )}#{" ".__send__(
-        :*,
-        [
-          self.error_col.__send__(
-            :-,
-            1
-          ),
-          0
-        ].max
-      )}^"
+      "Syntax error with parser: #{self.rule} at index: #{self.error_idx}"
     )})}
   )}}
   .tap { |__c__| __c__.__name__ = :State }
+  declare_meme(:debug_mode, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (false)}
   declare_meme(:grammar, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:Grammar).new)}
-  declare_meme(:builder, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:Builder).new)}
+  declare_meme(:builder, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (nil)}
   declare_meme(:new_worker, [], nil, ::Myco.cscope.dup) { |*| (self.set_up_worker(self.prototype.new))}
   declare_meme(:new_processor, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:Processor).new({:builder => self.builder}))}
   declare_meme(:prototype, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (self.compile_prototype)}
@@ -54,20 +36,19 @@
     proto
   )}
   declare_meme(:compile_rule_into, [], nil, ::Myco.cscope.dup) { |proto, name, rule| (
-    construct = rule.construct_rule
+    construct = rule.inner.construct
     ::Myco.find_constant(:Myco).add_dynamic_method(
       proto,
       name,
       "(compiled parser)"
     ) { |g| (
-      instructor = ::Myco.find_constant(:BytecodeInstructions).new
-      instructor.__send__(
-        :g=,
-        g
-      )
       g.extend(::Myco.find_constant(:BytecodeHelpers))
+      g.__send__(
+        :debug_mode=,
+        self.debug_mode
+      )
       g.rule_start
-      construct.bytecode(instructor)
+      construct.bytecode(g)
       g.rule_finish
     )}
   )}
@@ -165,18 +146,14 @@
   )}
   declare_meme(:captures_of_worker, [], nil, ::Myco.cscope.dup) { |worker| (worker.__get_ivar__(:@captures))}
   declare_meme(:highest_idx_of_worker, [], nil, ::Myco.cscope.dup) { |worker| (worker.__get_ivar__(:@highest_idx))}
+  declare_meme(:parse, [], nil, ::Myco.cscope.dup) { |*| (self.raise("The parse method is not implemented for #{self}"))}
   declare_meme(:parse, [], nil, ::Myco.cscope.dup) { |string, rule:"root", start_idx:0| (
     worker = self.new_worker
     processor = self.new_processor
     state = ::Myco.find_constant(:State).new({
       :string => string.to_s,
       :rule => rule.to_sym,
-      :start_idx => start_idx.to_i,
-      :error_idx => nil,
-      :error_row => nil,
-      :error_col => nil,
-      :error_string => nil,
-      :result => nil
+      :start_idx => start_idx.to_i
     })
     state.__send__(
       :end_idx=,
@@ -195,6 +172,10 @@
         :capture_items=,
         self.captures_of_worker(worker)
       )
+      ::Myco.branch_op(:"&&", (Rubinius::Type.object_respond_to?(self.grammar, :tokenizer).false? ? ::Myco::Void : self.grammar.tokenizer)) {processor.__send__(
+        :tokenizer=,
+        self.grammar.tokenizer
+      )}
       state.__send__(
         :result=,
         processor.process
@@ -220,4 +201,4 @@
     state
   )}
 )}}
-.tap { |__c__| __c__.__name__ = :BytecodeParser })}}.instance
+.tap { |__c__| __c__.__name__ = :Parser })})}}.instance

data/lib/myco/code_tools/parser/pegleromyces/lib/pegleromyces/Composite.my

@@ -0,0 +1,229 @@
+
+Composite < EmptyObject {
+  Patterns < EmptyObject {
+    UnaryBase  < Common::Patterns::UnaryBase  { }
+    BinaryBase < Common::Patterns::BinaryBase { }
+    
+    NegativePredicate < UnaryBase  { construct_type: Constructions::NegativePredicate }
+    PositivePredicate < UnaryBase  { construct_type: Constructions::PositivePredicate }
+    OneOrMore         < UnaryBase  { construct_type: Constructions::OneOrMore }
+    ZeroOrOne         < UnaryBase  { construct_type: Constructions::ZeroOrOne }
+    ZeroOrMore        < UnaryBase  { construct_type: Constructions::ZeroOrMore }
+    OrderedChoice     < BinaryBase { construct_type: Constructions::OrderedChoice }
+    Concatenation     < BinaryBase { construct_type: Constructions::Concatenation }
+  }
+  
+  Constructions < EmptyObject {
+    UnaryBase  < Common::Constructions::UnaryBase  { }
+    BinaryBase < Common::Constructions::BinaryBase { }
+    
+    NegativePredicate < UnaryBase  { }
+    PositivePredicate < UnaryBase  { }
+    OneOrMore         < UnaryBase  { var inlaid }
+    ZeroOrOne         < UnaryBase  { }
+    ZeroOrMore        < UnaryBase  { var inlaid }
+    OrderedChoice     < BinaryBase { }
+    Concatenation     < BinaryBase { }
+  }
+  
+  Patterns << {
+    NegativePredicate << {
+      # Invert the polarity of the predicate instead of nesting the predicate
+      "!": PositivePredicate.new(inner:inner)
+    }
+    
+    PositivePredicate << {
+      # Invert the polarity of the predicate instead of nesting the predicate
+      "!": NegativePredicate.new(inner:inner)
+    }
+    
+    OrderedChoice << {
+      # Build a right-associative tree if the first operand of another "/"
+      "/": |other|
+        private.binary_right_assoc(self, other, OrderedChoice)
+    }
+    
+    Concatenation << {
+      # Build a right-associative tree if the first operand of another "+"
+      "+": |other=false|
+        other
+          &? private.binary_right_assoc(self, other, Concatenation)
+          ?? OneOrMore.new(inner:self)
+    }
+  }
+  
+  Constructions << {
+    # Negative matching predicate that consumes no input.
+    NegativePredicate << { bytecode: |g| {
+      local_fail = g.new_label
+      old_fail = g.overall_fail
+      g.overall_fail = local_fail
+      
+      # Store index and captures for backtracking
+      if(inner.bytecode_can_capture?) { g.push_temp_captures }
+      g.push_idx
+      
+      inner.bytecode(g)
+      
+      # Success => Failure, backtrack index and captures
+      g.pop_to_set_idx
+      if(inner.bytecode_can_capture?) { g.pop_to_reject_captures }
+      g.overall_fail = old_fail # reset fail
+      g.goto(g.overall_fail)
+      
+      # Failure => Success, backtrack index and cannot keep captures either (incomplete)
+      local_fail.set!
+      g.pop_to_set_idx
+      if(inner.bytecode_can_capture?) { g.pop_to_reject_captures }
+      g.overall_fail = old_fail
+    }}
+    
+    # Positive matching predicate that consumes no input.
+    PositivePredicate << { bytecode: |g| {
+      local_done = g.new_label
+      local_fail = g.new_label
+      old_fail = g.overall_fail
+      g.overall_fail = local_fail
+      
+      # Store index and captures for backtracking
+      if(inner.bytecode_can_capture?) { g.push_temp_captures }
+      g.push_idx
+      
+      inner.bytecode(g)
+      
+      # Success, but do not consume input, so backtrack index but keep captures
+      g.pop_to_set_idx
+      if(inner.bytecode_can_capture?) { g.pop_to_accept_captures }
+      g.overall_fail = old_fail # reset fail
+      g.goto(local_done)
+      
+      # Failure, backtrack index and captures
+      local_fail.set!
+      g.pop_to_set_idx
+      if(inner.bytecode_can_capture?) { g.pop_to_reject_captures }
+      g.overall_fail = old_fail
+      g.goto(g.overall_fail)
+      
+      local_done.set!
+    }}
+    
+    # Keep consuming |inner| until it doesn't match; it must match at least one.
+    OneOrMore << { bytecode: |g| {
+      local_retry = g.new_label
+      local_fail = g.new_label
+      old_fail = g.overall_fail
+      g.overall_fail = local_fail
+      # push a false to indicate that no matches have occurred yet
+      g.push_false
+      
+      local_retry.set!
+      
+      # Store captures for restoration
+      if(inner.bytecode_can_capture?) { g.push_temp_captures }
+      
+      inner.bytecode(g); inlaid.?call
+      
+      # Success, accept captures and try again, popping the last boolean
+      # to push a true to indicate at least one match was made.
+      if(inner.bytecode_can_capture?) { g.pop_to_accept_captures }
+      g.pop; g.push_true
+      g.goto(local_retry)
+      
+      # Failure, reject captures and continue
+      local_fail.set!
+      if(inner.bytecode_can_capture?) { g.pop_to_reject_captures }
+      g.overall_fail = old_fail # reset fail
+      
+      # If at least one match was not found, it is an overall failure
+      g.goto_if_false(g.overall_fail)
+    }}
+    
+    # Optionally match and capture from inner, or still succeed if not.
+    ZeroOrOne << { bytecode: |g| {
+      local_done = g.new_label
+      local_fail = g.new_label
+      old_fail = g.overall_fail
+      g.overall_fail = local_fail
+      
+      # Store index and captures for backtracking in case of failure
+      if(inner.bytecode_can_capture?) { g.push_temp_captures }
+      g.push_idx
+      
+      inner.bytecode(g)
+      
+      # Success, throw away backtrack entry
+      g.pop # keep idx
+      if(inner.bytecode_can_capture?) { g.pop_to_accept_captures }
+      g.overall_fail = old_fail # reset fail
+      g.goto(local_done)
+      
+      # Failure, backtrack index and captures
+      local_fail.set!
+      g.pop_to_set_idx
+      if(inner.bytecode_can_capture?) { g.pop_to_reject_captures }
+      g.overall_fail = old_fail
+      
+      local_done.set!
+    }}
+    
+    # Keep consuming |inner| until it doesn't match; it will not cause backtrack.
+    ZeroOrMore << { bytecode: |g| {
+      local_retry = g.new_label
+      local_fail = g.new_label
+      old_fail = g.overall_fail
+      g.overall_fail = local_fail
+      
+      local_retry.set!
+      
+      # Store captures for restoration
+      if(inner.bytecode_can_capture?) { g.push_temp_captures }
+      
+      inner.bytecode(g); inlaid.?call
+      
+      # Success, accept captures and try again
+      if(inner.bytecode_can_capture?) { g.pop_to_accept_captures }
+      g.goto(local_retry)
+      
+      # Failure, reject captures and continue
+      local_fail.set!
+      if(inner.bytecode_can_capture?) { g.pop_to_reject_captures }
+      g.overall_fail = old_fail # reset fail
+    }}
+    
+    # An ordered choice between first and second that matches when one succeeds.
+    OrderedChoice << { bytecode: |g| {
+      local_done = g.new_label
+      local_fail = g.new_label
+      old_fail = g.overall_fail
+      g.overall_fail = local_fail
+      
+      # Store index and captures for backtracking in case of failure
+      if(first.bytecode_can_capture?) { g.push_temp_captures }
+      g.push_idx
+      
+      first.bytecode(g)
+      
+      # Success, throw away backtrack entry
+      g.pop # keep idx
+      if(first.bytecode_can_capture?) { g.pop_to_accept_captures }
+      g.overall_fail = old_fail # reset fail
+      g.goto(local_done)
+      
+      # Failure, backtrack index and captures
+      local_fail.set!
+      g.pop_to_set_idx
+      if(first.bytecode_can_capture?) { g.pop_to_reject_captures }
+      g.overall_fail = old_fail
+      
+      second.bytecode(g)
+      
+      local_done.set!
+    }}
+    
+    # Match the first item followed by the second.
+    Concatenation << { bytecode: |g| {
+      first.bytecode(g)
+      second.bytecode(g)
+    }}
+  }
+}