myco 0.1.4 → 0.1.5

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

@@ -0,0 +1,164 @@
+
+::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(:Patterns, ::Myco::Component.new([::Myco.find_constant(:EmptyObject)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+  ::Myco.cscope.for_method_definition.const_set(:Base, ::Myco::Component.new([::Myco.find_constant(:BasicObject)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {(declare_meme(:name, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (self.parent_meme.name)})}})
+  .tap { |__c__| __c__.__name__ = :Base }
+  ::Myco.cscope.for_method_definition.const_set(:UnaryBase, ::Myco::Component.new([::Myco.find_constant(:Base)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {(declare_meme(:inner, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil})}})
+  .tap { |__c__| __c__.__name__ = :UnaryBase }
+  ::Myco.cscope.for_method_definition.const_set(:BinaryBase, ::Myco::Component.new([::Myco.find_constant(:Base)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {(
+    declare_meme(:first, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+    declare_meme(:second, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  )}})
+  .tap { |__c__| __c__.__name__ = :BinaryBase }
+  ::Myco.cscope.for_method_definition.const_set(:AnyCharacter, ::Myco::Component.new([::Myco.find_constant(:Base)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}})
+  .tap { |__c__| __c__.__name__ = :AnyCharacter }
+  ::Myco.cscope.for_method_definition.const_set(:Character, ::Myco::Component.new([::Myco.find_constant(:Base)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {(declare_meme(:code, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil})}})
+  .tap { |__c__| __c__.__name__ = :Character }
+  ::Myco.cscope.for_method_definition.const_set(:CharacterString, ::Myco::Component.new([::Myco.find_constant(:Base)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {(declare_meme(:codes, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil})}})
+  .tap { |__c__| __c__.__name__ = :CharacterString }
+  ::Myco.cscope.for_method_definition.const_set(:CharacterSet, ::Myco::Component.new([::Myco.find_constant(:Base)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {(declare_meme(:codes, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil})}})
+  .tap { |__c__| __c__.__name__ = :CharacterSet }
+  ::Myco.cscope.for_method_definition.const_set(:CharacterRange, ::Myco::Component.new([::Myco.find_constant(:Base)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {(
+    declare_meme(:start, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+    declare_meme(:stop, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  )}})
+  .tap { |__c__| __c__.__name__ = :CharacterRange }
+  ::Myco.cscope.for_method_definition.const_set(:NegativePredicate, ::Myco::Component.new([::Myco.find_constant(:UnaryBase)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}})
+  .tap { |__c__| __c__.__name__ = :NegativePredicate }
+  ::Myco.cscope.for_method_definition.const_set(:PositivePredicate, ::Myco::Component.new([::Myco.find_constant(:UnaryBase)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}})
+  .tap { |__c__| __c__.__name__ = :PositivePredicate }
+  ::Myco.cscope.for_method_definition.const_set(:OneOrMore, ::Myco::Component.new([::Myco.find_constant(:UnaryBase)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}})
+  .tap { |__c__| __c__.__name__ = :OneOrMore }
+  ::Myco.cscope.for_method_definition.const_set(:ZeroOrOne, ::Myco::Component.new([::Myco.find_constant(:UnaryBase)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}})
+  .tap { |__c__| __c__.__name__ = :ZeroOrOne }
+  ::Myco.cscope.for_method_definition.const_set(:ZeroOrMore, ::Myco::Component.new([::Myco.find_constant(:UnaryBase)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}})
+  .tap { |__c__| __c__.__name__ = :ZeroOrMore }
+  ::Myco.cscope.for_method_definition.const_set(:OrderedChoice, ::Myco::Component.new([::Myco.find_constant(:BinaryBase)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}})
+  .tap { |__c__| __c__.__name__ = :OrderedChoice }
+  ::Myco.cscope.for_method_definition.const_set(:Concatenation, ::Myco::Component.new([::Myco.find_constant(:BinaryBase)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}})
+  .tap { |__c__| __c__.__name__ = :Concatenation }
+  ::Myco.cscope.for_method_definition.const_set(:NamedCapture, ::Myco::Component.new([::Myco.find_constant(:UnaryBase)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}})
+  .tap { |__c__| __c__.__name__ = :NamedCapture }
+  ::Myco.cscope.for_method_definition.const_set(:NamedTextCapture, ::Myco::Component.new([::Myco.find_constant(:UnaryBase)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}})
+  .tap { |__c__| __c__.__name__ = :NamedTextCapture }
+  ::Myco.cscope.for_method_definition.const_set(:NamedTokenCapture, ::Myco::Component.new([::Myco.find_constant(:UnaryBase)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}})
+  .tap { |__c__| __c__.__name__ = :NamedTokenCapture }
+  ::Myco.cscope.for_method_definition.const_set(:Reduction, ::Myco::Component.new([::Myco.find_constant(:UnaryBase)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {(
+    declare_meme(:block, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+    declare_meme(:args, [[:var, []]], nil, ::Myco.cscope.dup) { |*| ([])}
+  )}})
+  .tap { |__c__| __c__.__name__ = :Reduction }
+  ::Myco.cscope.for_method_definition.const_set(:ShorthandMethods, ::Myco::Component.new([::Myco.find_constant(:EmptyObject)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {(
+    declare_meme(:any, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:AnyCharacter).new)}
+    declare_meme(:char, [], nil, ::Myco.cscope.dup) { |character| (::Myco.find_constant(:Character).new({:code => character.ord}))}
+    declare_meme(:str, [], nil, ::Myco.cscope.dup) { |string| (::Myco.find_constant(:CharacterString).new({:codes => string.each_char.map(&:ord)}))}
+    declare_meme(:set, [], nil, ::Myco.cscope.dup) { |string| (::Myco.find_constant(:CharacterSet).new({:codes => string.each_char.map(&:ord)}))}
+    declare_meme(:range, [], nil, ::Myco.cscope.dup) { |start, stop| (::Myco.find_constant(:CharacterRange).new({
+      :start => start.ord,
+      :stop => stop.ord
+    }))}
+    declare_meme(:r, [], nil, ::Myco.cscope.dup) { |pattern, &block| (::Myco.find_constant(:Reduction).new({
+      :inner => pattern,
+      :block => block
+    }))}
+  )}})
+  .tap { |__c__| __c__.__name__ = :ShorthandMethods }
+  ::Myco.find_constant(:Base).component_eval {(
+    declare_meme(:!, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:NegativePredicate).new({:inner => self}))}
+    declare_meme(:/, [], nil, ::Myco.cscope.dup) { |other| (::Myco.find_constant(:OrderedChoice).new({
+      :first => self,
+      :second => other
+    }))}
+    declare_meme(:+, [], nil, ::Myco.cscope.dup) { |other=false| (::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", other) {::Myco.find_constant(:Concatenation).new({
+      :first => self,
+      :second => other
+    })}) {::Myco.find_constant(:OneOrMore).new({:inner => self})})}
+    declare_meme(:-, [], nil, ::Myco.cscope.dup) { |other=false| (::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", other) {::Myco.find_constant(:ErrorCondition).new}) {::Myco.find_constant(:ZeroOrOne).new({:inner => self})})}
+    declare_meme(:*, [], nil, ::Myco.cscope.dup) { |other=false| (::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", other) {::Myco.find_constant(:ErrorCondition).new}) {::Myco.find_constant(:ZeroOrMore).new({:inner => self})})}
+    declare_meme(:[], [], nil, ::Myco.cscope.dup) { |name| (::Myco.find_constant(:NamedCapture).new({
+      :inner => self,
+      :name => name
+    }))}
+    declare_meme(:text, [], nil, ::Myco.cscope.dup) { |name=:text| (::Myco.find_constant(:NamedTextCapture).new({
+      :inner => self,
+      :name => name
+    }))}
+    declare_meme(:token, [], nil, ::Myco.cscope.dup) { |name| (::Myco.find_constant(:NamedTokenCapture).new({
+      :inner => self,
+      :name => name
+    }))}
+    __category__(:private).component_eval {(declare_meme(:binary_right_assoc, [], nil, ::Myco.cscope.dup) { |orig, other, type| (
+      cursor = orig
+      self.loop { || (
+        self.__send__(
+          :unless,
+          cursor.second.__send__(
+            :is_a?,
+            type
+          )
+        ) { || (self.__send__(:break))}
+        cursor = cursor.second
+      )}
+      cursor.__send__(
+        :second=,
+        type.new({
+          :first => cursor.second,
+          :second => other
+        })
+      )
+      orig
+    )})}
+  )}
+  ::Myco.find_constant(:NegativePredicate).component_eval {(declare_meme(:!, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:PositivePredicate).new({:inner => self.inner}))})}
+  ::Myco.find_constant(:PositivePredicate).component_eval {(declare_meme(:!, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:NegativePredicate).new({:inner => self.inner}))})}
+  ::Myco.find_constant(:OrderedChoice).component_eval {(declare_meme(:/, [], nil, ::Myco.cscope.dup) { |other| (self.private.binary_right_assoc(
+    self,
+    other,
+    ::Myco.find_constant(:OrderedChoice)
+  ))})}
+  ::Myco.find_constant(:Concatenation).component_eval {(declare_meme(:+, [], nil, ::Myco.cscope.dup) { |other=false| (::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", other) {self.private.binary_right_assoc(
+    self,
+    other,
+    ::Myco.find_constant(:Concatenation)
+  )}) {::Myco.find_constant(:OneOrMore).new({:inner => self})})})}
+  ::Myco.find_constant(:Reduction).component_eval {(
+    ::Myco.cscope.for_method_definition.const_set(:Environment, ::Myco::Component.new([
+      ::Myco.find_constant(:EmptyObject),
+      ::Myco.find_constant(:BasicDecorators)
+    ], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+    .tap { |__c__| __c__.__last__ = __c__.component_eval {(
+      declare_meme(:captures, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+      declare_meme(:builder, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+      declare_meme(:method_missing, [], nil, ::Myco.cscope.dup) { |name, *args, &block| (self.captures.fetch(name) { || (self.builder.send(
+        name,
+        *args,
+        &block
+      ))})}
+      declare_meme(:!, [], nil, ::Myco.cscope.dup) { |*| (nil)}
+    )}})
+    .tap { |__c__| __c__.__name__ = :Environment }
+    declare_meme(:code, [], nil, ::Myco.cscope.dup) { |*| (self.block.block.compiled_code)}
+  )}
+)}})
+.tap { |__c__| __c__.__name__ = :Patterns })}}.instance

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

@@ -0,0 +1,236 @@
+
+Processor < BasicObject {
+  var string: ""        # The source string to be processed
+  var capture_items: [] # The stream of capture tokens to be processed
+  var builder: null     # The AST Builder to use in the reduction environment
+  
+  # Process the inputs and return the final captures layer
+  process: setup; process_each; validate_state; final_captures
+  
+  # A lightweight class used for string captures in the reduction environment
+  Token < BasicObject {
+    var type
+    var text
+    var row
+    var col
+    
+    inspect: [type, text, row, col].inspect
+    to_s:    [type, text, row, col].inspect
+    
+    line: row # alias
+    
+    sym:              text.to_sym
+    float:            text.to_f
+    integer: |base=0| text.to_inum(base, true)
+  }
+  
+  # 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 { }
+  var reduction_env_cscope:
+    ::Rubinius::ConstantScope.new(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
+  var tidx_stack: [] # A FILO stack of start indices for token captures
+  var midx_stack: [] # A FILO stack of start indices for multiplicit captures
+  var ridx_stack: [] # A FILO stack of start indices for reductions
+  var capt_stack: [] # A FILO stack of Hashes with capture names, values
+  
+  # Given a string, return a map of indices of newline positions to line numbers
+  memoize line_map_for: |string| {
+    idx_hash = ::Hash.new
+    idx_hash[0] = 0
+    count = 0
+    idx = 0
+    loop {
+      idx = string.index("\n", idx + 1)
+      idx || break
+      count = count + 1
+      idx_hash[idx] = count
+    }
+    idx_hash
+  }
+  
+  # Given an index and string, return the row (line) and column numbers
+  position_of: |idx, string| {
+    nl_idx = string.rindex("\n", idx) || 0
+    row = line_map_for(string).fetch(nl_idx) + 1
+    col = idx - nl_idx
+    [row, col]
+  }
+  
+  # Push or pop a layer to/from the capture stack
+  push_layer: capt_stack.push(::Hash.new)
+  pop_layer:  capt_stack.pop
+  
+  setup:
+    push_layer
+  
+  final_captures:
+    pop_layer
+      .select |k,v| { k.is_a?(::Symbol) }
+      .map    |k,v| { [k,v.last] }
+      .to_h
+  
+  process_each: capture_items.each |idx, metadata| {
+    type     = metadata[0]
+    captargs = metadata[1] || []
+    send(type, idx, *captargs)
+  }
+  
+  validate_state: {
+    cidx_stack.empty? || raise("unbalanced cidx_stack: "cidx_stack"")
+    sidx_stack.empty? || raise("unbalanced sidx_stack: "sidx_stack"")
+    tidx_stack.empty? || raise("unbalanced tidx_stack: "tidx_stack"")
+    midx_stack.empty? || raise("unbalanced midx_stack: "midx_stack"")
+    ridx_stack.empty? || raise("unbalanced ridx_stack: "ridx_stack"")
+  }
+  
+  # Start of a named capture
+  c_start: |idx| {
+    # Note the starting index of the capture
+    cidx_stack.push(idx)
+  }
+  
+  # End of a named capture
+  c_end: |idx, name| {
+    captures = capt_stack.last
+    start_idx = cidx_stack.pop
+    
+    # Pick up the captured reduction, if its start and end 
+    # indices are within the bounds we are looking for.
+    use_reduction = false
+    value = captures[idx]
+    value &? (
+      loc = value.first
+      value = value.last
+      ((loc.first>=start_idx) && (loc.last<=idx)) &? (
+        use_reduction = true
+      ) ?? (
+        value = null
+      )
+    )
+    
+    # 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)
+    )
+    
+    store_value = [[start_idx, idx], value]
+    captures.store(idx, store_value)
+    captures.store(name, store_value)
+  }
+  
+  # Start of a named text capture
+  s_start: |idx| {
+    # Note the starting index of the text capture
+    sidx_stack.push(idx)
+  }
+  
+  # End of a named text capture
+  s_end: |idx, name| {
+    captures = capt_stack.last
+    start_idx = sidx_stack.pop
+    
+    value = string.slice(start_idx, idx-start_idx)
+    store_value = [[start_idx, idx], value]
+    captures.store(idx, store_value)
+    captures.store(name, store_value)
+  }
+  
+  # Start of a named token capture
+  t_start: |idx| {
+    # Note the starting index of the text capture
+    tidx_stack.push(idx)
+  }
+  
+  # End of a named token capture
+  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
+    )
+    store_value = [[start_idx, idx], value]
+    captures.store(idx, store_value)
+    captures.store(name, store_value)
+  }
+  
+  # Start of a multiplicit capture
+  m_start: |idx| {
+    midx_stack.push(idx)
+    c_start(idx)
+  }
+  
+  # Split of a multiplicit capture
+  m_split: |idx, name| {
+    c_end(idx, name)
+    c_start(idx)
+  }
+  
+  # End of a multiplicit capture
+  m_end: |idx, name| {
+    captures = capt_stack.last
+    start_idx = midx_stack.pop
+    cidx_stack.pop # Discard cidx pushed by m_start/end calling c_start
+    
+    # Try to find a group of "anonymous" captures by index first
+    value = []
+    captures.each |k,v| {
+      (k.is_a?(::Fixnum) && k<=idx && k>start_idx) && (
+        loc = v.first
+        (loc.first>=start_idx) && (
+          value.push(v.last)
+        )
+      )
+    }
+    
+    # If the group is empty and the string length is not zero
+    # slice the string with the given indices to get a text value
+    (value.empty? && !(start_idx==idx)) && (
+      value = string.slice(start_idx, idx-start_idx)
+    )
+    
+    store_value = [[start_idx, idx], value]
+    captures.store(idx, store_value)
+    captures.store(name, store_value)
+  }
+  
+  # Start of a reduction
+  r_start: |idx| (
+    # Push a new layer of reduction context onto the stack
+    push_layer
+    ridx_stack.push(idx)
+  )
+  
+  # End of a reduction
+  r_end: |idx, code, *args| {
+    captures = pop_layer
+    start_idx = ridx_stack.pop
+    
+    # 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
+    
+    # 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,
+      reduction_env,
+      [],
+      null,
+    )
+    store_value = [[start_idx, idx], value]
+    capt_stack.last.store(idx, store_value)
+  }
+}