myco 0.1.8 → 0.1.9

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

@@ -1,51 +1,221 @@
 
 ::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-.tap { |__c__| __c__.__last__ = __c__.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.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(: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
+      )}^"
+    )})}
+  )}}
+  .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(:string, [[:var, []]], nil, ::Myco.cscope.dup) { |*| ("")}
-  declare_meme(:result, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (nil)}
-  declare_meme(:make_sequence_table, [[:memoize, []]], nil, ::Myco.cscope.dup) { |grammar| (
-    grammar.construct_all_rules
-    grammar.rule_table.map { |k, v| ([
-      k,
-      v.construct_rule.sequence.__send__(
-        :+,
-        [[:return]]
-      )
-    ])}.to_h
-  )}
-  declare_meme(:new_machine, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:Machine).new({
-    :sequence_table => self.make_sequence_table(self.grammar),
-    :subject => self.string.each_char.map(&:ord)
-  }))}
-  declare_meme(:new_processor, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:Processor).new({
-    :builder => self.new_builder,
-    :string => self.string
-  }))}
-  declare_meme(:new_builder, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:Builder).new)}
-  declare_meme(:parse, [], nil, ::Myco.cscope.dup) { |string=nil| (
-    ::Myco.branch_op(:"&&", string) {self.__send__(
-      :string=,
-      string
+  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)}
+  declare_meme(:refresh, [], nil, ::Myco.cscope.dup) { |*| (self.__send__(
+    :prototype=,
+    self.compile_prototype
+  ))}
+  declare_meme(:compile_prototype, [], nil, ::Myco.cscope.dup) { |*| (
+    proto = ::Myco.find_constant(:Component).new
+    self.grammar.construct_all_rules
+    self.grammar.rule_table.each { |name, rule| (self.compile_rule_into(
+      proto,
+      name,
+      rule
+    ))}
+    proto
+  )}
+  declare_meme(:compile_rule_into, [], nil, ::Myco.cscope.dup) { |proto, name, rule| (
+    construct = rule.inner.construct
+    ::Myco.find_constant(:Myco).add_dynamic_method(
+      proto,
+      name,
+      "(compiled parser)"
+    ) { |g| (
+      g.extend(::Myco.find_constant(:BytecodeHelpers))
+      g.__send__(
+        :debug_mode=,
+        self.debug_mode
+      )
+      g.rule_start
+      construct.bytecode(g)
+      g.rule_finish
     )}
-    machine = self.new_machine
-    machine.execute
+  )}
+  declare_meme(:compile_generator, [], nil, ::Myco.cscope.dup) { |name, file, line=1, &block| (
+    g = ::Myco.find_constant(:Myco)::ToolSet::Generator.new
+    g.__send__(
+      :name=,
+      name
+    )
+    g.__send__(
+      :file=,
+      file
+    )
+    g.set_line(line)
+    block.call(g)
+    g.ret
+    g.close
+    g.use_detected
+    g
+  )}
+  declare_meme(:compile_code, [], nil, ::Myco.cscope.dup) { |name, file, line=1, &block| (
+    g = self.compile_generator(
+      name,
+      file,
+      line,
+      &block
+    )
+    g.encode
+    g.package(::Myco.find_constant(:Rubinius)::CompiledCode)
+  )}
+  declare_meme(:save_prototype, [], nil, ::Myco.cscope.dup) { |filename| (
+    code = self.compile_code(
+      :__script__,
+      :"(snippet)"
+    ) { |g| (
+      g.push_cpath_top
+      g.find_const(:Class)
+      g.create_block(self.compile_generator(
+        :__block__,
+        :"(snippet)"
+      ) { |g| (self.prototype.instance_methods.each { |name| (
+        code = self.prototype.instance_method(name).executable
+        self.__send__(
+          :if,
+          code.__send__(
+            :is_a?,
+            ::Myco.find_constant(: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.find_constant(:Myco)::ToolSet::CompiledFile.dump(
+      code,
+      filename,
+      ::Myco.find_constant(:Rubinius)::Signature,
+      ::Myco.find_constant(:Rubinius)::RUBY_LIB_VERSION
+    )
+  )}
+  declare_meme(:load_prototype, [], nil, ::Myco.cscope.dup) { |filename| (
+    loader = ::Myco.find_constant(:Myco)::CodeLoader::BytecodeLoader.new(filename)
+    loader.bind_to({:call_depth => 1})
     self.__send__(
-      :unless,
-      machine.had_failure
-    ) { || (
-      processor = self.new_processor
+      :prototype=,
+      loader.load
+    )
+  )}
+  declare_meme(:set_up_worker, [], nil, ::Myco.cscope.dup) { |worker| (
+    worker.__set_ivar__(
+      :@captures,
+      []
+    )
+    worker.__set_ivar__(
+      :@highest_idx,
+      0
+    )
+    worker
+  )}
+  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) { |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
+    })
+    state.__send__(
+      :end_idx=,
+      worker.__send__(
+        state.rule,
+        state.string,
+        state.start_idx
+      )
+    )
+    ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", state.end_idx) {(
+      processor.__send__(
+        :string=,
+        state.string
+      )
       processor.__send__(
         :capture_items=,
-        machine.captures
+        self.captures_of_worker(worker)
       )
-      self.__send__(
+      ::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
       )
+    )}) {(
+      state.__send__(
+        :error_idx=,
+        self.highest_idx_of_worker(worker)
+      )
+      pos = processor.position_of(
+        state.error_idx,
+        state.string
+      )
+      state.__send__(
+        :error_row=,
+        pos.first
+      )
+      state.__send__(
+        :error_col=,
+        pos.last
+      )
     )}
-    self
+    state
   )}
 )}}
-.tap { |__c__| __c__.__name__ = :Parser })}}.instance
+.tap { |__c__| __c__.__name__ = :Parser })})}}.instance

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

