myco 0.1.4 → 0.1.5

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

@@ -0,0 +1,370 @@
+
+::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.cscope.for_method_definition.const_set(: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.const_set(: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.const_set(: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.const_set(: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.cscope.for_method_definition.const_set(:AnyCharacter, ::Myco::Component.new([::Myco.find_constant(:Base)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}})
+  .tap { |__c__| __c__.__name__ = :AnyCharacter }
+  ::Myco.cscope.for_method_definition.const_set(:Character, ::Myco::Component.new([::Myco.find_constant(:Base)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {(declare_meme(:code, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil})}})
+  .tap { |__c__| __c__.__name__ = :Character }
+  ::Myco.cscope.for_method_definition.const_set(:CharacterString, ::Myco::Component.new([::Myco.find_constant(:Base)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {(declare_meme(:codes, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil})}})
+  .tap { |__c__| __c__.__name__ = :CharacterString }
+  ::Myco.cscope.for_method_definition.const_set(:CharacterSet, ::Myco::Component.new([::Myco.find_constant(:Base)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {(declare_meme(:codes, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil})}})
+  .tap { |__c__| __c__.__name__ = :CharacterSet }
+  ::Myco.cscope.for_method_definition.const_set(:CharacterRange, ::Myco::Component.new([::Myco.find_constant(:Base)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {(
+    declare_meme(:start, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+    declare_meme(:stop, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  )}})
+  .tap { |__c__| __c__.__name__ = :CharacterRange }
+  ::Myco.cscope.for_method_definition.const_set(:NegativePredicate, ::Myco::Component.new([::Myco.find_constant(:UnaryBase)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}})
+  .tap { |__c__| __c__.__name__ = :NegativePredicate }
+  ::Myco.cscope.for_method_definition.const_set(:PositivePredicate, ::Myco::Component.new([::Myco.find_constant(:UnaryBase)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}})
+  .tap { |__c__| __c__.__name__ = :PositivePredicate }
+  ::Myco.cscope.for_method_definition.const_set(:OneOrMore, ::Myco::Component.new([::Myco.find_constant(:UnaryBase)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}})
+  .tap { |__c__| __c__.__name__ = :OneOrMore }
+  ::Myco.cscope.for_method_definition.const_set(:ZeroOrOne, ::Myco::Component.new([::Myco.find_constant(:UnaryBase)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}})
+  .tap { |__c__| __c__.__name__ = :ZeroOrOne }
+  ::Myco.cscope.for_method_definition.const_set(:ZeroOrMore, ::Myco::Component.new([::Myco.find_constant(:UnaryBase)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}})
+  .tap { |__c__| __c__.__name__ = :ZeroOrMore }
+  ::Myco.cscope.for_method_definition.const_set(:OrderedChoice, ::Myco::Component.new([::Myco.find_constant(:BinaryBase)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}})
+  .tap { |__c__| __c__.__name__ = :OrderedChoice }
+  ::Myco.cscope.for_method_definition.const_set(:Concatenation, ::Myco::Component.new([::Myco.find_constant(:BinaryBase)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}})
+  .tap { |__c__| __c__.__name__ = :Concatenation }
+  ::Myco.cscope.for_method_definition.const_set(:NamedCapture, ::Myco::Component.new([::Myco.find_constant(:UnaryBase)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {(declare_meme(:captargs, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil})}})
+  .tap { |__c__| __c__.__name__ = :NamedCapture }
+  ::Myco.cscope.for_method_definition.const_set(:NamedTextCapture, ::Myco::Component.new([::Myco.find_constant(:UnaryBase)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {(declare_meme(:captargs, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil})}})
+  .tap { |__c__| __c__.__name__ = :NamedTextCapture }
+  ::Myco.cscope.for_method_definition.const_set(:NamedTokenCapture, ::Myco::Component.new([::Myco.find_constant(:UnaryBase)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {(declare_meme(:captargs, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil})}})
+  .tap { |__c__| __c__.__name__ = :NamedTokenCapture }
+  ::Myco.cscope.for_method_definition.const_set(:Reduction, ::Myco::Component.new([::Myco.find_constant(:UnaryBase)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {(declare_meme(:captargs, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil})}})
+  .tap { |__c__| __c__.__name__ = :Reduction }
+  ::Myco.find_constant(:Patterns)::UnaryBase.component_eval {(declare_meme(:construct, [], nil, ::Myco.cscope.dup) { |*| (self.construct_type.new({:inner => self.inner.construct}))})}
+  ::Myco.find_constant(:Patterns)::BinaryBase.component_eval {(declare_meme(:construct, [], nil, ::Myco.cscope.dup) { |*| (self.construct_type.new({
+    :first => self.first.construct,
+    :second => self.second.construct
+  }))})}
+  ::Myco.find_constant(:Patterns)::AnyCharacter.component_eval {(declare_meme(:construct, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:AnyCharacter).new)})}
+  ::Myco.find_constant(:Patterns)::Character.component_eval {(declare_meme(:construct, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:Character).new({:code => self.code}))})}
+  ::Myco.find_constant(:Patterns)::CharacterString.component_eval {(declare_meme(:construct, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:CharacterString).new({:codes => self.codes}))})}
+  ::Myco.find_constant(:Patterns)::CharacterSet.component_eval {(declare_meme(:construct, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:CharacterSet).new({:codes => self.codes}))})}
+  ::Myco.find_constant(:Patterns)::CharacterRange.component_eval {(declare_meme(:construct, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:CharacterRange).new({
+    :start => self.start,
+    :stop => self.stop
+  }))})}
+  ::Myco.find_constant(:Patterns)::NegativePredicate.component_eval {(declare_meme(:construct_type, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:NegativePredicate))})}
+  ::Myco.find_constant(:Patterns)::PositivePredicate.component_eval {(declare_meme(:construct_type, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:PositivePredicate))})}
+  ::Myco.find_constant(:Patterns)::OneOrMore.component_eval {(declare_meme(:construct_type, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:OneOrMore))})}
+  ::Myco.find_constant(:Patterns)::ZeroOrOne.component_eval {(declare_meme(:construct_type, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:ZeroOrOne))})}
+  ::Myco.find_constant(:Patterns)::ZeroOrMore.component_eval {(declare_meme(:construct_type, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:ZeroOrMore))})}
+  ::Myco.find_constant(:Patterns)::OrderedChoice.component_eval {(declare_meme(:construct_type, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:OrderedChoice))})}
+  ::Myco.find_constant(:Patterns)::Concatenation.component_eval {(declare_meme(:construct_type, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:Concatenation))})}
+  ::Myco.find_constant(:Patterns)::NamedCapture.component_eval {(declare_meme(:construct, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:NamedCapture).new({
+    :inner => self.inner.construct,
+    :captargs => [self.name]
+  }))})}
+  ::Myco.find_constant(:Patterns)::NamedTextCapture.component_eval {(declare_meme(:construct, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:NamedTextCapture).new({
+    :inner => self.inner.construct,
+    :captargs => [self.name]
+  }))})}
+  ::Myco.find_constant(:Patterns)::NamedTokenCapture.component_eval {(declare_meme(:construct, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:NamedTokenCapture).new({
+    :inner => self.inner.construct,
+    :captargs => [self.name]
+  }))})}
+  ::Myco.find_constant(:Patterns)::Reduction.component_eval {(declare_meme(:construct, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:Reduction).new({
+    :inner => self.inner.construct,
+    :captargs => [
+      self.code,
+      *self.args
+    ]
+  }))})}
+  ::Myco.find_constant(:AnyCharacter).component_eval {(declare_meme(:sequence, [], nil, ::Myco.cscope.dup) { |*| ([[
+    :any,
+    1
+  ]])})}
+  ::Myco.find_constant(:Character).component_eval {(declare_meme(:sequence, [], nil, ::Myco.cscope.dup) { |*| ([[
+    :char,
+    self.code
+  ]])})}
+  ::Myco.find_constant(:CharacterString).component_eval {(declare_meme(:sequence, [], nil, ::Myco.cscope.dup) { |*| (self.codes.map { |code| ([
+    :char,
+    code
+  ])})})}
+  ::Myco.find_constant(:CharacterSet).component_eval {(
+    declare_meme(:sequence, [], nil, ::Myco.cscope.dup) { |*| ([[
+      :charset,
+      self.table
+    ]])}
+    declare_meme(:table, [], nil, ::Myco.cscope.dup) { |*| (self.codes.map { |code| ([
+      code,
+      true
+    ])}.to_h)}
+  )}
+  ::Myco.find_constant(:CharacterRange).component_eval {(declare_meme(:sequence, [], nil, ::Myco.cscope.dup) { |*| ([[
+    :charrange,
+    self.start,
+    self.stop
+  ]])})}
+  ::Myco.find_constant(:NegativePredicate).component_eval {(declare_meme(:sequence, [], nil, ::Myco.cscope.dup) { |*| (
+    a = self.inner.sequence
+    [
+      [
+        :choice,
+        a.size.__send__(
+          :+,
+          2
+        )
+      ],
+      *a,
+      [:fail_twice]
+    ]
+  )})}
+  ::Myco.find_constant(:PositivePredicate).component_eval {(declare_meme(:sequence, [], nil, ::Myco.cscope.dup) { |*| (
+    a = self.inner.sequence
+    size = a.size
+    [
+      [
+        :choice,
+        size.__send__(
+          :+,
+          4
+        )
+      ],
+      [
+        :choice,
+        size.__send__(
+          :+,
+          1
+        )
+      ],
+      *a,
+      [
+        :commit,
+        1
+      ],
+      [:fail]
+    ]
+  )})}
+  ::Myco.find_constant(:OneOrMore).component_eval {(
+    declare_meme(:inlaid, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+    declare_meme(:sequence, [], nil, ::Myco.cscope.dup) { |*| (
+      one = self.inner.sequence
+      ::Myco.branch_op(:"&&", self.inlaid) {one = one.__send__(
+        :+,
+        self.inlaid
+      )}
+      or_more = ::Myco.find_constant(:ZeroOrMore).new({
+        :inner => self.inner,
+        :inlaid => self.inlaid
+      }).sequence
+      [
+        *one,
+        *or_more
+      ]
+    )}
+  )}
+  ::Myco.find_constant(:ZeroOrOne).component_eval {(declare_meme(:sequence, [], nil, ::Myco.cscope.dup) { |*| (
+    a = self.inner.sequence
+    [
+      [
+        :choice,
+        a.size.__send__(
+          :+,
+          2
+        )
+      ],
+      *a,
+      [
+        :commit,
+        1
+      ]
+    ]
+  )})}
+  ::Myco.find_constant(:ZeroOrMore).component_eval {(
+    declare_meme(:inlaid, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+    declare_meme(:sequence, [], nil, ::Myco.cscope.dup) { |*| (self.switch(
+      self.inner,
+      :is_a?
+    ).when(::Myco.find_constant(:CharacterSet)) { || ([[
+      :span,
+      self.inner.table
+    ]])}.else { || (
+      a = self.inner.sequence
+      ::Myco.branch_op(:"&&", self.inlaid) {a = a.__send__(
+        :+,
+        self.inlaid
+      )}
+      size = a.size
+      [
+        [
+          :choice,
+          size.__send__(
+            :+,
+            2
+          )
+        ],
+        *a,
+        [
+          :partial_commit,
+          size.__send__(
+            :*,
+            -1
+          )
+        ]
+      ]
+    )}.output)}
+  )}
+  ::Myco.find_constant(:OrderedChoice).component_eval {(declare_meme(:sequence, [], nil, ::Myco.cscope.dup) { |*| (
+    a = self.first.sequence
+    b = self.second.sequence
+    [
+      [
+        :choice,
+        a.size.__send__(
+          :+,
+          2
+        )
+      ],
+      *a,
+      [
+        :commit,
+        b.size.__send__(
+          :+,
+          1
+        )
+      ],
+      *b
+    ]
+  )})}
+  ::Myco.find_constant(:Concatenation).component_eval {(declare_meme(:sequence, [], nil, ::Myco.cscope.dup) { |*| ([
+    *self.first.sequence,
+    *self.second.sequence
+  ])})}
+  ::Myco.find_constant(:NamedCapture).component_eval {(declare_meme(:sequence, [], nil, ::Myco.cscope.dup) { |*| (::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", ::Myco.branch_op(:"||", self.inner.__send__(
+    :is_a?,
+    ::Myco.find_constant(:OneOrMore)
+  )) {self.inner.__send__(
+    :is_a?,
+    ::Myco.find_constant(:ZeroOrMore)
+  )}) {(
+    self.inner.__send__(
+      :inlaid=,
+      [[
+        :capture,
+        [
+          :m_split,
+          self.captargs
+        ]
+      ]]
+    )
+    a = self.inner.sequence
+    [
+      [
+        :capture,
+        [:m_start]
+      ],
+      *a,
+      [
+        :capture,
+        [
+          :m_end,
+          self.captargs
+        ]
+      ]
+    ]
+  )}) {(
+    a = self.inner.sequence
+    [
+      [
+        :capture,
+        [:c_start]
+      ],
+      *a,
+      [
+        :capture,
+        [
+          :c_end,
+          self.captargs
+        ]
+      ]
+    ]
+  )})})}
+  ::Myco.find_constant(:NamedTextCapture).component_eval {(declare_meme(:sequence, [], nil, ::Myco.cscope.dup) { |*| (
+    a = self.inner.sequence
+    [
+      [
+        :capture,
+        [:s_start]
+      ],
+      *a,
+      [
+        :capture,
+        [
+          :s_end,
+          self.captargs
+        ]
+      ]
+    ]
+  )})}
+  ::Myco.find_constant(:NamedTokenCapture).component_eval {(declare_meme(:sequence, [], nil, ::Myco.cscope.dup) { |*| (
+    a = self.inner.sequence
+    [
+      [
+        :capture,
+        [:t_start]
+      ],
+      *a,
+      [
+        :capture,
+        [
+          :t_end,
+          self.captargs
+        ]
+      ]
+    ]
+  )})}
+  ::Myco.find_constant(:Reduction).component_eval {(declare_meme(:sequence, [], nil, ::Myco.cscope.dup) { |*| (
+    a = self.inner.sequence
+    [
+      [
+        :capture,
+        [:r_start]
+      ],
+      *a,
+      [
+        :capture,
+        [
+          :r_end,
+          self.captargs
+        ]
+      ]
+    ]
+  )})}
+)}})
+.tap { |__c__| __c__.__name__ = :Constructions })}}.instance

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

