myco 0.1.8 → 0.1.9

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

@@ -0,0 +1,296 @@
+
+::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.cscope.for_method_definition::Composite = ::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::UnaryBase = ::Myco::Component.new([::Myco.find_constant(:Common)::Patterns::UnaryBase], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+    .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}}
+    .tap { |__c__| __c__.__name__ = :UnaryBase }
+    ::Myco.cscope.for_method_definition::BinaryBase = ::Myco::Component.new([::Myco.find_constant(:Common)::Patterns::BinaryBase], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+    .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}}
+    .tap { |__c__| __c__.__name__ = :BinaryBase }
+    ::Myco.cscope.for_method_definition::NegativePredicate = ::Myco::Component.new([::Myco.find_constant(:UnaryBase)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+    .tap { |__c__| __c__.__last__ = __c__.component_eval {(declare_meme(:construct_type, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:Constructions)::NegativePredicate)})}}
+    .tap { |__c__| __c__.__name__ = :NegativePredicate }
+    ::Myco.cscope.for_method_definition::PositivePredicate = ::Myco::Component.new([::Myco.find_constant(:UnaryBase)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+    .tap { |__c__| __c__.__last__ = __c__.component_eval {(declare_meme(:construct_type, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:Constructions)::PositivePredicate)})}}
+    .tap { |__c__| __c__.__name__ = :PositivePredicate }
+    ::Myco.cscope.for_method_definition::OneOrMore = ::Myco::Component.new([::Myco.find_constant(:UnaryBase)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+    .tap { |__c__| __c__.__last__ = __c__.component_eval {(declare_meme(:construct_type, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:Constructions)::OneOrMore)})}}
+    .tap { |__c__| __c__.__name__ = :OneOrMore }
+    ::Myco.cscope.for_method_definition::ZeroOrOne = ::Myco::Component.new([::Myco.find_constant(:UnaryBase)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+    .tap { |__c__| __c__.__last__ = __c__.component_eval {(declare_meme(:construct_type, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:Constructions)::ZeroOrOne)})}}
+    .tap { |__c__| __c__.__name__ = :ZeroOrOne }
+    ::Myco.cscope.for_method_definition::ZeroOrMore = ::Myco::Component.new([::Myco.find_constant(:UnaryBase)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+    .tap { |__c__| __c__.__last__ = __c__.component_eval {(declare_meme(:construct_type, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:Constructions)::ZeroOrMore)})}}
+    .tap { |__c__| __c__.__name__ = :ZeroOrMore }
+    ::Myco.cscope.for_method_definition::OrderedChoice = ::Myco::Component.new([::Myco.find_constant(:BinaryBase)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+    .tap { |__c__| __c__.__last__ = __c__.component_eval {(declare_meme(:construct_type, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:Constructions)::OrderedChoice)})}}
+    .tap { |__c__| __c__.__name__ = :OrderedChoice }
+    ::Myco.cscope.for_method_definition::Concatenation = ::Myco::Component.new([::Myco.find_constant(:BinaryBase)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+    .tap { |__c__| __c__.__last__ = __c__.component_eval {(declare_meme(:construct_type, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:Constructions)::Concatenation)})}}
+    .tap { |__c__| __c__.__name__ = :Concatenation }
+  )}}
+  .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::UnaryBase = ::Myco::Component.new([::Myco.find_constant(:Common)::Constructions::UnaryBase], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+    .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}}
+    .tap { |__c__| __c__.__name__ = :UnaryBase }
+    ::Myco.cscope.for_method_definition::BinaryBase = ::Myco::Component.new([::Myco.find_constant(:Common)::Constructions::BinaryBase], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+    .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}}
+    .tap { |__c__| __c__.__name__ = :BinaryBase }
+    ::Myco.cscope.for_method_definition::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::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::OneOrMore = ::Myco::Component.new([::Myco.find_constant(:UnaryBase)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+    .tap { |__c__| __c__.__last__ = __c__.component_eval {(declare_meme(:inlaid, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil})}}
+    .tap { |__c__| __c__.__name__ = :OneOrMore }
+    ::Myco.cscope.for_method_definition::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::ZeroOrMore = ::Myco::Component.new([::Myco.find_constant(:UnaryBase)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+    .tap { |__c__| __c__.__last__ = __c__.component_eval {(declare_meme(:inlaid, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil})}}
+    .tap { |__c__| __c__.__name__ = :ZeroOrMore }
+    ::Myco.cscope.for_method_definition::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::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 }
+  )}}
+  .tap { |__c__| __c__.__name__ = :Constructions }
+  ::Myco.find_constant(:Patterns).component_eval {(
+    ::Myco.find_constant(:NegativePredicate).component_eval {(declare_meme(:!, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:PositivePredicate).new({:inner => self.inner}))})}
+    ::Myco.find_constant(:PositivePredicate).component_eval {(declare_meme(:!, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:NegativePredicate).new({:inner => self.inner}))})}
+    ::Myco.find_constant(:OrderedChoice).component_eval {(declare_meme(:/, [], nil, ::Myco.cscope.dup) { |other| (self.private.binary_right_assoc(
+      self,
+      other,
+      ::Myco.find_constant(:OrderedChoice)
+    ))})}
+    ::Myco.find_constant(:Concatenation).component_eval {(declare_meme(:+, [], nil, ::Myco.cscope.dup) { |other=false| (::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", other) {self.private.binary_right_assoc(
+      self,
+      other,
+      ::Myco.find_constant(:Concatenation)
+    )}) {::Myco.find_constant(:OneOrMore).new({:inner => self})})})}
+  )}
+  ::Myco.find_constant(:Constructions).component_eval {(
+    ::Myco.find_constant(:NegativePredicate).component_eval {(declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
+      local_fail = g.new_label
+      old_fail = g.overall_fail
+      g.__send__(
+        :overall_fail=,
+        local_fail
+      )
+      self.__send__(
+        :if,
+        self.inner.__send__(:bytecode_can_capture?)
+      ) { || (g.push_temp_captures)}
+      g.push_idx
+      self.inner.bytecode(g)
+      g.pop_to_set_idx
+      self.__send__(
+        :if,
+        self.inner.__send__(:bytecode_can_capture?)
+      ) { || (g.pop_to_reject_captures)}
+      g.__send__(
+        :overall_fail=,
+        old_fail
+      )
+      g.goto(g.overall_fail)
+      local_fail.__send__(:set!)
+      g.pop_to_set_idx
+      self.__send__(
+        :if,
+        self.inner.__send__(:bytecode_can_capture?)
+      ) { || (g.pop_to_reject_captures)}
+      g.__send__(
+        :overall_fail=,
+        old_fail
+      )
+    )})}
+    ::Myco.find_constant(:PositivePredicate).component_eval {(declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
+      local_done = g.new_label
+      local_fail = g.new_label
+      old_fail = g.overall_fail
+      g.__send__(
+        :overall_fail=,
+        local_fail
+      )
+      self.__send__(
+        :if,
+        self.inner.__send__(:bytecode_can_capture?)
+      ) { || (g.push_temp_captures)}
+      g.push_idx
+      self.inner.bytecode(g)
+      g.pop_to_set_idx
+      self.__send__(
+        :if,
+        self.inner.__send__(:bytecode_can_capture?)
+      ) { || (g.pop_to_accept_captures)}
+      g.__send__(
+        :overall_fail=,
+        old_fail
+      )
+      g.goto(local_done)
+      local_fail.__send__(:set!)
+      g.pop_to_set_idx
+      self.__send__(
+        :if,
+        self.inner.__send__(:bytecode_can_capture?)
+      ) { || (g.pop_to_reject_captures)}
+      g.__send__(
+        :overall_fail=,
+        old_fail
+      )
+      g.goto(g.overall_fail)
+      local_done.__send__(:set!)
+    )})}
+    ::Myco.find_constant(:OneOrMore).component_eval {(declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
+      local_retry = g.new_label
+      local_fail = g.new_label
+      old_fail = g.overall_fail
+      g.__send__(
+        :overall_fail=,
+        local_fail
+      )
+      g.push_false
+      local_retry.__send__(:set!)
+      self.__send__(
+        :if,
+        self.inner.__send__(:bytecode_can_capture?)
+      ) { || (g.push_temp_captures)}
+      self.inner.bytecode(g)
+      (Rubinius::Type.object_respond_to?(self.inlaid, :call).false? ? ::Myco::Void : self.inlaid.call)
+      self.__send__(
+        :if,
+        self.inner.__send__(:bytecode_can_capture?)
+      ) { || (g.pop_to_accept_captures)}
+      g.pop
+      g.push_true
+      g.goto(local_retry)
+      local_fail.__send__(:set!)
+      self.__send__(
+        :if,
+        self.inner.__send__(:bytecode_can_capture?)
+      ) { || (g.pop_to_reject_captures)}
+      g.__send__(
+        :overall_fail=,
+        old_fail
+      )
+      g.goto_if_false(g.overall_fail)
+    )})}
+    ::Myco.find_constant(:ZeroOrOne).component_eval {(declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
+      local_done = g.new_label
+      local_fail = g.new_label
+      old_fail = g.overall_fail
+      g.__send__(
+        :overall_fail=,
+        local_fail
+      )
+      self.__send__(
+        :if,
+        self.inner.__send__(:bytecode_can_capture?)
+      ) { || (g.push_temp_captures)}
+      g.push_idx
+      self.inner.bytecode(g)
+      g.pop
+      self.__send__(
+        :if,
+        self.inner.__send__(:bytecode_can_capture?)
+      ) { || (g.pop_to_accept_captures)}
+      g.__send__(
+        :overall_fail=,
+        old_fail
+      )
+      g.goto(local_done)
+      local_fail.__send__(:set!)
+      g.pop_to_set_idx
+      self.__send__(
+        :if,
+        self.inner.__send__(:bytecode_can_capture?)
+      ) { || (g.pop_to_reject_captures)}
+      g.__send__(
+        :overall_fail=,
+        old_fail
+      )
+      local_done.__send__(:set!)
+    )})}
+    ::Myco.find_constant(:ZeroOrMore).component_eval {(declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
+      local_retry = g.new_label
+      local_fail = g.new_label
+      old_fail = g.overall_fail
+      g.__send__(
+        :overall_fail=,
+        local_fail
+      )
+      local_retry.__send__(:set!)
+      self.__send__(
+        :if,
+        self.inner.__send__(:bytecode_can_capture?)
+      ) { || (g.push_temp_captures)}
+      self.inner.bytecode(g)
+      (Rubinius::Type.object_respond_to?(self.inlaid, :call).false? ? ::Myco::Void : self.inlaid.call)
+      self.__send__(
+        :if,
+        self.inner.__send__(:bytecode_can_capture?)
+      ) { || (g.pop_to_accept_captures)}
+      g.goto(local_retry)
+      local_fail.__send__(:set!)
+      self.__send__(
+        :if,
+        self.inner.__send__(:bytecode_can_capture?)
+      ) { || (g.pop_to_reject_captures)}
+      g.__send__(
+        :overall_fail=,
+        old_fail
+      )
+    )})}
+    ::Myco.find_constant(:OrderedChoice).component_eval {(declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
+      local_done = g.new_label
+      local_fail = g.new_label
+      old_fail = g.overall_fail
+      g.__send__(
+        :overall_fail=,
+        local_fail
+      )
+      self.__send__(
+        :if,
+        self.first.__send__(:bytecode_can_capture?)
+      ) { || (g.push_temp_captures)}
+      g.push_idx
+      self.first.bytecode(g)
+      g.pop
+      self.__send__(
+        :if,
+        self.first.__send__(:bytecode_can_capture?)
+      ) { || (g.pop_to_accept_captures)}
+      g.__send__(
+        :overall_fail=,
+        old_fail
+      )
+      g.goto(local_done)
+      local_fail.__send__(:set!)
+      g.pop_to_set_idx
+      self.__send__(
+        :if,
+        self.first.__send__(:bytecode_can_capture?)
+      ) { || (g.pop_to_reject_captures)}
+      g.__send__(
+        :overall_fail=,
+        old_fail
+      )
+      self.second.bytecode(g)
+      local_done.__send__(:set!)
+    )})}
+    ::Myco.find_constant(:Concatenation).component_eval {(declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
+      self.first.bytecode(g)
+      self.second.bytecode(g)
+    )})}
+  )}
+)}}
+.tap { |__c__| __c__.__name__ = :Composite })}}.instance

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

