myco 0.1.4 → 0.1.5

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

@@ -0,0 +1,284 @@
+
+::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(:Instructions, ::Myco::Component.new([::Myco.find_constant(:EmptyObject)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+  declare_meme(:char, [], nil, ::Myco.cscope.dup) { |code| (::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.subject.at(self.idx).__send__(
+    :==,
+    code
+  )) {(
+    self.__send__(
+      :ip=,
+      self.ip.__send__(
+        :+,
+        1
+      )
+    )
+    self.__send__(
+      :idx=,
+      self.idx.__send__(
+        :+,
+        1
+      )
+    )
+  )}) {self.__send__(
+    :ip=,
+    nil
+  )})}
+  declare_meme(:jump, [], nil, ::Myco.cscope.dup) { |label| (self.__send__(
+    :ip=,
+    self.ip.__send__(
+      :+,
+      label
+    )
+  ))}
+  declare_meme(:choice, [], nil, ::Myco.cscope.dup) { |label| (
+    self.stack.push([
+      self.ip.__send__(
+        :+,
+        label
+      ),
+      self.idx,
+      self.captures.dup
+    ])
+    self.__send__(
+      :ip=,
+      self.ip.__send__(
+        :+,
+        1
+      )
+    )
+  )}
+  declare_meme(:call, [], nil, ::Myco.cscope.dup) { |new_ipk| (
+    self.stack.push([
+      self.ip.__send__(
+        :+,
+        1
+      ),
+      self.ipk
+    ])
+    self.__send__(
+      :ip=,
+      0
+    )
+    self.__send__(
+      :ipk=,
+      new_ipk
+    )
+  )}
+  declare_meme(:return, [], nil, ::Myco.cscope.dup) { |*| (
+    addr = self.stack.pop
+    ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", addr) {(
+      self.__send__(
+        :ipk=,
+        addr.pop
+      )
+      self.__send__(
+        :ip=,
+        addr.pop
+      )
+      true
+    )}) {self.finish}
+  )}
+  declare_meme(:commit, [], nil, ::Myco.cscope.dup) { |label| (
+    self.stack.pop
+    self.__send__(
+      :ip=,
+      self.ip.__send__(
+        :+,
+        label
+      )
+    )
+  )}
+  declare_meme(:capture, [], nil, ::Myco.cscope.dup) { |metadata| (
+    self.captures.push([
+      self.idx,
+      metadata
+    ])
+    self.__send__(
+      :ip=,
+      self.ip.__send__(
+        :+,
+        1
+      )
+    )
+  )}
+  declare_meme(:handle_fail, [], nil, ::Myco.cscope.dup) { |*| (::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.stack.__send__(:empty?)) {::Myco.find_constant(:ErrorCondition).new}) {(
+    entry = self.stack.pop
+    size = entry.size
+    ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", size.__send__(
+      :==,
+      3
+    )) {(
+      self.__send__(
+        :captures=,
+        entry.pop
+      )
+      self.__send__(
+        :idx=,
+        entry.pop
+      )
+      self.__send__(
+        :ip=,
+        entry.pop
+      )
+      true
+    )}) {::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", size.__send__(
+      :==,
+      2
+    )) {(
+      self.__send__(
+        :ipk=,
+        entry.pop
+      )
+      self.__send__(
+        :ip=,
+        nil
+      )
+    )}) {::Myco.find_constant(:ErrorCondition).new}}
+  )})}
+  declare_meme(:finish, [], nil, ::Myco.cscope.dup) { |*| (self.__send__(
+    :ip=,
+    true
+  ))}
+  declare_meme(:charset, [], nil, ::Myco.cscope.dup) { |table| (::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", (
+    code = self.subject.at(self.idx)
+    ::Myco.branch_op(:"&&", code) {table.__send__(
+      :key?,
+      code
+    )}
+  )) {(
+    self.__send__(
+      :ip=,
+      self.ip.__send__(
+        :+,
+        1
+      )
+    )
+    self.__send__(
+      :idx=,
+      self.idx.__send__(
+        :+,
+        1
+      )
+    )
+  )}) {self.__send__(
+    :ip=,
+    nil
+  )})}
+  declare_meme(:charrange, [], nil, ::Myco.cscope.dup) { |start, stop| (::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", (
+    code = self.subject.at(self.idx)
+    ::Myco.branch_op(:"&&", ::Myco.branch_op(:"&&", code) {code.__send__(
+      :>=,
+      start
+    )}) {code.__send__(
+      :<=,
+      stop
+    )}
+  )) {(
+    self.__send__(
+      :ip=,
+      self.ip.__send__(
+        :+,
+        1
+      )
+    )
+    self.__send__(
+      :idx=,
+      self.idx.__send__(
+        :+,
+        1
+      )
+    )
+  )}) {self.__send__(
+    :ip=,
+    nil
+  )})}
+  declare_meme(:span, [], nil, ::Myco.cscope.dup) { |table| (self.loop { || (::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", (
+    code = self.subject.at(self.idx)
+    ::Myco.branch_op(:"&&", code) {table.__send__(
+      :key?,
+      code
+    )}
+  )) {self.__send__(
+    :idx=,
+    self.idx.__send__(
+      :+,
+      1
+    )
+  )}) {(
+    self.__send__(
+      :ip=,
+      self.ip.__send__(
+        :+,
+        1
+      )
+    )
+    self.__send__(:break)
+  )})})}
+  declare_meme(:any, [], nil, ::Myco.cscope.dup) { |count| (::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.idx.__send__(
+    :+,
+    count
+  ).__send__(
+    :>,
+    self.subject.size
+  )) {(
+    self.__send__(
+      :ip=,
+      nil
+    )
+    true
+  )}) {(
+    self.__send__(
+      :ip=,
+      self.ip.__send__(
+        :+,
+        1
+      )
+    )
+    self.__send__(
+      :idx=,
+      self.idx.__send__(
+        :+,
+        count
+      )
+    )
+  )})}
+  declare_meme(:partial_commit, [], nil, ::Myco.cscope.dup) { |label| (
+    entry = self.stack.pop
+    self.stack.push([
+      entry.first,
+      self.idx,
+      self.captures.dup
+    ])
+    self.__send__(
+      :ip=,
+      self.ip.__send__(
+        :+,
+        label
+      )
+    )
+  )}
+  declare_meme(:back_commit, [], nil, ::Myco.cscope.dup) { |label| (
+    entry = self.stack.pop
+    self.__send__(
+      :captures=,
+      entry.pop
+    )
+    self.__send__(
+      :idx=,
+      entry.pop
+    )
+    self.__send__(
+      :ip=,
+      self.ip.__send__(
+        :+,
+        label
+      )
+    )
+  )}
+  declare_meme(:fail_twice, [], nil, ::Myco.cscope.dup) { |*| (
+    ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.stack.__send__(:empty?)) {::Myco.find_constant(:ErrorCondition).new}) {self.stack.pop}
+    self.handle_fail
+  )}
+)}})
+.tap { |__c__| __c__.__name__ = :Instructions })}}.instance

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