@@ -0,0 +1,65 @@
+
+Grammar < BasicObject, Patterns::ShorthandMethods {
+  
+  Rule < Patterns::UnaryBase {
+    construct_rule: inner.construct
+    construct: RuleReference.new(name:name)
+  }
+  
+  RuleReference < Constructions::UnaryBase {
+    var name
+    sequence: [[:call, name]]
+    bytecode: |m| m.call(name)
+    bytecode_can_capture: true
+  }
+  
+  var rule_table: ::Hash.new
+  
+  # Force evaluation of the rule tree in a way that
+  # doesn't get stuck in an infinite recursion.
+  construct_all_rules: {
+    rules.root.construct_rule
+    seen_keys = []
+    loop {
+      new_keys = rule_table.keys - seen_keys
+      new_keys.empty? && break
+      new_keys.each |key| {
+        rule_table[key].construct_rule
+        seen_keys.push(key)
+      }
+    }
+  }
+  
+  [decorators]
+  
+  # TODO: streamline syntax for this definition to make it more intuitive
+  token: Decorator {
+    apply: |meme| {
+      orig_meme = meme.dup
+      meme.body = Proc.new { orig_meme.result.token(:"t_"meme.name"") }
+    }
+    [transforms]
+    cache: true
+  }
+  
+  var rule: Decorator {
+    apply: |meme| {
+      name = meme.name
+      # TODO: use some kind of Decorator#wrap mechanism instead
+      meme.target.declare_meme(name, [:var]) {
+        outer_self = self
+        rule = Rule {
+          name: name
+          inner: meme.result_for(outer_self)
+        }
+        rule_table[name] = rule
+        rule
+      }
+    }
+    [transforms]
+    expose: false # Exposing the original meme would overwrite the wrapped one
+  }
+  
+  [rules]
+  rule root: Patterns::AnyCharacter.new.*
+}

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