@@ -24,12 +24,22 @@ Processor < BasicObject {
     integer: |base=0| text.to_inum(base, true)
   }
   
+  var tokenizer: &|type, source, start, stop| {
+    pos = position_of(start, source)
+    value = Token.new(
+      type: type
+      text: source.slice(start, stop - start)
+      row: pos.first
+      col: pos.last
+    )
+  }
+  
   # The environment for performing reduction actions to build an AST in the PEG.
   # It gives implicit access to both local captures and AST builder methods.
   var reduction_env:
-    Patterns::Reduction::Environment.new
+    Capture::Patterns::Reduction::Environment.new
   var reduction_env_cscope:
-    ::Rubinius::ConstantScope.new(Patterns::Reduction::Environment) # TODO: fix
+    ::Rubinius::ConstantScope.new(Capture::Patterns::Reduction::Environment) # TODO: fix
   
   var cidx_stack: [] # A FILO stack of start indices for captures
   var sidx_stack: [] # A FILO stack of start indices for string captures
@@ -116,7 +126,8 @@ Processor < BasicObject {
     # If the reduction is not found and the string length is not zero
     # slice the string with the given indices to get a text value.
     !use_reduction && !(start_idx==idx) && (
-      value = string.slice(start_idx, idx-start_idx)
+      size = idx-start_idx
+      value = (size == 1 &? string[start_idx] ?? string.slice(start_idx, size))
     )
     
     store_value = [[start_idx, idx], value]
@@ -151,14 +162,8 @@ Processor < BasicObject {
   t_end: |idx, name| {
     captures = capt_stack.last
     start_idx = tidx_stack.pop
-    pos = position_of(start_idx, string)
     
-    value = Token.new(
-      type: name
-      text: string.slice(start_idx, idx - start_idx)
-      row: pos.first
-      col: pos.last
-    )
+    value = tokenizer.call(name, string, start_idx, idx)
     store_value = [[start_idx, idx], value]
     captures.store(idx, store_value)
     captures.store(name, store_value)
@@ -216,16 +221,20 @@ Processor < BasicObject {
     captures = pop_layer
     start_idx = ridx_stack.pop
     
+    captures_map = captures.map |k,v| {
+      k.is_a?(Symbol) &? [k,v.last] ?? null
+    }.compact.to_h
+    
     # Set up the reduction environment
     code.scope = reduction_env_cscope
     reduction_env.builder = builder
-    reduction_env.captures = captures.map |k,v| { [k,v.last] }.to_h
+    reduction_env.captures = captures_map
     
     # Invoke the reduction action to get a value
     # Store with the string index as the key so the value can be recaptured
     value = code.invoke(
       code.name,
-      Patterns::Reduction::Environment,
+      Capture::Patterns::Reduction::Environment,
       reduction_env,
       [],
       null,

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

@@ -38,8 +38,26 @@
     ))}
   )}}
   .tap { |__c__| __c__.__name__ = :Token }