@@ -1,17 +1,5 @@
 
-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
-  }
+Grammar < BasicObject, Common::Patterns::ShorthandMethods {
   
   var rule_table: ::Ruby::Hash.new
   
@@ -21,7 +9,7 @@ Grammar < BasicObject, Patterns::ShorthandMethods {
     # Consider all rules with "root" in the name
     rules.memes.each |name, meme| {
       meme.name.to_s.include?("root") && (
-        meme.result_for(rules).construct_rule
+        meme.result_for(rules).inner.construct
       )
     }
     
@@ -30,7 +18,7 @@ Grammar < BasicObject, Patterns::ShorthandMethods {
       new_keys = rule_table.keys - seen_keys
       new_keys.empty? && break
       new_keys.each |key| {
-        rule_table[key].construct_rule
+        rule_table[key].inner.construct
         seen_keys.push(key)
       }
     }
@@ -48,20 +36,15 @@ Grammar < BasicObject, Patterns::ShorthandMethods {
   }
   
   const rule: Decorator {
-    # TODO: remove need for helper method by adding parser aborts/continuations to pegleromyces
-    helper_method: |name, meme, outer_self| Rule {
-      name: name
-      inner: meme.result_for(outer_self)
-      blargy: [name, meme, outer_self]
-    }
-    
     apply: |meme| {
       name = meme.name
-      meme_self = self
       # TODO: use some kind of Decorator#wrap mechanism instead
       meme.target.declare_meme(name, [:memoize]) {
         outer_self = self
-        rule = meme_self.helper_method(name, meme, outer_self)
+        rule = Capture::Patterns::RuleCall {
+          name: name
+          inner: meme.result_for(outer_self)
+        }
         rule_table[name] = rule
         rule
       }
@@ -71,5 +54,5 @@ Grammar < BasicObject, Patterns::ShorthandMethods {
   }
   
   [rules]
-  rule root: Patterns::AnyCharacter.new.*
+  rule root: String::Patterns::AnyCharacter.new.*
 }

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

@@ -2,32 +2,15 @@
 ::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.cscope.for_method_definition::Grammar = ::Myco::Component.new([
   ::Myco.find_constant(:BasicObject),
-  ::Myco.find_constant(:Patterns)::ShorthandMethods
+  ::Myco.find_constant(:Common)::Patterns::ShorthandMethods
 ], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-  ::Myco.cscope.for_method_definition::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::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) { |*| (::Object::Hash.new)}
   declare_meme(:construct_all_rules, [], nil, ::Myco.cscope.dup) { |*| (
     self.rules.memes.each { |name, meme| (::Myco.branch_op(:"&&", meme.name.to_s.__send__(
       :include?,
       "root"
-    )) {meme.result_for(self.rules).construct_rule})}
+    )) {meme.result_for(self.rules).inner.construct})}
     seen_keys = []
     self.loop { || (
       new_keys = self.rule_table.keys.__send__(
@@ -39,7 +22,7 @@
         self.rule_table.__send__(
           :[],
           key
-        ).construct_rule
+        ).inner.construct
         seen_keys.push(key)
       )}
     )}