@@ -0,0 +1,83 @@
+
+::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.cscope.for_method_definition.const_set(:Grammar, ::Myco::Component.new([
+  ::Myco.find_constant(:BasicObject),
+  ::Myco.find_constant(:Patterns)::ShorthandMethods
+], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+  ::Myco.cscope.for_method_definition.const_set(:Rule, ::Myco::Component.new([::Myco.find_constant(:Patterns)::UnaryBase], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {(
+    declare_meme(:construct_rule, [], nil, ::Myco.cscope.dup) { |*| (self.inner.construct)}
+    declare_meme(:construct, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:RuleReference).new({:name => self.name}))}
+  )}})
+  .tap { |__c__| __c__.__name__ = :Rule }
+  ::Myco.cscope.for_method_definition.const_set(:RuleReference, ::Myco::Component.new([::Myco.find_constant(:Constructions)::UnaryBase], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {(
+    declare_meme(:name, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+    declare_meme(:sequence, [], nil, ::Myco.cscope.dup) { |*| ([[
+      :call,
+      self.name
+    ]])}
+    declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |m| (m.call(self.name))}
+    declare_meme(:bytecode_can_capture, [], nil, ::Myco.cscope.dup) { |*| (true)}
+  )}})
+  .tap { |__c__| __c__.__name__ = :RuleReference }
+  declare_meme(:rule_table, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (::Hash.new)}
+  declare_meme(:construct_all_rules, [], nil, ::Myco.cscope.dup) { |*| (
+    self.rules.root.construct_rule
+    seen_keys = []
+    self.loop { || (
+      new_keys = self.rule_table.keys.__send__(
+        :-,
+        seen_keys
+      )
+      ::Myco.branch_op(:"&&", new_keys.__send__(:empty?)) {self.__send__(:break)}
+      new_keys.each { |key| (
+        self.rule_table.__send__(
+          :[],
+          key
+        ).construct_rule
+        seen_keys.push(key)
+      )}
+    )}
+  )}
+  __category__(:decorators).component_eval {(
+    declare_meme(:token, [], nil, ::Myco.cscope.dup) { |*| (::Myco::Component.new([::Myco.find_constant(:Decorator)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+    .tap { |__c__| __c__.__last__ = __c__.component_eval {(
+      declare_meme(:apply, [], nil, ::Myco.cscope.dup) { |meme| (
+        orig_meme = meme.dup
+        meme.__send__(
+          :body=,
+          ::Myco.find_constant(:Proc).new { || (orig_meme.result.token(:"t_#{meme.name}"))}
+        )
+      )}
+      __category__(:transforms).component_eval {(declare_meme(:cache, [], nil, ::Myco.cscope.dup) { |*| (true)})}
+    )}}.instance)}
+    declare_meme(:rule, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (::Myco::Component.new([::Myco.find_constant(:Decorator)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+    .tap { |__c__| __c__.__last__ = __c__.component_eval {(
+      declare_meme(:apply, [], nil, ::Myco.cscope.dup) { |meme| (
+        name = meme.name
+        meme.target.declare_meme(
+          name,
+          [:var]
+        ) { || (
+          outer_self = self
+          rule = ::Myco::Component.new([::Myco.find_constant(:Rule)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+          .tap { |__c__| __c__.__last__ = __c__.component_eval {(
+            declare_meme(:name, [], nil, ::Myco.cscope.dup) { |*| (name)}
+            declare_meme(:inner, [], nil, ::Myco.cscope.dup) { |*| (meme.result_for(outer_self))}
+          )}}.instance
+          self.rule_table.__send__(
+            :[]=,
+            name,
+            rule
+          )
+          rule
+        )}
+      )}
+      __category__(:transforms).component_eval {(declare_meme(:expose, [], nil, ::Myco.cscope.dup) { |*| (false)})}
+    )}}.instance)}
+  )}
+  __category__(:rules).component_eval {(declare_meme(:root, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:Patterns)::AnyCharacter.new.__send__(:*))})}
+)}})
+.tap { |__c__| __c__.__name__ = :Grammar })}}.instance

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

