myco 0.1.4 → 0.1.5

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

@@ -0,0 +1,415 @@
+
+::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+  declare_meme(:"BytecodeHelpers.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  ::Myco.cscope.for_method_definition.const_set(:BytecodeInstructions, ::Myco::Component.new([::Myco.find_constant(:BasicObject)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {(
+    ::Myco.find_constant(:Constructions).component_eval {(
+      ::Myco.find_constant(:AnyCharacter).component_eval {(declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |m| (m.any(1))})}
+      ::Myco.find_constant(:Character).component_eval {(declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |m| (m.char(self.code.chr))})}
+      ::Myco.find_constant(:CharacterString).component_eval {(declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |m| (m.char(self.codes.map(&:chr).join))})}
+      ::Myco.find_constant(:CharacterSet).component_eval {(declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |m| (m.set(self.codes.map(&:chr).join))})}
+      ::Myco.find_constant(:CharacterRange).component_eval {(declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |m| (
+        codes = ::Myco.find_constant(:Range).new(
+          self.start,
+          self.stop
+        )
+        m.set(codes.map(&:chr).join)
+      )})}
+      ::Myco.find_constant(:NegativePredicate).component_eval {(declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |m| (m.neg_predicate(
+        ::Proc.new { || (self.inner.bytecode(m))},
+        self.inner.bytecode_can_capture
+      ))})}
+      ::Myco.find_constant(:PositivePredicate).component_eval {(declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |m| (m.pos_predicate(
+        ::Proc.new { || (self.inner.bytecode(m))},
+        self.inner.bytecode_can_capture
+      ))})}
+      ::Myco.find_constant(:OneOrMore).component_eval {(declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |m| (m.many(
+        ::Proc.new { || (
+          self.inner.bytecode(m)
+          (self.inlaid.respond_to?(:call).false? ? ::Myco::Void : self.inlaid.call)
+        )},
+        self.inner.bytecode_can_capture
+      ))})}
+      ::Myco.find_constant(:ZeroOrOne).component_eval {(declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |m| (m.choice(
+        ::Proc.new { || (self.inner.bytecode(m))},
+        ::Proc.new { || nil},
+        self.inner.bytecode_can_capture
+      ))})}
+      ::Myco.find_constant(:ZeroOrMore).component_eval {(declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |m| (m.kleene(
+        ::Proc.new { || (
+          self.inner.bytecode(m)
+          (self.inlaid.respond_to?(:call).false? ? ::Myco::Void : self.inlaid.call)
+        )},
+        self.inner.bytecode_can_capture
+      ))})}
+      ::Myco.find_constant(:OrderedChoice).component_eval {(declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |m| (m.choice(
+        ::Proc.new { || (self.first.bytecode(m))},
+        ::Proc.new { || (self.second.bytecode(m))},
+        self.first.bytecode_can_capture
+      ))})}
+      ::Myco.find_constant(:Concatenation).component_eval {(declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |m| (
+        self.first.bytecode(m)
+        self.second.bytecode(m)
+      )})}
+      ::Myco.find_constant(:NamedCapture).component_eval {(declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |m| (::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=,
+          ::Proc.new { || (m.capture(
+            :m_split,
+            self.captargs
+          ))}
+        )
+        m.capture(:m_start)
+        self.inner.bytecode(m)
+        m.capture(
+          :m_end,
+          self.captargs
+        )
+      )}) {(
+        m.capture(:c_start)
+        self.inner.bytecode(m)
+        m.capture(
+          :c_end,
+          self.captargs
+        )
+      )})})}
+      ::Myco.find_constant(:NamedTextCapture).component_eval {(declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |m| (
+        m.capture(:s_start)
+        self.inner.bytecode(m)
+        m.capture(
+          :s_end,
+          self.captargs
+        )
+      )})}
+      ::Myco.find_constant(:NamedTokenCapture).component_eval {(declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |m| (
+        m.capture(:t_start)
+        self.inner.bytecode(m)
+        m.capture(
+          :t_end,
+          self.captargs
+        )
+      )})}
+      ::Myco.find_constant(:Reduction).component_eval {(declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |m| (
+        m.capture(:r_start)
+        self.inner.bytecode(m)
+        m.capture(
+          :r_end,
+          self.captargs
+        )
+      )})}
+      ::Myco.find_constant(:AnyCharacter).component_eval {(declare_meme(:bytecode_can_capture, [], nil, ::Myco.cscope.dup) { |*| (false)})}
+      ::Myco.find_constant(:Character).component_eval {(declare_meme(:bytecode_can_capture, [], nil, ::Myco.cscope.dup) { |*| (false)})}
+      ::Myco.find_constant(:CharacterString).component_eval {(declare_meme(:bytecode_can_capture, [], nil, ::Myco.cscope.dup) { |*| (false)})}
+      ::Myco.find_constant(:CharacterSet).component_eval {(declare_meme(:bytecode_can_capture, [], nil, ::Myco.cscope.dup) { |*| (false)})}
+      ::Myco.find_constant(:CharacterRange).component_eval {(declare_meme(:bytecode_can_capture, [], nil, ::Myco.cscope.dup) { |*| (false)})}
+      ::Myco.find_constant(:NegativePredicate).component_eval {(declare_meme(:bytecode_can_capture, [], nil, ::Myco.cscope.dup) { |*| (self.inner.bytecode_can_capture)})}
+      ::Myco.find_constant(:PositivePredicate).component_eval {(declare_meme(:bytecode_can_capture, [], nil, ::Myco.cscope.dup) { |*| (self.inner.bytecode_can_capture)})}
+      ::Myco.find_constant(:OneOrMore).component_eval {(declare_meme(:bytecode_can_capture, [], nil, ::Myco.cscope.dup) { |*| (self.inner.bytecode_can_capture)})}
+      ::Myco.find_constant(:ZeroOrOne).component_eval {(declare_meme(:bytecode_can_capture, [], nil, ::Myco.cscope.dup) { |*| (self.inner.bytecode_can_capture)})}
+      ::Myco.find_constant(:ZeroOrMore).component_eval {(declare_meme(:bytecode_can_capture, [], nil, ::Myco.cscope.dup) { |*| (self.inner.bytecode_can_capture)})}
+      ::Myco.find_constant(:OrderedChoice).component_eval {(declare_meme(:bytecode_can_capture, [], nil, ::Myco.cscope.dup) { |*| (::Myco.branch_op(:"||", self.first.bytecode_can_capture) {self.second.bytecode_can_capture})})}
+      ::Myco.find_constant(:Concatenation).component_eval {(declare_meme(:bytecode_can_capture, [], nil, ::Myco.cscope.dup) { |*| (::Myco.branch_op(:"||", self.first.bytecode_can_capture) {self.second.bytecode_can_capture})})}
+      ::Myco.find_constant(:NamedCapture).component_eval {(declare_meme(:bytecode_can_capture, [], nil, ::Myco.cscope.dup) { |*| (true)})}
+      ::Myco.find_constant(:NamedTextCapture).component_eval {(declare_meme(:bytecode_can_capture, [], nil, ::Myco.cscope.dup) { |*| (true)})}
+      ::Myco.find_constant(:NamedTokenCapture).component_eval {(declare_meme(:bytecode_can_capture, [], nil, ::Myco.cscope.dup) { |*| (true)})}
+      ::Myco.find_constant(:Reduction).component_eval {(declare_meme(:bytecode_can_capture, [], nil, ::Myco.cscope.dup) { |*| (true)})}
+    )}
+    declare_meme(:g, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+    declare_meme(:any, [], nil, ::Myco.cscope.dup) { |count| (
+      self.g.push_idx
+      self.g.push_int(count)
+      self.g.send(
+        :+,
+        1
+      )
+      self.g.push_subject
+      self.g.send(
+        :size,
+        0
+      )
+      self.g.send(
+        :<=,
+        1
+      )
+      self.g.goto_if_false(self.g.overall_fail)
+      self.g.push_int(count)
+      self.g.increment_idx
+    )}
+    declare_meme(:char, [], nil, ::Myco.cscope.dup) { |string| (
+      self.g.setup_unwind(
+        self.g.overall_fail,
+        0
+      )
+      self.g.push_literal(string)
+      self.g.push_subject
+      self.g.push_idx
+      self.g.push_int(string.size)
+      self.g.send(
+        :compare_substring,
+        3
+      )
+      self.g.__send__(:meta_push_0)
+      self.g.pop_unwind
+      self.g.goto_if_not_equal(self.g.overall_fail)
+      self.g.push_int(string.size)
+      self.g.increment_idx
+    )}
+    declare_meme(:set, [], nil, ::Myco.cscope.dup) { |string| (
+      local_done = self.g.new_label
+      local_early_fail = self.g.new_label
+      self.g.push_literal(string)
+      self.g.push_subject_at_idx
+      self.g.dup_top
+      self.g.goto_if_false(local_early_fail)
+      self.g.__send__(:meta_push_0)
+      self.g.send(
+        :find_string,
+        2
+      )
+      self.g.goto_if_false(self.g.overall_fail)
+      self.g.goto(local_done)
+      local_early_fail.__send__(:set!)
+      self.g.pop
+      self.g.pop
+      self.g.goto(self.g.overall_fail)
+      local_done.__send__(:set!)
+      self.g.__send__(:meta_push_1)
+      self.g.increment_idx
+    )}
+    declare_meme(:choice, [], nil, ::Myco.cscope.dup) { |first, second, first_can_capture| (
+      local_done = self.g.new_label
+      local_fail = self.g.new_label
+      old_fail = self.g.overall_fail
+      self.g.__send__(
+        :overall_fail=,
+        local_fail
+      )
+      self.__send__(
+        :if,
+        first_can_capture
+      ) { || (self.g.push_temp_captures)}
+      self.g.push_idx
+      first.call
+      self.g.pop
+      self.__send__(
+        :if,
+        first_can_capture
+      ) { || (self.g.pop_to_accept_captures)}
+      self.g.__send__(
+        :overall_fail=,
+        old_fail
+      )
+      self.g.goto(local_done)
+      local_fail.__send__(:set!)
+      self.g.pop_to_set_idx
+      self.__send__(
+        :if,
+        first_can_capture
+      ) { || (self.g.pop_to_reject_captures)}
+      self.g.__send__(
+        :overall_fail=,
+        old_fail
+      )
+      second.call
+      local_done.__send__(:set!)
+    )}
+    declare_meme(:many, [], nil, ::Myco.cscope.dup) { |inner, inner_can_capture| (
+      local_retry = self.g.new_label
+      local_fail = self.g.new_label
+      old_fail = self.g.overall_fail
+      self.g.__send__(
+        :overall_fail=,
+        local_fail
+      )
+      self.g.push_false
+      local_retry.__send__(:set!)
+      self.__send__(
+        :if,
+        inner_can_capture
+      ) { || (self.g.push_temp_captures)}
+      inner.call
+      self.__send__(
+        :if,
+        inner_can_capture
+      ) { || (self.g.pop_to_accept_captures)}
+      self.g.pop
+      self.g.push_true
+      self.g.goto(local_retry)
+      local_fail.__send__(:set!)
+      self.__send__(
+        :if,
+        inner_can_capture
+      ) { || (self.g.pop_to_reject_captures)}
+      self.g.__send__(
+        :overall_fail=,
+        old_fail
+      )
+      self.g.goto_if_false(self.g.overall_fail)
+    )}
+    declare_meme(:kleene, [], nil, ::Myco.cscope.dup) { |inner, inner_can_capture| (
+      local_retry = self.g.new_label
+      local_fail = self.g.new_label
+      old_fail = self.g.overall_fail
+      self.g.__send__(
+        :overall_fail=,
+        local_fail
+      )
+      local_retry.__send__(:set!)
+      self.__send__(
+        :if,
+        inner_can_capture
+      ) { || (self.g.push_temp_captures)}
+      inner.call
+      self.__send__(
+        :if,
+        inner_can_capture
+      ) { || (self.g.pop_to_accept_captures)}
+      self.g.goto(local_retry)
+      local_fail.__send__(:set!)
+      self.__send__(
+        :if,
+        inner_can_capture
+      ) { || (self.g.pop_to_reject_captures)}
+      self.g.__send__(
+        :overall_fail=,
+        old_fail
+      )
+    )}
+    declare_meme(:pos_predicate, [], nil, ::Myco.cscope.dup) { |inner, inner_can_capture| (
+      local_done = self.g.new_label
+      local_fail = self.g.new_label
+      old_fail = self.g.overall_fail
+      self.g.__send__(
+        :overall_fail=,
+        local_fail
+      )
+      self.__send__(
+        :if,
+        inner_can_capture
+      ) { || (self.g.push_temp_captures)}
+      self.g.push_idx
+      inner.call
+      self.g.pop_to_set_idx
+      self.__send__(
+        :if,
+        inner_can_capture
+      ) { || (self.g.pop_to_accept_captures)}
+      self.g.__send__(
+        :overall_fail=,
+        old_fail
+      )
+      self.g.goto(local_done)
+      local_fail.__send__(:set!)
+      self.g.pop_to_set_idx
+      self.__send__(
+        :if,
+        inner_can_capture
+      ) { || (self.g.pop_to_reject_captures)}
+      self.g.__send__(
+        :overall_fail=,
+        old_fail
+      )
+      self.g.goto(self.g.overall_fail)
+      local_done.__send__(:set!)
+    )}
+    declare_meme(:neg_predicate, [], nil, ::Myco.cscope.dup) { |inner, inner_can_capture| (
+      local_fail = self.g.new_label
+      old_fail = self.g.overall_fail
+      self.g.__send__(
+        :overall_fail=,
+        local_fail
+      )
+      self.__send__(
+        :if,
+        inner_can_capture
+      ) { || (self.g.push_temp_captures)}
+      self.g.push_idx
+      inner.call
+      self.g.pop_to_set_idx
+      self.__send__(
+        :if,
+        inner_can_capture
+      ) { || (self.g.pop_to_reject_captures)}
+      self.g.__send__(
+        :overall_fail=,
+        old_fail
+      )
+      self.g.goto(self.g.overall_fail)
+      local_fail.__send__(:set!)
+      self.g.pop_to_set_idx
+      self.__send__(
+        :if,
+        inner_can_capture
+      ) { || (self.g.pop_to_accept_captures)}
+      self.g.__send__(
+        :overall_fail=,
+        old_fail
+      )
+    )}
+    declare_meme(:call, [], nil, ::Myco.cscope.dup) { |name, memoize=true| (
+      result_check = self.g.new_label
+      memo_result_check = self.g.new_label
+      local_success = self.g.new_label
+      local_fail = self.g.new_label
+      self.g.push_temp_captures
+      self.__send__(
+        :if,
+        memoize
+      ) { || (
+        self.g.memo_or_eq_new_hash(name)
+        self.g.goto_if_memo_for_idx(
+          name,
+          memo_result_check
+        )
+      )}
+      self.g.push_self
+      self.g.push_subject
+      self.g.push_idx
+      self.g.send(
+        name,
+        2
+      )
+      result_check.__send__(:set!)
+      self.g.copy_result_to_memo(name)
+      self.g.dup_top
+      self.g.goto_if_true(local_success)
+      self.g.goto(local_fail)
+      self.__send__(
+        :if,
+        memoize
+      ) { || (
+        memo_result_check.__send__(:set!)
+        self.g.dup_top
+        self.g.goto_if_true(local_success)
+        self.g.goto(local_fail)
+      )}
+      local_fail.__send__(:set!)
+      self.g.pop
+      self.g.pop_to_reject_captures
+      self.g.goto(self.g.overall_fail)
+      local_success.__send__(:set!)
+      self.g.pop_to_set_idx
+      self.g.pop_to_accept_captures
+    )}
+    declare_meme(:capture, [], nil, ::Myco.cscope.dup) { |*metadata| (
+      self.g.push_captures
+      self.g.push_idx
+      self.g.push_literal_or_array(metadata)
+      self.g.make_array(2)
+      self.g.make_array(1)
+      self.g.send(
+        :concat,
+        1
+      )
+      self.g.pop
+    )}
+  )}})
+  .tap { |__c__| __c__.__name__ = :BytecodeInstructions }
+)}}.instance

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

