myco 0.1.4 → 0.1.5

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

@@ -0,0 +1,237 @@
+
+::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(:BytecodeParser, ::Myco::Component.new([::Myco.find_constant(:BasicObject)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+  declare_meme(:grammar, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (::Myco::Component.new([::Myco.find_constant(:Grammar)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}}.instance)}
+  declare_meme(:new_worker, [], nil, ::Myco.cscope.dup) { |*| (self.set_up_worker(self.prototype.new))}
+  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.construct_rule
+    proto.dynamic_method(
+      name,
+      "(compiled parser)"
+    ) { |g| (
+      instructor = ::Myco::Component.new([::Myco.find_constant(:BytecodeInstructions)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+      .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}}.instance
+      instructor.__send__(
+        :g=,
+        g
+      )
+      g.extend(::Myco.find_constant(:BytecodeHelpers))
+      g.rule_start
+      construct.bytecode(instructor)
+      g.rule_finish
+    )}
+  )}
+  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__(
+      :prototype=,
+      loader.load
+    )
+  )}
+  declare_meme(:set_up_worker, [], nil, ::Myco.cscope.dup) { |worker| (
+    worker.instance_variable_set(
+      :@captures,
+      []
+    )
+    worker.instance_variable_set(
+      :@highest_idx,
+      0
+    )
+    worker
+  )}
+  declare_meme(:captures_of_worker, [], nil, ::Myco.cscope.dup) { |worker| (worker.instance_variable_get(:@captures))}
+  declare_meme(:highest_idx_of_worker, [], nil, ::Myco.cscope.dup) { |worker| (worker.instance_variable_get(:@highest_idx))}
+  declare_meme(:new_processor, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:Processor).new({:builder => self.new_builder}))}
+  declare_meme(:new_builder, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:Builder).new)}
+  declare_meme(:parse, [], nil, ::Myco.cscope.dup) { |string| (
+    worker = self.new_worker
+    self.__send__(
+      :error_idx=,
+      nil
+    )
+    self.__send__(
+      :error_row=,
+      nil
+    )
+    self.__send__(
+      :error_col=,
+      nil
+    )
+    self.__send__(
+      :error_string=,
+      nil
+    )
+    self.__send__(
+      :result=,
+      nil
+    )
+    self.__send__(
+      :end_idx=,
+      worker.root(
+        string,
+        0
+      )
+    )
+    processor = self.new_processor
+    self.__send__(
+      :if,
+      self.end_idx
+    ) { || (
+      processor.__send__(
+        :string=,
+        string
+      )
+      processor.__send__(
+        :capture_items=,
+        self.captures_of_worker(worker)
+      )
+      self.__send__(
+        :result=,
+        processor.process
+      )
+    )}
+    self.__send__(
+      :if,
+      self.end_idx.__send__(:!)
+    ) { || (
+      self.__send__(
+        :error_idx=,
+        self.highest_idx_of_worker(worker)
+      )
+      pos = processor.position_of(
+        self.error_idx,
+        string
+      )
+      self.__send__(
+        :error_row=,
+        pos.first
+      )
+      self.__send__(
+        :error_col=,
+        pos.last
+      )
+      self.__send__(
+        :error_string=,
+        "Unexpected character near line: #{self.error_row}, column: #{self.error_col}.\n#{string.each_line.to_a.__send__(
+          :[],
+          self.error_row.__send__(
+            :-,
+            1
+          )
+        )}#{" ".__send__(
+          :*,
+          [
+            self.error_col.__send__(
+              :-,
+              1
+            ),
+            0
+          ].max
+        )}^"
+      )
+    )}
+    self.result
+  )}
+  declare_meme(:end_idx, [[: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(:error_string, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:raise_error, [], nil, ::Myco.cscope.dup) { |*| (self.raise(
+    ::Myco.find_constant(:SyntaxError),
+    self.error_string
+  ))}
+)}})
+.tap { |__c__| __c__.__name__ = :BytecodeParser })}}.instance

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