@@ -0,0 +1,139 @@
+
+Instructions < EmptyObject {
+  
+  ##
+  # Basic Instructions
+  
+  # Test the character pointed to by the current index into the subject.
+  # Continue if the character |code| is equal, otherwise fail.
+  char: |code|
+    (subject.at(idx) == code)
+      &? (self.ip = ip + 1; self.idx = idx + 1)
+      ?? (self.ip = null) # failure
+  
+  # Move the instruction pointer forward by |label| instructions.
+  jump: |label|
+    self.ip = ip + label
+  
+  # Create a backtrack entry on the stack, pointing |label| instructions ahead.
+  choice: |label| {
+    stack.push([ip + label, idx, captures.dup])
+    self.ip = ip + 1
+  }
+  
+  # Push two-part return address onto the stack and goto start of |new_ipk|
+  call: |new_ipk| {
+    stack.push([ip+1, ipk])
+    self.ip = 0
+    self.ipk = new_ipk
+  }
+  
+  # Return from a call by popping the return address and jumping to it.
+  # It is assumed that the top of the stack is a return address from a :call.
+  return: {
+    addr = stack.pop
+    addr &? (
+      self.ipk = addr.pop
+      self.ip  = addr.pop
+      true
+    ) ?? finish
+  }
+  
+  # Pop and discard the backtrack entry from the stack and jump to |label|.
+  # It is assumed that the top of the stack is a backtrack entry from a :choice.
+  commit: |label| {
+    stack.pop
+    self.ip = ip + label
+  }
+  
+  # Note the current subject index and the given metadata for post-processing.
+  capture: |metadata| {
+    captures.push([idx, metadata])
+    self.ip = ip + 1
+  }
+  
+  # Pop the backtrack entry off the stack and copy the state from it,
+  # effectively pursuing the alternative posed by the last :choice.
+  handle_fail:
+    self.stack.empty?
+      &? ErrorCondition.new
+      ?? (
+        entry = stack.pop
+        size = entry.size
+        size == 3 &? ( # backtrack
+          self.captures = entry.pop
+          self.idx      = entry.pop
+          self.ip       = entry.pop
+          true
+        ) ?? ( # return and mark fail
+          size == 2 &? (
+            self.ipk = entry.pop
+            self.ip  = null
+          ) ?? ErrorCondition.new
+        )
+      )
+  
+  # Signal a successful match at the end of the complete pattern
+  finish:
+    self.ip = true
+  
+  ##
+  # Optimized Instructions
+  #
+  # These instructions could be expressed in terms of the Basic Instructions,
+  # but are more efficiently executed if given special implementations.
+  
+  # Like char, but accept any char whose code is a valid key in |table|
+  charset: |table|
+    (code=subject.at(idx); code && table.key?(code))
+      &? (self.ip = ip + 1; self.idx = idx + 1)
+      ?? (self.ip = null) # failure
+  
+  # Like char, but accept any char whose code is between |start| and |stop|
+  charrange: |start, stop|
+    (code=subject.at(idx); code && code>=start && code<=stop)
+      &? (self.ip = ip + 1; self.idx = idx + 1)
+      ?? (self.ip = null) # failure
+  
+  # (Kleene star applied to a charset)
+  span: |table| loop {
+    (code=subject.at(idx); code && table.key?(code))
+      &? (self.idx = idx + 1)
+      ?? (self.ip = ip + 1; break)
+  }
+  
+  # Match any character, |count| number of times.
+  any: |count|
+    (self.idx + count > subject.size)
+      &? (self.ip = null; true) # failure
+      ?? (
+        self.ip = ip + 1
+        self.idx = idx + count
+      )
+  
+  # Update the state for the backtrack entry on the top of the stack
+  # but don't change the fail address; then jump to |label|.
+  partial_commit: |label| {
+    entry = stack.pop
+    stack.push([entry.first, idx, captures.dup])
+    self.ip = ip + label
+  }
+  
+  # Pop the backtrack entry and restore state but jump to |label|
+  # instead of jumping to the popped fail address.
+  back_commit: |label| {
+    entry = stack.pop
+    self.captures = entry.pop
+    self.idx      = entry.pop
+    self.ip = ip + label
+  }
+  
+  # Pop a backtrack entry off the stack and discard it, then fail.
+  fail_twice: {
+    self.stack.empty?
+      &? ErrorCondition.new
+      ?? stack.pop
+    handle_fail
+  }
+  
+}