-  declare_meme(:reduction_env, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:Patterns)::Reduction::Environment.new)}
-  declare_meme(:reduction_env_cscope, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (::Rubinius::ConstantScope.new(::Myco.find_constant(:Patterns)::Reduction::Environment))}
+  declare_meme(:tokenizer, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (::Object::Proc.new { |type, source, start, stop| (
+    pos = self.position_of(
+      start,
+      source
+    )
+    value = ::Myco.find_constant(:Token).new({
+      :type => type,
+      :text => source.slice(
+        start,
+        stop.__send__(
+          :-,
+          start
+        )
+      ),
+      :row => pos.first,
+      :col => pos.last
+    })
+  )})}
+  declare_meme(:reduction_env, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:Capture)::Patterns::Reduction::Environment.new)}
+  declare_meme(:reduction_env_cscope, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (::Rubinius::ConstantScope.new(::Myco.find_constant(:Capture)::Patterns::Reduction::Environment))}
   declare_meme(:cidx_stack, [[:var, []]], nil, ::Myco.cscope.dup) { |*| ([])}
   declare_meme(:sidx_stack, [[:var, []]], nil, ::Myco.cscope.dup) { |*| ([])}
   declare_meme(:tidx_stack, [[:var, []]], nil, ::Myco.cscope.dup) { |*| ([])}