@@ -0,0 +1,37 @@
+
+Machine < BasicObject, Instructions {
+  # The index of the next program instruction, or null indicating fail condition
+  var ip: 0
+  
+  # The key name in the rule table of the next program instruction
+  var ipk: :root
+  
+  # The current index into the subject string
+  var idx: 0
+  
+  # A list of stack entries, each of which is either a:
+  #   return_address (the instruction index to return to)
+  # or a list containing:
+  #   [fail_address, current_idx, current_capture_list] (a pending alternative)
+  var stack: []
+  
+  # A list of tuples, each containing:
+  #   [idx, captor] (the index into the subject and the captor to notify)
+  var captures: []
+  
+  # The subject string as an array of character codes
+  var subject: []
+  
+  # The sequence of instructions to execute for each rule name
+  var sequence_table: Hash.new
+  
+  
+  # Execute the root rule instruction sequence over the given subject
+  execute: loop {
+    ip |? handle_fail ?? (
+      (ip==true) &? break ?? send(*sequence_table.fetch(ipk)[ip])
+    )
+  }
+  
+  had_failure: !ip
+}

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

@@ -0,0 +1,24 @@
+
+::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(:Machine, ::Myco::Component.new([
+  ::Myco.find_constant(:BasicObject),
+  ::Myco.find_constant(:Instructions)
+], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+  declare_meme(:ip, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (0)}
+  declare_meme(:ipk, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (:root)}
+  declare_meme(:idx, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (0)}
+  declare_meme(:stack, [[:var, []]], nil, ::Myco.cscope.dup) { |*| ([])}
+  declare_meme(:captures, [[:var, []]], nil, ::Myco.cscope.dup) { |*| ([])}
+  declare_meme(:subject, [[:var, []]], nil, ::Myco.cscope.dup) { |*| ([])}
+  declare_meme(:sequence_table, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:Hash).new)}
+  declare_meme(:execute, [], nil, ::Myco.cscope.dup) { |*| (self.loop { || (::Myco.branch_op(:"??", ::Myco.branch_op(:"|?", self.ip) {self.handle_fail}) {::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.ip.__send__(
+    :==,
+    true
+  )) {self.__send__(:break)}) {self.send(*self.sequence_table.fetch(self.ipk).__send__(
+    :[],
+    self.ip
+  ))}})})}
+  declare_meme(:had_failure, [], nil, ::Myco.cscope.dup) { |*| (self.ip.__send__(:!))}
+)}})
+.tap { |__c__| __c__.__name__ = :Machine })}}.instance

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

