myco 0.1.8 → 0.1.9

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

@@ -3,6 +3,7 @@ BytecodeHelpers < BasicDecorators {
   ##
   # Bytecode Generation Helper Methods
   
+  var debug_mode: false
   var overall_fail: new_label
   
   g: self # For consistency
@@ -35,6 +36,9 @@ BytecodeHelpers < BasicDecorators {
     g.push_captures; g.send(:concat, 1); g.set_captures; g.pop
   
   push_subject_at_idx:
+    g.push_subject; g.push_idx; g.send(:at, 1)
+  
+  push_subject_chr_at_idx:
     g.push_subject; g.push_idx; g.send(:chr_at, 1)
   
   push_new_table:
@@ -114,7 +118,10 @@ BytecodeHelpers < BasicDecorators {
     g.local_count = 2
     g.local_names = [:subject, :idx]
     
-    # g.puts_string("trying.. "g.name"") # TODO: enable with debug flag
+    g.debug_mode && (
+      g.push_idx; g.inspect_top; g.pop
+      g.puts_string("trying.. "g.name"")
+    )
   }
   
   # Wrap up a compiled parser method
@@ -123,13 +130,19 @@ BytecodeHelpers < BasicDecorators {
     
     # end
     g.push_idx
-    # g.puts_string("SUCCESS! "g.name"") # TODO: enable with debug flag
+    g.debug_mode && (
+      g.push_idx; g.inspect_top; g.pop
+      g.puts_string("SUCCESS! "g.name"")
+    )
     g.goto(overall_done)
     
     # fail
     g.overall_fail.set!
     g.push_nil
-    # g.puts_string("failure: "g.name"") # TODO: enable with debug flag
+    g.debug_mode && (
+      g.push_idx; g.inspect_top; g.pop
+      g.puts_string("failure: "g.name"")
+    )
     
     overall_done.set!
     g.ret
@@ -143,4 +156,13 @@ BytecodeHelpers < BasicDecorators {
     item.is_a?(Array)
       &? push_literal_array(item)
       ?? push_literal(item)
+  
+  capture: |*metadata| {
+    g.push_captures
+      g.push_idx
+      g.push_literal_array(metadata)
+      g.make_array(2)
+    g.send(:push, 1)
+    g.pop
+  }
 }

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

@@ -2,6 +2,7 @@
 ::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.cscope.for_method_definition::BytecodeHelpers = ::Myco::Component.new([::Myco.find_constant(:BasicDecorators)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
+  declare_meme(:debug_mode, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (false)}
   declare_meme(:overall_fail, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (self.new_label)}
   declare_meme(:g, [], nil, ::Myco.cscope.dup) { |*| (self)}
   declare_meme(:puts_string, [], nil, ::Myco.cscope.dup) { |string| (
@@ -57,6 +58,14 @@
     self.g.pop
   )}
   declare_meme(:push_subject_at_idx, [], nil, ::Myco.cscope.dup) { |*| (
+    self.g.push_subject
+    self.g.push_idx
+    self.g.send(
+      :at,
+      1
+    )
+  )}
+  declare_meme(:push_subject_chr_at_idx, [], nil, ::Myco.cscope.dup) { |*| (
     self.g.push_subject
     self.g.push_idx
     self.g.send(
@@ -158,13 +167,31 @@
         :idx
       ]
     )
+    ::Myco.branch_op(:"&&", self.g.debug_mode) {(
+      self.g.push_idx
+      self.g.inspect_top
+      self.g.pop
+      self.g.puts_string("trying.. #{self.g.name}")
+    )}
   )}
   declare_meme(:rule_finish, [], nil, ::Myco.cscope.dup) { |*| (
     overall_done = self.g.new_label
     self.g.push_idx
+    ::Myco.branch_op(:"&&", self.g.debug_mode) {(
+      self.g.push_idx
+      self.g.inspect_top
+      self.g.pop
+      self.g.puts_string("SUCCESS! #{self.g.name}")
+    )}
     self.g.goto(overall_done)
     self.g.overall_fail.__send__(:set!)
     self.g.push_nil
+    ::Myco.branch_op(:"&&", self.g.debug_mode) {(
+      self.g.push_idx
+      self.g.inspect_top
+      self.g.pop
+      self.g.puts_string("failure: #{self.g.name}")
+    )}
     overall_done.__send__(:set!)
     self.g.ret
     self.g.close
@@ -177,5 +204,16 @@
     :is_a?,
     ::Myco.find_constant(:Array)
   )) {self.push_literal_array(item)}) {self.push_literal(item)})}
+  declare_meme(:capture, [], nil, ::Myco.cscope.dup) { |*metadata| (
+    self.g.push_captures
+    self.g.push_idx
+    self.g.push_literal_array(metadata)
+    self.g.make_array(2)
+    self.g.send(
+      :push,
+      1
+    )
+    self.g.pop
+  )}
 )}}
 .tap { |__c__| __c__.__name__ = :BytecodeHelpers })}}.instance

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