@@ -0,0 +1,137 @@
+
+BytecodeParser < BasicObject {
+  var grammar: Grammar { }
+  
+  new_worker: set_up_worker(prototype.new)
+  
+  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.construct_rule
+    
+    proto.dynamic_method(name, "(compiled parser)") |g| {
+      instructor = BytecodeInstructions { }
+      instructor.g = g
+      g.extend(BytecodeHelpers)
+      
+      g.rule_start
+      construct.bytecode(instructor)
+      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.instance_variable_set(:"@captures", [])
+    worker.instance_variable_set(:"@highest_idx", 0)
+    worker
+  }
+  
+  captures_of_worker: |worker|
+    worker.instance_variable_get(:"@captures")
+  
+  highest_idx_of_worker: |worker|
+    worker.instance_variable_get(:"@highest_idx")
+  
+  new_processor: Processor.new(builder: new_builder)
+  new_builder: Builder.new
+  
+  
+  # Match and process the given string using the current grammar
+  parse: |string| {
+    worker = new_worker
+    
+    self.error_idx = null
+    self.error_row = null
+    self.error_col = null
+    self.error_string = null
+    self.result = null
+    self.end_idx = worker.root(string, 0)
+    
+    processor = new_processor
+    
+    if(end_idx) {
+      processor.string = string
+      processor.capture_items = captures_of_worker(worker)
+      self.result = processor.process
+    }
+    if(!end_idx) {
+      self.error_idx = highest_idx_of_worker(worker)
+      pos = processor.position_of(error_idx, string)
+      self.error_row = pos.first
+      self.error_col = pos.last
+      self.error_string = \
+      "Unexpected character near line: "error_row", column: "error_col".\n" \
+        string.each_line.to_a[error_row - 1]"" \
+        (' ' * [(error_col - 1), 0].max)"^"
+    }
+    self.result
+  }
+  
+  var end_idx
+  var result
+  
+  var error_idx
+  var error_row
+  var error_col
+  var error_string
+  raise_error: raise(SyntaxError, error_string)
+}