@@ -0,0 +1,42 @@
+
+Parser < BasicObject {
+  
+  var grammar: Grammar { }
+  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
+    }
+    
+    self
+  }
+}

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

@@ -0,0 +1,52 @@
+
+::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(:Parser, ::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(: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
+    )}
+    machine = self.new_machine
+    machine.execute
+    self.__send__(
+      :unless,
+      machine.had_failure
+    ) { || (
+      processor = self.new_processor
+      processor.__send__(
+        :capture_items=,
+        machine.captures
+      )
+      self.__send__(
+        :result=,
+        processor.process
+      )
+    )}
+    self
+  )}
+)}})
+.tap { |__c__| __c__.__name__ = :Parser })}}.instance

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

@@ -0,0 +1,123 @@
+
+Patterns < EmptyObject {
+  
+  ##
+  # Basic types of patterns.
+  
+  Base < BasicObject { var name: parent_meme.name }
+  UnaryBase  < Base { var inner }
+  BinaryBase < Base { var first, var second }
+  
+  AnyCharacter      < Base { }
+  Character         < Base { var code }
+  CharacterString   < Base { var codes } # Concatenation for Characters
+  CharacterSet      < Base { var codes } # OrderedChoice for Characters
+  CharacterRange    < Base { var start, var stop }
+  
+  NegativePredicate < UnaryBase { }
+  PositivePredicate < UnaryBase { }
+  OneOrMore         < UnaryBase { }
+  ZeroOrOne         < UnaryBase { }
+  ZeroOrMore        < UnaryBase { }
+  OrderedChoice     < BinaryBase { }
+  Concatenation     < BinaryBase { }
+  
+  NamedCapture      < UnaryBase { }
+  NamedTextCapture  < UnaryBase { }
+  NamedTokenCapture < UnaryBase { }
+  Reduction         < UnaryBase { var block, var args: [] }
+  
+  ##
+  # Shorthand methods for creating primitive patterns
+  
+  ShorthandMethods < EmptyObject {
+    any:                   AnyCharacter.new
+    char:  |character|        Character.new(code:character.ord)
+    str:   |string|     CharacterString.new(codes:string.each_char.map(&:ord))
+    set:   |string|        CharacterSet.new(codes:string.each_char.map(&:ord))
+    range: |start, stop| CharacterRange.new(start:start.ord, stop:stop.ord)
+    r:     |pattern, &block|  Reduction.new(inner:pattern, block:block)
+  }
+  
+  ##
+  # Operator overloading for combining and modifying patterns.
+  #
+  # Each operation returns a new Pattern object composed of the operands
+  # so that complex grammars can be specified with relatively succint syntax.
+  
+  Base << {
+    "!":         NegativePredicate .new(inner:self)
+    "/": |other| OrderedChoice     .new(first:self, second:other)
+    "+": |other=false|
+      other &? Concatenation       .new(first:self, second:other)
+            ?? OneOrMore           .new(inner:self)
+    "-": |other=false|
+      other &? ErrorCondition      .new() # TODO: add exception handling to Myco
+            ?? ZeroOrOne           .new(inner:self)
+    "*": |other=false|
+      other &? ErrorCondition      .new()
+            ?? ZeroOrMore          .new(inner:self)
+    
+    "[]": |name| NamedCapture      .new(inner:self, name:name)
+    text: |name=:text|
+                 NamedTextCapture  .new(inner:self, name:name)
+    token: |name|
+                 NamedTokenCapture .new(inner:self, name:name)
+    
+    [private]
+    
+    # Add |other| to |orig| in a right-associative tree of type |type|
+    binary_right_assoc: |orig, other, type| {
+      cursor = orig
+      loop {
+        unless(cursor.second.is_a?(type)) { break }
+        cursor = cursor.second
+      }
+      cursor.second = type.new(first:cursor.second, second:other)
+      orig
+    }
+  }
+  
+  NegativePredicate << {
+    # Invert the polarity of the predicate instead of nesting the predicate
+    "!": PositivePredicate.new(inner:inner)
+  }
+  
+  PositivePredicate << {
+    # Invert the polarity of the predicate instead of nesting the predicate
+    "!": NegativePredicate.new(inner:inner)
+  }
+  
+  OrderedChoice << {
+    # Build a right-associative tree if the first operand of another "/"
+    "/": |other|
+      private.binary_right_assoc(self, other, OrderedChoice)
+  }
+  
+  Concatenation << {
+    # Build a right-associative tree if the first operand of another "+"
+    "+": |other=false|
+      other
+        &? private.binary_right_assoc(self, other, Concatenation)
+        ?? OneOrMore.new(inner:self)
+  }
+  
+  ##
+  # 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
+  }
+}