@@ -0,0 +1,152 @@
+
+Capture < EmptyObject {
+  Patterns < EmptyObject {
+    UnaryBase < Common::Patterns::UnaryBase { }
+    
+    NamedCapture      < UnaryBase {
+      construct: Constructions::NamedCapture.new(
+        inner: inner.construct
+        captargs: [self.name]
+      )
+    }
+    NamedTextCapture  < UnaryBase {
+      construct: Constructions::NamedTextCapture.new(
+        inner: inner.construct
+        captargs: [self.name]
+      )
+    }
+    NamedTokenCapture < UnaryBase {
+      construct: Constructions::NamedTokenCapture.new(
+        inner: inner.construct
+        captargs: [self.name]
+      )
+    }
+    Reduction         < UnaryBase { var block, var args: []
+      construct: Constructions::Reduction.new(
+        inner: inner.construct
+        captargs: [self.code, *self.args]
+      )
+    }
+    
+    RuleCall          < UnaryBase { var name
+      construct: Constructions::RuleCall.new(name: name)
+    }
+  }
+  
+  Constructions < EmptyObject {
+    UnaryBase < Common::Constructions::UnaryBase { }
+    
+    NamedCapture      < UnaryBase { var captargs }
+    NamedTextCapture  < UnaryBase { var captargs }
+    NamedTokenCapture < UnaryBase { var captargs }
+    Reduction         < UnaryBase { var captargs }
+    
+    RuleCall          < UnaryBase { var name }
+  }
+  
+  Patterns << {
+    ##
+    # Reduction and associated named captures implementation
+    
+    Reduction << {
+      Environment < EmptyObject, BasicDecorators {
+        var captures # A Hash of capture names to values
+        var builder # The fallback delegate for methods that are not capture names
+        
+        method_missing: |name, *args, &block|
+          captures.fetch(name) { builder.__send__(name, *args, &block) }
+        
+        # Implement the action for the reduction in the '!' method.
+        # It will have access to the captures via method_missing.
+        "!": null
+      }
+      
+      code: block.block.compiled_code
+    }
+  }
+  
+  Constructions << {
+    UnaryBase << { const bytecode_can_capture?: true }
+    
+    NamedCapture << { bytecode: |g| {
+      Rubinius::Type.object_respond_to?(inner, :inlaid) &? (
+        inner.inlaid = &{ g.capture(:m_split, captargs) }
+        g.capture(:m_start)
+        inner.bytecode(g)
+        g.capture(:m_end, captargs)
+      ) ?? (
+        g.capture(:c_start)
+        inner.bytecode(g)
+        g.capture(:c_end, captargs)
+      )
+    }}
+    
+    NamedTextCapture << { bytecode: |g| {
+      g.capture(:s_start)
+      inner.bytecode(g)
+      g.capture(:s_end, captargs)
+    }}
+    
+    NamedTokenCapture << { bytecode: |g| {
+      g.capture(:t_start)
+      inner.bytecode(g)
+      g.capture(:t_end, captargs)
+    }}
+    
+    Reduction << { bytecode: |g| {
+      g.capture(:r_start)
+      inner.bytecode(g)
+      g.capture(:r_end, captargs)
+    }}
+    
+    RuleCall << { bytecode: |g| {
+      memoize           = true
+      result_check      = g.new_label
+      memo_result_check = g.new_label
+      local_success     = g.new_label
+      local_fail        = g.new_label
+      
+      # Push @captures onto stack and set @captures to a new empty array
+      g.push_temp_captures
+      
+      if(memoize) {
+        # Check if a memoized result exists;
+        # If one does, go straight to memo_result_check label
+        g.memo_or_eq_new_hash(name)
+        g.goto_if_memo_for_idx(name, memo_result_check)
+      }
+      
+      # Call the method; sets @captures and returns the result_idx (or nil)
+      g.push_self
+        g.push_subject
+        g.push_idx
+      g.send(name, 2)
+      
+      # Check result and memoize the result
+      result_check.set!
+      g.copy_result_to_memo(name)
+      g.dup_top
+      g.goto_if_true(local_success)
+      g.goto(local_fail)
+      
+      if(memoize) {
+        # Check result, but skip memo copy
+        memo_result_check.set!
+        g.dup_top
+        g.goto_if_true(local_success)
+        g.goto(local_fail)
+      }
+      
+      # Failure, reject index and captures
+      local_fail.set!
+      g.pop # reject idx (which is actually null here)
+      g.pop_to_reject_captures
+      g.goto(g.overall_fail)
+      
+      # Success, accept new index and captures
+      local_success.set!
+      g.pop_to_set_idx # set to the new index given by the call's return value
+      g.pop_to_accept_captures
+    }}
+  }
+}

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