@@ -58,29 +41,18 @@
     )}}.instance)}
     declare_meme(:rule, [[:const, []]], 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(:helper_method, [], nil, ::Myco.cscope.dup) { |name, meme, outer_self| (::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))}
-        declare_meme(:blargy, [], nil, ::Myco.cscope.dup) { |*| ([
-          name,
-          meme,
-          outer_self
-        ])}
-      )}}.instance)}
       declare_meme(:apply, [], nil, ::Myco.cscope.dup) { |meme| (
         name = meme.name
-        meme_self = self
         meme.target.declare_meme(
           name,
           [:memoize]
         ) { || (
           outer_self = self
-          rule = meme_self.helper_method(
-            name,
-            meme,
-            outer_self
-          )
+          rule = ::Myco::Component.new([::Myco.find_constant(:Capture)::Patterns::RuleCall], ::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,
@@ -92,6 +64,6 @@
       __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__(:*))})}
+  __category__(:rules).component_eval {(declare_meme(:root, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:String)::Patterns::AnyCharacter.new.__send__(:*))})}
 )}}
 .tap { |__c__| __c__.__name__ = :Grammar })}}.instance

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

@@ -1,42 +1,144 @@
 
-Parser < BasicObject {
-  
-  var grammar: Grammar.new
-  var string: ""
-  
-  var result: null
-  
-  memoize make_sequence_table: |grammar| {
-    grammar.construct_all_rules
-    grammar.rule_table.map |k,v| {
-      [k, v.construct_rule.sequence + [[:return]]]
-    }.to_h
-  }
-  
-  new_machine: Machine.new(
-    sequence_table: make_sequence_table(grammar)
-    subject: string.each_char.map(&:ord)
-  )
-  
-  new_processor: Processor.new(
-    builder: new_builder
-    string: string
-  )
-  
-  new_builder: Builder.new
-  
-  parse: |string=null| {
-    string && (self.string = string)
-    machine = new_machine
-    
-    machine.execute
-    
-    unless(machine.had_failure) {
-      processor = new_processor
-      processor.capture_items = machine.captures
-      self.result = processor.process
+Common << {
+  Parser < BasicObject {
+    State < BasicObject {
+      var string
+      var start_idx
+      var end_idx
+      var rule
+      var result
+      
+      var error_idx
+      var error_row
+      var error_col
+      
+      raise_error: self.error_idx && raise(SyntaxError
+        "Unexpected character with parser: "self.rule \
+          " near line: "self.error_row \
+          ", column: "self.error_col".\n" \
+          self.string.each_line.to_a[self.error_row - 1]"" \
+          (' ' * [(self.error_col - 1), 0].max)"^"
+      )
+    }
+    
+    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
     }
     
-    self
+    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")
+    
+    
+    # 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
+    }
   }
 }