@@ -0,0 +1,183 @@
+
+Constructions < EmptyObject {
+  
+  ##
+  # Basic types of constructions.
+  
+  Base < BasicObject { }
+  UnaryBase  < Base { var inner }
+  BinaryBase < Base { var first, var second }
+  
+  AnyCharacter      < Base { }
+  Character         < Base { var code }
+  CharacterString   < Base { var codes }
+  CharacterSet      < Base { var codes }
+  CharacterRange    < Base { var start, var stop }
+  
+  NegativePredicate < UnaryBase { }
+  PositivePredicate < UnaryBase { }
+  OneOrMore         < UnaryBase { }
+  ZeroOrOne         < UnaryBase { }
+  ZeroOrMore        < UnaryBase { }
+  OrderedChoice     < BinaryBase { }
+  Concatenation     < BinaryBase { }
+  
+  NamedCapture      < UnaryBase { var captargs }
+  NamedTextCapture  < UnaryBase { var captargs }
+  NamedTokenCapture < UnaryBase { var captargs }
+  Reduction         < UnaryBase { var captargs }
+  
+  ##
+  # Bindings of patterns to constructions.
+  
+  Patterns::UnaryBase << {
+    construct: construct_type.new(inner:inner.construct)
+  }
+  
+  Patterns::BinaryBase << {
+    construct: construct_type.new(first:first.construct,second:second.construct)
+  }
+  
+  Patterns::AnyCharacter      << { construct: AnyCharacter.new }
+  Patterns::Character         << { construct: Character      .new(code:code) }
+  Patterns::CharacterString   << { construct: CharacterString.new(codes:codes) }
+  Patterns::CharacterSet      << { construct: CharacterSet   .new(codes:codes) }
+  Patterns::CharacterRange    << { construct: CharacterRange .new(start:start
+                                                                   stop:stop) }
+  
+  Patterns::NegativePredicate << { construct_type: NegativePredicate }
+  Patterns::PositivePredicate << { construct_type: PositivePredicate }
+  Patterns::OneOrMore         << { construct_type: OneOrMore }
+  Patterns::ZeroOrOne         << { construct_type: ZeroOrOne }
+  Patterns::ZeroOrMore        << { construct_type: ZeroOrMore }
+  Patterns::OrderedChoice     << { construct_type: OrderedChoice }
+  Patterns::Concatenation     << { construct_type: Concatenation }
+  
+  Patterns::NamedCapture      << {
+    construct: NamedCapture.new(
+      inner: inner.construct
+      captargs: [self.name]
+    )
+  }
+  Patterns::NamedTextCapture  << {
+    construct: NamedTextCapture.new(
+      inner: inner.construct
+      captargs: [self.name]
+    )
+  }
+  Patterns::NamedTokenCapture  << {
+    construct: NamedTokenCapture.new(
+      inner: inner.construct
+      captargs: [self.name]
+    )
+  }
+  Patterns::Reduction         << {
+    construct: Reduction.new(
+      inner: inner.construct
+      captargs: [self.code, *self.args]
+    )
+  }
+  
+  ##
+  # The instruction sequence generator for each construction.
+  
+  AnyCharacter    << { sequence: [[:any, 1]] }
+  Character       << { sequence: [[:char, code]] }
+  CharacterString << { sequence: codes.map |code| { [:char, code] } }
+  CharacterSet    << { sequence: [[:charset, table]]
+                          table: codes.map |code| { [code, true] }.to_h }
+  CharacterRange  << { sequence: [[:charrange, start, stop]] }
+  
+  NegativePredicate << {
+    sequence: {
+      a = inner.sequence
+      [[:choice, a.size+2], *a, [:fail_twice]]
+    }
+  }
+  
+  PositivePredicate << {
+    sequence: {
+      a = inner.sequence
+      size = a.size
+      [[:choice, size+4], [:choice, size+1], *a, [:commit, 1], [:fail]]
+    }
+  }
+  
+  OneOrMore << {
+    var inlaid
+    sequence: {
+      one = inner.sequence
+      inlaid && (one = one + inlaid)
+      or_more = ZeroOrMore.new(inner:inner,inlaid:inlaid).sequence
+      [*one, *or_more]
+    }
+  }
+  
+  ZeroOrOne << {
+    sequence: {
+      a = inner.sequence
+      [[:choice, a.size+2], *a, [:commit, 1]]
+    }
+  }
+  
+  ZeroOrMore << {
+    var inlaid
+    sequence:
+      switch(inner, :"is_a?")
+        .when(CharacterSet) { [[:span, inner.table]] }
+        .else {
+          a = inner.sequence
+          inlaid && (a = a + inlaid)
+          size = a.size
+          [[:choice, size+2], *a, [:partial_commit, size*-1]]
+        }
+        .output
+  }
+  
+  OrderedChoice << {
+    sequence: {
+      a = first.sequence
+      b = second.sequence
+      [[:choice, a.size+2], *a, [:commit, b.size+1], *b]
+    }
+  }
+  
+  Concatenation << {
+    sequence: [*first.sequence, *second.sequence]
+  }
+  
+  NamedCapture << {
+    sequence: {
+      (inner.is_a?(OneOrMore) || inner.is_a?(ZeroOrMore)) &? (
+        inner.inlaid = [[:capture, [:m_split, captargs]]]
+        a = inner.sequence
+        [[:capture, [:m_start]], *a, [:capture, [:m_end, captargs]]]
+      ) ?? (
+        a = inner.sequence
+        [[:capture, [:c_start]], *a, [:capture, [:c_end, captargs]]]
+      )
+    }
+  }
+  
+  NamedTextCapture << {
+    sequence: {
+      a = inner.sequence
+      [[:capture, [:s_start]], *a, [:capture, [:s_end, captargs]]]
+    }
+  }
+  
+  NamedTokenCapture << {
+    sequence: {
+      a = inner.sequence
+      [[:capture, [:t_start]], *a, [:capture, [:t_end, captargs]]]
+    }
+  }
+  
+  Reduction << {
+    sequence: {
+      a = inner.sequence
+      [[:capture, [:r_start]], *a, [:capture, [:r_end, captargs]]]
+    }
+  }
+  
+}