myco 0.1.8 → 0.1.9

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

@@ -1,139 +0,0 @@
-
-Instructions < EmptyObject {
-  
-  ##
-  # Basic Instructions
-  
-  # Test the character pointed to by the current index into the subject.
-  # Continue if the character |code| is equal, otherwise fail.
-  char: |code|
-    (subject.at(idx) == code)
-      &? (self.ip = ip + 1; self.idx = idx + 1)
-      ?? (self.ip = null) # failure
-  
-  # Move the instruction pointer forward by |label| instructions.
-  jump: |label|
-    self.ip = ip + label
-  
-  # Create a backtrack entry on the stack, pointing |label| instructions ahead.
-  choice: |label| {
-    stack.push([ip + label, idx, captures.dup])
-    self.ip = ip + 1
-  }
-  
-  # Push two-part return address onto the stack and goto start of |new_ipk|
-  call: |new_ipk| {
-    stack.push([ip+1, ipk])
-    self.ip = 0
-    self.ipk = new_ipk
-  }
-  
-  # Return from a call by popping the return address and jumping to it.
-  # It is assumed that the top of the stack is a return address from a :call.
-  return: {
-    addr = stack.pop
-    addr &? (
-      self.ipk = addr.pop
-      self.ip  = addr.pop
-      true
-    ) ?? finish
-  }
-  
-  # Pop and discard the backtrack entry from the stack and jump to |label|.
-  # It is assumed that the top of the stack is a backtrack entry from a :choice.
-  commit: |label| {
-    stack.pop
-    self.ip = ip + label
-  }
-  
-  # Note the current subject index and the given metadata for post-processing.
-  capture: |metadata| {
-    captures.push([idx, metadata])
-    self.ip = ip + 1
-  }
-  
-  # Pop the backtrack entry off the stack and copy the state from it,
-  # effectively pursuing the alternative posed by the last :choice.
-  handle_fail:
-    self.stack.empty?
-      &? ErrorCondition.new
-      ?? (
-        entry = stack.pop
-        size = entry.size
-        size == 3 &? ( # backtrack
-          self.captures = entry.pop
-          self.idx      = entry.pop
-          self.ip       = entry.pop
-          true
-        ) ?? ( # return and mark fail
-          size == 2 &? (
-            self.ipk = entry.pop
-            self.ip  = null
-          ) ?? ErrorCondition.new
-        )
-      )
-  
-  # Signal a successful match at the end of the complete pattern
-  finish:
-    self.ip = true
-  
-  ##
-  # Optimized Instructions
-  #
-  # These instructions could be expressed in terms of the Basic Instructions,
-  # but are more efficiently executed if given special implementations.
-  
-  # Like char, but accept any char whose code is a valid key in |table|
-  charset: |table|
-    (code=subject.at(idx); code && table.key?(code))
-      &? (self.ip = ip + 1; self.idx = idx + 1)
-      ?? (self.ip = null) # failure
-  
-  # Like char, but accept any char whose code is between |start| and |stop|
-  charrange: |start, stop|
-    (code=subject.at(idx); code && code>=start && code<=stop)
-      &? (self.ip = ip + 1; self.idx = idx + 1)
-      ?? (self.ip = null) # failure
-  
-  # (Kleene star applied to a charset)
-  span: |table| loop {
-    (code=subject.at(idx); code && table.key?(code))
-      &? (self.idx = idx + 1)
-      ?? (self.ip = ip + 1; break)
-  }
-  
-  # Match any character, |count| number of times.
-  any: |count|
-    (self.idx + count > subject.size)
-      &? (self.ip = null; true) # failure
-      ?? (
-        self.ip = ip + 1
-        self.idx = idx + count
-      )
-  
-  # Update the state for the backtrack entry on the top of the stack
-  # but don't change the fail address; then jump to |label|.
-  partial_commit: |label| {
-    entry = stack.pop
-    stack.push([entry.first, idx, captures.dup])
-    self.ip = ip + label
-  }
-  
-  # Pop the backtrack entry and restore state but jump to |label|
-  # instead of jumping to the popped fail address.
-  back_commit: |label| {
-    entry = stack.pop
-    self.captures = entry.pop
-    self.idx      = entry.pop
-    self.ip = ip + label
-  }
-  
-  # Pop a backtrack entry off the stack and discard it, then fail.
-  fail_twice: {
-    self.stack.empty?
-      &? ErrorCondition.new
-      ?? stack.pop
-    handle_fail
-  }
-  
-}

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

@@ -1,284 +0,0 @@
-
-::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.cscope.for_method_definition::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

@@ -1,37 +0,0 @@
-
-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: ::Ruby::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
-}