@@ -0,0 +1,189 @@
+
+::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.cscope.for_method_definition::Capture = ::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::NamedCapture = ::Myco::Component.new([::Myco.find_constant(:UnaryBase)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+    .tap { |__c__| __c__.__last__ = __c__.component_eval {(declare_meme(:construct, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:Constructions)::NamedCapture.new({
+      :inner => self.inner.construct,
+      :captargs => [self.name]
+    }))})}}
+    .tap { |__c__| __c__.__name__ = :NamedCapture }
+    ::Myco.cscope.for_method_definition::NamedTextCapture = ::Myco::Component.new([::Myco.find_constant(:UnaryBase)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+    .tap { |__c__| __c__.__last__ = __c__.component_eval {(declare_meme(:construct, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:Constructions)::NamedTextCapture.new({
+      :inner => self.inner.construct,
+      :captargs => [self.name]
+    }))})}}
+    .tap { |__c__| __c__.__name__ = :NamedTextCapture }
+    ::Myco.cscope.for_method_definition::NamedTokenCapture = ::Myco::Component.new([::Myco.find_constant(:UnaryBase)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+    .tap { |__c__| __c__.__last__ = __c__.component_eval {(declare_meme(:construct, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:Constructions)::NamedTokenCapture.new({
+      :inner => self.inner.construct,
+      :captargs => [self.name]
+    }))})}}
+    .tap { |__c__| __c__.__name__ = :NamedTokenCapture }
+    ::Myco.cscope.for_method_definition::Reduction = ::Myco::Component.new([::Myco.find_constant(:UnaryBase)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+    .tap { |__c__| __c__.__last__ = __c__.component_eval {(
+      declare_meme(:block, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+      declare_meme(:args, [[:var, []]], nil, ::Myco.cscope.dup) { |*| ([])}
+      declare_meme(:construct, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:Constructions)::Reduction.new({
+        :inner => self.inner.construct,
+        :captargs => [
+          self.code,
+          *self.args
+        ]
+      }))}
+    )}}
+    .tap { |__c__| __c__.__name__ = :Reduction }
+    ::Myco.cscope.for_method_definition::RuleCall = ::Myco::Component.new([::Myco.find_constant(: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(:construct, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:Constructions)::RuleCall.new({:name => self.name}))}
+    )}}
+    .tap { |__c__| __c__.__name__ = :RuleCall }
+  )}}
+  .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::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::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::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::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.cscope.for_method_definition::RuleCall = ::Myco::Component.new([::Myco.find_constant(:UnaryBase)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+    .tap { |__c__| __c__.__last__ = __c__.component_eval {(declare_meme(:name, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil})}}
+    .tap { |__c__| __c__.__name__ = :RuleCall }
+  )}}
+  .tap { |__c__| __c__.__name__ = :Constructions }
+  ::Myco.find_constant(:Patterns).component_eval {(::Myco.find_constant(:Reduction).component_eval {(
+    ::Myco.cscope.for_method_definition::Environment = ::Myco::Component.new([
+      ::Myco.find_constant(:EmptyObject),
+      ::Myco.find_constant(:BasicDecorators)
+    ], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+    .tap { |__c__| __c__.__last__ = __c__.component_eval {(
+      declare_meme(:captures, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+      declare_meme(:builder, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+      declare_meme(:method_missing, [], nil, ::Myco.cscope.dup) { |name, *args, &block| (self.captures.fetch(name) { || (self.builder.__send__(
+        name,
+        *args,
+        &block
+      ))})}
+      declare_meme(:!, [], nil, ::Myco.cscope.dup) { |*| (nil)}
+    )}}
+    .tap { |__c__| __c__.__name__ = :Environment }
+    declare_meme(:code, [], nil, ::Myco.cscope.dup) { |*| (self.block.block.compiled_code)}
+  )})}
+  ::Myco.find_constant(:Constructions).component_eval {(
+    ::Myco.find_constant(:UnaryBase).component_eval {(declare_meme(:bytecode_can_capture?, [[:const, []]], nil, ::Myco.cscope.dup) { |*| (true)})}
+    ::Myco.find_constant(:NamedCapture).component_eval {(declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", ::Myco.find_constant(:Rubinius)::Type.__send__(
+      :object_respond_to?,
+      self.inner,
+      :inlaid
+    )) {(
+      self.inner.__send__(
+        :inlaid=,
+        ::Object::Proc.new { || (g.capture(
+          :m_split,
+          self.captargs
+        ))}
+      )
+      g.capture(:m_start)
+      self.inner.bytecode(g)
+      g.capture(
+        :m_end,
+        self.captargs
+      )
+    )}) {(
+      g.capture(:c_start)
+      self.inner.bytecode(g)
+      g.capture(
+        :c_end,
+        self.captargs
+      )
+    )})})}
+    ::Myco.find_constant(:NamedTextCapture).component_eval {(declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
+      g.capture(:s_start)
+      self.inner.bytecode(g)
+      g.capture(
+        :s_end,
+        self.captargs
+      )
+    )})}
+    ::Myco.find_constant(:NamedTokenCapture).component_eval {(declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
+      g.capture(:t_start)
+      self.inner.bytecode(g)
+      g.capture(
+        :t_end,
+        self.captargs
+      )
+    )})}
+    ::Myco.find_constant(:Reduction).component_eval {(declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
+      g.capture(:r_start)
+      self.inner.bytecode(g)
+      g.capture(
+        :r_end,
+        self.captargs
+      )
+    )})}
+    ::Myco.find_constant(:RuleCall).component_eval {(declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
+      memoize = true
+      result_check = g.new_label
+      memo_result_check = g.new_label
+      local_success = g.new_label
+      local_fail = g.new_label
+      g.push_temp_captures
+      self.__send__(
+        :if,
+        memoize
+      ) { || (
+        g.memo_or_eq_new_hash(self.name)
+        g.goto_if_memo_for_idx(
+          self.name,
+          memo_result_check
+        )
+      )}
+      g.push_self
+      g.push_subject
+      g.push_idx
+      g.send(
+        self.name,
+        2
+      )
+      result_check.__send__(:set!)
+      g.copy_result_to_memo(self.name)
+      g.dup_top
+      g.goto_if_true(local_success)
+      g.goto(local_fail)
+      self.__send__(
+        :if,
+        memoize
+      ) { || (
+        memo_result_check.__send__(:set!)
+        g.dup_top
+        g.goto_if_true(local_success)
+        g.goto(local_fail)
+      )}
+      local_fail.__send__(:set!)
+      g.pop
+      g.pop_to_reject_captures
+      g.goto(g.overall_fail)
+      local_success.__send__(:set!)
+      g.pop_to_set_idx
+      g.pop_to_accept_captures
+    )})}
+  )}
+)}}
+.tap { |__c__| __c__.__name__ = :Capture })}}.instance