@@ -149,12 +167,21 @@
     ::Myco.branch_op(:"&&", ::Myco.branch_op(:"&&", use_reduction.__send__(:!)) {start_idx.__send__(
       :==,
       idx
-    ).__send__(:!)}) {value = self.string.slice(
-      start_idx,
-      idx.__send__(
+    ).__send__(:!)}) {(
+      size = idx.__send__(
         :-,
         start_idx
       )
+      value = ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", size.__send__(
+        :==,
+        1
+      )) {self.string.__send__(
+        :[],
+        start_idx
+      )}) {self.string.slice(
+        start_idx,
+        size
+      )}
     )}
     store_value = [
       [
@@ -203,22 +230,12 @@
   declare_meme(:t_end, [], nil, ::Myco.cscope.dup) { |idx, name| (
     captures = self.capt_stack.last
     start_idx = self.tidx_stack.pop
-    pos = self.position_of(
+    value = self.tokenizer.call(
+      name,
+      self.string,
       start_idx,
-      self.string
+      idx
     )
-    value = ::Myco.find_constant(:Token).new({
-      :type => name,
-      :text => self.string.slice(
-        start_idx,
-        idx.__send__(
-          :-,
-          start_idx
-        )
-      ),
-      :row => pos.first,
-      :col => pos.last
-    })
     store_value = [
       [
         start_idx,
@@ -300,6 +317,13 @@
   declare_meme(:r_end, [], nil, ::Myco.cscope.dup) { |idx, code, *args| (
     captures = self.pop_layer
     start_idx = self.ridx_stack.pop
+    captures_map = captures.map { |k, v| (::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", k.__send__(
+      :is_a?,
+      ::Myco.find_constant(:Symbol)
+    )) {[
+      k,
+      v.last
+    ]}) {nil})}.compact.to_h
     code.__send__(
       :scope=,
       self.reduction_env_cscope
@@ -310,14 +334,11 @@
     )
     self.reduction_env.__send__(
       :captures=,
-      captures.map { |k, v| ([
-        k,
-        v.last
-      ])}.to_h
+      captures_map
     )
     value = code.invoke(
       code.name,
-      ::Myco.find_constant(:Patterns)::Reduction::Environment,
+      ::Myco.find_constant(:Capture)::Patterns::Reduction::Environment,
       self.reduction_env,
       [],
       nil

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

@@ -0,0 +1,99 @@
+
+Stream < EmptyObject {
+  Patterns < EmptyObject {
+    Base < Common::Patterns::Base { }
+    
+    End  < Base {
+      construct: Constructions::End.new
+    }
+    Item < Base { var checks
+      construct: Constructions::Item.new(checks: checks)
+    }
+  }
+  
+  Constructions < EmptyObject {
+    Base < Common::Constructions::Base { }
+    
+    End  < Base { }
+    Item < Base { var checks }
+  }
+  
+  Constructions << {
+    End << { bytecode: |g| {
+      # Just verify the index is NOT within range
+      g.push_subject; g.send(:size, 0)
+        g.push_idx
+      g.send(:">", 1)
+      g.goto_if_true(g.overall_fail)
+    }}
+    
+    Item << { bytecode: |g| {
+      many_checks = checks.size > 1
+      local_fail  = g.overall_fail
+      if(many_checks) { local_fail = g.new_label }
+      
+      # First, verify the index is within range
+      g.push_subject; g.send(:size, 0)
+        g.push_idx
+      g.send(:">", 1)
+      g.goto_if_false(g.overall_fail)
+      
+      checks.empty? || (
+        # Retrieve the item
+        g.push_subject_at_idx
+        
+        # Try each check on the item until one fails
+        checks.each |method, args, result| {
+          if(many_checks) { g.dup_top }
+          
+          # Run the given method (or other check) with the given args (if applicable) 
+          :self.equal?(method) &? (
+            # Do nothing; let the self pass through to result checking.
+          ) ?? (method.is_a?(Symbol) &? (
+            args.each |arg| { g.push_literal_or_array(arg) }
+            g.send(method, args.size)
+          ) ?? (method.is_a?(Proc) &? (
+            code = method.block.compiled_code
+            g.push_literal(code) # TODO: add a move_up instruction and avoid all of these swap_stacks
+              g.swap_stack; g.push_literal(code.name)             # name
+              g.swap_stack; g.push_cpath_top; g.find_const(:Myco) # module
+              g.swap_stack                                        # receiver (the item)
+              g.push_literal_array(args)                          # args
+              g.push_nil                                          # block
+            g.send(:invoke, 5)
+          ) ?? (
+            raise("Unknown type of check method: "method"")
+          )))
+          
+          # Compare the result of the check with the given expected result 
+          null.equal?(result) &? (
+            g.goto_if_not_nil(local_fail)
+          ) ?? ((false.equal?(result) || true.equal?(result) ||
+                 result.is_a?(Symbol) || result.is_a?(Fixnum)) &? (
+            g.push_literal(result)
+            g.goto_if_not_equal(local_fail)
+          ) ?? (
+            g.push_literal_or_array(result)
+            g.send(:"==", 1)
+            g.goto_if_false(local_fail)
+          ))
+        }
+        
+        if(many_checks) {
+          local_done = g.new_label
+          g.pop # The dup'd subject_at_idx
+          g.goto(local_done)
+          
+          local_fail.set!
+          g.pop # The dup'd subject_at_idx
+          g.goto(g.overall_fail)
+          
+          local_done.set!
+        }
+      )
+      
+      g.meta_push_1
+      g.increment_idx
+    }}
+  }
+}