myco 0.1.4 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c497fbe2e87f23f8cea7374510cbac8a7aefdd6a
-  data.tar.gz: 519dc6fbe9d381ee9478ca46fa71fefecd5318b8
+  metadata.gz: bc8d9aa903a16793652f0a984ea68b5dc0058dee
+  data.tar.gz: 0ed0d4a3adb25552541a384019deeb7016d67057
 SHA512:
-  metadata.gz: 6e7dc8c64ae6d9a26b421ba7a45dc5a0ec44f969519e128ebe680701c39d68dd70b6dde54743e99c2c5fb0b2267696c4e119095cead9c41254b1de50d28556a4
-  data.tar.gz: 05cf18931bdf1d8632dcf9d7d88e09cc014b8af1e6a86d70f8a2b74395c8210c36d999cb25f4fc0096380618132e09887d4af23aa0130a73724055e0b7029b3d
+  metadata.gz: d50aa9cdf66fec631609560ea0c5bac80a39a27be523ca32ad1529795cbb0aab4cf9db3b11b55e30718e86191915c86ec95edec7ee9562d0bb687ad13f1025c3
+  data.tar.gz: c9ec127069f005ad5ba684b2a0fec708d7d8abceb297283838d323a14f65e0fe6df211840abf4cdbcce92db437c8b760049d2134ba30be15690c738a808d5fa5

data/lib/myco/bootstrap/find_constant.rb

@@ -61,27 +61,20 @@ module Myco
     Rubinius::ConstantScope.of_sender
   end
   
-  def self.find_constant(name, scope=nil)
-    name = ::Rubinius::Type.coerce_to_constant_name name
-    scope ||= ::Rubinius::ConstantScope.of_sender
-    
-    category  = scope.myco_category
-    component = scope.myco_component
-    file      = scope.myco_file
-    
+  def self.find_constant(name, scope=Rubinius::ConstantScope.of_sender)
     # TODO: optimize this constant search
     # (it currently searches each ancestor of each nested component scope)
     bucket = nil
     scope.myco_levels.detect { |level|
       bucket = find_constant_bucket_in_module(level, name)
     }
-    bucket ? bucket.constant : ::Rubinius::Type.const_get(::Myco, name)
+    bucket ? bucket.constant : Rubinius::Type.const_get(::Myco, name)
   end
   
   def self.find_constant_bucket_in_module(mod, name, inherit=true)
-    current, constant = mod, nil
+    current = mod
     
-    while current and ::Rubinius::Type.object_kind_of? current, Module
+    while current and Rubinius::Type.object_kind_of? current, Module
       if bucket = current.constant_table.lookup(name)
         return bucket
       end

data/lib/myco/code_loader.rb

@@ -263,7 +263,8 @@ module Myco
     class RubyLoader < AbstractLoader
       def is_rb?; true end
       
-      def emit_rb!; nil end
+      def emit_rb!;  nil end
+      def emit_rbc!; nil end
       
       def initialize *args
         super *args

data/lib/myco/code_tools/AST/ConstantAccess.my

@@ -16,14 +16,58 @@ CodeTools::AST << {
         g.push_cpath_top
         g.find_const(first_name)
       ) ?? (
+        Myco.find_constant_bytecode(g, first_name)
+      )
+      
+      name_list.each |name| { g.find_const(name) }
+    }
+    
+    ::Myco::SingletonClass << {
+      find_constant_bytecode: |g, name| {
         g.push_cpath_top
         g.find_const(:"Myco")
-          g.push_literal(first_name)
+          g.push_literal(name)
           g.push_scope
         g.send(:find_constant, 2)
-      )
+      }
       
-      name_list.each |name| { g.find_const(name) }
+      # TODO: use the try_find_const_fast instruction here, when it is merged into Rubinius.
+      # find_constant_bytecode: |g, name| {
+      #   loop_start_label = g.new_label
+      #   retry_label = g.new_label
+      #   fail_label = g.new_label
+      #   done_label = g.new_label
+        
+      #   # g.push_rubinius; g.push_literal(name); g.send(:p, 1, true); g.pop
+        
+      #   g.push_scope
+      #   g.send(:myco_levels, 0)
+      #   # TODO: don't dup, iterate without mutating
+      #   g.send(:dup, 0)                         # stack: myco_levels
+        
+      #   loop_start_label.set!
+      #   g.dup_top                               # stack: myco_levels, myco_levels
+      #   g.send(:pop, 0)                         # stack: myco_levels, mod
+        
+      #   g.dup_top                               # stack: myco_levels, mod, mod
+      #   g.goto_if_nil(fail_label)               # stack: myco_levels, mod
+        
+      #   g.try_find_const(name)                  # stack: myco_levels, result
+      #   g.dup_top                               # stack: myco_levels, result, result
+        
+      #   g.goto_if_not_undefined(done_label)     # stack: myco_levels, undefined
+      #   g.pop                                   # stack: myco_levels
+      #   g.goto(loop_start_label)
+        
+      #   fail_label.set!                         # stack: myco_levels, mod
+      #   g.pop                                   # stack: myco_levels
+      #   g.push_cpath_top; g.find_const(:"Myco") # stack: myco_levels, ::Myco
+      #     g.push_literal(name)
+      #   g.send(:const_get, 1)                   # stack: myco_levels, result
+        
+      #   done_label.set!                         # stack: myco_levels, result
+      #   g.swap; g.pop                           # stack: result
+      # }
     }
   }
   

data/lib/myco/code_tools/AST/ConstantAccess.my.rb

@@ -16,17 +16,21 @@
     ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.toplevel) {(
       g.push_cpath_top
       g.find_const(first_name)
-    )}) {(
-      g.push_cpath_top
-      g.find_const(:Myco)
-      g.push_literal(first_name)
-      g.push_scope
-      g.send(
-        :find_constant,
-        2
-      )
+    )}) {::Myco.find_constant(:Myco).find_constant_bytecode(
+      g,
+      first_name
     )}
     name_list.each { |name| (g.find_const(name))}
   )}
+  ::Myco::SingletonClass.component_eval {(declare_meme(:find_constant_bytecode, [], nil, ::Myco.cscope.dup) { |g, name| (
+    g.push_cpath_top
+    g.find_const(:Myco)
+    g.push_literal(name)
+    g.push_scope
+    g.send(
+      :find_constant,
+      2
+    )
+  )})}
 )}})
 .tap { |__c__| __c__.__name__ = :ConstantAccess })})}}.instance

data/lib/myco/code_tools/AST/ConstantAssignment.my

@@ -18,11 +18,7 @@ CodeTools::AST << {
         first_name && g.find_const(first_name)
       ) ?? (
         first_name &? (
-          g.push_cpath_top
-          g.find_const(:"Myco")
-            g.push_literal(first_name)
-            g.push_scope
-          g.send(:find_constant, 2)
+          Myco.find_constant_bytecode(g, first_name)
         ) ?? (
           g.push_scope
           g.send(:for_method_definition, 0)

data/lib/myco/code_tools/AST/ConstantAssignment.my.rb

@@ -17,15 +17,9 @@
     ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.constant.toplevel) {(
       g.push_cpath_top
       ::Myco.branch_op(:"&&", first_name) {g.find_const(first_name)}
-    )}) {::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", first_name) {(
-      g.push_cpath_top
-      g.find_const(:Myco)
-      g.push_literal(first_name)
-      g.push_scope
-      g.send(
-        :find_constant,
-        2
-      )
+    )}) {::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", first_name) {::Myco.find_constant(:Myco).find_constant_bytecode(
+      g,
+      first_name
     )}) {(
       g.push_scope
       g.send(

data/lib/myco/code_tools/AST/ToRuby.my

@@ -238,8 +238,11 @@ CodeTools::AST << {
   }
   
   DeclareDecorator << {
-    to_ruby: |g|
-      g.add("["self.name.value.inspect", "); g.add(self.arguments); g.add("]")
+    to_ruby: |g| {
+      g.add("["self.name.value.inspect", [")
+        g.list(self.arguments.body, ",", auto_lines:true)
+      g.add("]]")
+    }
   }
   
   BlockParameter << {

data/lib/myco/code_tools/AST/ToRuby.my.rb

@@ -208,9 +208,13 @@
     g.add("}")
   )})})}
   ::Myco.find_constant(:DeclareDecorator).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
-    g.add("[#{self.name.value.inspect}, ")
-    g.add(self.arguments)
-    g.add("]")
+    g.add("[#{self.name.value.inspect}, [")
+    g.list(
+      self.arguments.body,
+      ",",
+      {:auto_lines => true}
+    )
+    g.add("]]")
   )})}
   ::Myco.find_constant(:BlockParameter).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (g.add("&#{self.name}"))})}
   ::Myco.find_constant(:ParameterAssembly).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (

data/lib/myco/code_tools/AST.my

@@ -1,6 +1,7 @@
 
 CodeTools::AST << {
   BuilderMethods: Module.new { } # TODO: move out of this file
+  Builder < BasicObject, BuilderMethods { }
 }
 
 import 'AST/Node.my'

data/lib/myco/code_tools/AST.my.rb

@@ -1,7 +1,15 @@
 
 ::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-  ::Myco.find_constant(:CodeTools)::AST.component_eval {(::Myco.cscope.for_method_definition.const_set(:BuilderMethods, (::Myco.find_constant(:Module).new { || nil})))}
+  ::Myco.find_constant(:CodeTools)::AST.component_eval {(
+    ::Myco.cscope.for_method_definition.const_set(:BuilderMethods, (::Myco.find_constant(:Module).new { || nil}))
+    ::Myco.cscope.for_method_definition.const_set(:Builder, ::Myco::Component.new([
+      ::Myco.find_constant(:BasicObject),
+      ::Myco.find_constant(:BuilderMethods)
+    ], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+    .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}})
+    .tap { |__c__| __c__.__name__ = :Builder }
+  )}
   declare_meme(:"AST/Node.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
   declare_meme(:"AST/Script.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
   declare_meme(:"AST/StringLiteral.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}

data/lib/myco/code_tools/Parser.my

@@ -0,0 +1,24 @@
+
+# TODO: include Pegleromyces library in a better way than clone into subdir
+import as(:"Pegleromyces") 'parser/pegleromyces/lib/pegleromyces.my'
+
+# TODO: remove this hack
+::Myco::Pegleromyces: Pegleromyces
+
+CodeTools::Parser < BasicObject {
+  MycoGrammar: Myco.eval_file('parser/MycoGrammar.my')
+  MycoBuilder: Myco.eval_file('parser/MycoBuilder.my')
+  
+  MycoParser: Pegleromyces::BytecodeParser {
+    var grammar: MycoGrammar
+    # TODO: re-evaluate design that returns an existing builder as 'new_builder'
+    new_builder: MycoBuilder
+  }
+  
+  parse_string: |string| {
+    parser = MycoParser
+    parser.parse(string)
+    parser.result &?
+      parser.result.fetch(:root) ?? parser.raise_error
+  }
+}

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

@@ -0,0 +1,25 @@
+
+::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+  declare_meme(:"parser/pegleromyces/lib/pegleromyces.my", [
+    [:as, [:Pegleromyces]],
+    [:import, []]
+  ], nil, ::Myco.cscope.dup) { |*| nil}
+  ::Myco::Pegleromyces = (::Myco.find_constant(:Pegleromyces))
+  ::Myco.find_constant(:CodeTools)::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.const_set(:MycoGrammar, (::Myco.find_constant(:Myco).eval_file("parser/MycoGrammar.my")))
+    ::Myco.cscope.for_method_definition.const_set(:MycoBuilder, (::Myco.find_constant(:Myco).eval_file("parser/MycoBuilder.my")))
+    ::Myco.cscope.for_method_definition.const_set(:MycoParser, (::Myco::Component.new([::Myco.find_constant(:Pegleromyces)::BytecodeParser], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+    .tap { |__c__| __c__.__last__ = __c__.component_eval {(
+      declare_meme(:grammar, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:MycoGrammar))}
+      declare_meme(:new_builder, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:MycoBuilder))}
+    )}}.instance))
+    declare_meme(:parse_string, [], nil, ::Myco.cscope.dup) { |string| (
+      parser = ::Myco.find_constant(:MycoParser)
+      parser.parse(string)
+      ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", parser.result) {parser.result.fetch(:root)}) {parser.raise_error}
+    )}
+  )}}
+  .tap { |__c__| __c__.__name__ = :Parser }
+)}}.instance

data/lib/myco/code_tools/parser/MycoBuilder.my

@@ -0,0 +1,67 @@
+
+BasicObject {
+  # TODO: be more clever here
+  ASTBuilder: ::CodeTools::AST::Builder.new
+  var ast: ASTBuilder
+  
+  var escape_encodings: {
+    hash = Hash.new
+    hash["\\a"] =  7.chr # \a  0x07  Bell or alert
+    hash["\\b"] =  8.chr # \b  0x08  Backspace
+    # TODO:              # \cx       Control-x
+    # TODO:              # \C-x      Control-x
+    hash["\\e"] = 27.chr # \e  0x1b  Escape
+    hash["\\f"] = 12.chr # \f  0x0c  Formfeed
+    # TODO:              # \M-\C-x   Meta-Control-x
+    hash["\\n"] = 10.chr # \n  0x0a  Newline
+    # TODO:              # \nnn      Octal notation, where n is a digit
+    hash["\\r"] = 13.chr # \r  0x0d  Carriage return
+    hash["\\s"] = 32.chr # \s  0x20  Space
+    hash["\\t"] =  9.chr # \t  0x09  Tab
+    hash["\\v"] = 11.chr # \v  0x0b  Vertical tab
+    # TODO:              # \xnn      Hexadecimal notation, where n is a digit
+    hash
+  }
+  
+  # Encode escape characters in string literals
+  # TODO: rigorously test and refine
+  encode_escapes: |str| {
+    str.gsub(Regexp.new("\\\\.")) |substr| {
+      escape_encodings.fetch(substr, substr[-1])
+    }
+  }
+  
+  # Given a node,op list ([node, op, node, op, ... node]) and operator types,
+  # collapse the (node, op, node) groups where the operator is one of the types
+  #
+  # This function is meant to be called several times on the same list,
+  # with a different set of operator types each time, in order of precedence.
+  #
+  collapse: |input, *types, &block| {
+    output = []
+    
+    # Scan through, reducing or shifting based on the operator
+    loop {
+      (input.count > 2) || break
+      n0 = input.shift
+      op = input.shift
+      
+      types.include?(op.type) &? (
+        n1 = input.shift
+        
+        result = block
+          &? block.call(n0,op,n1)
+          ?? ast.invoke(op, n0, op.sym, ast.argass(n1, [n1]))
+        input.unshift(result)
+      ) ?? (
+        output.push(n0)
+        output.push(op)
+      )
+    }
+    
+    # Push the last item remaining
+    output.push(input.shift)
+    
+    input.replace(output)
+  }
+}

data/lib/myco/code_tools/parser/MycoBuilder.my.rb

@@ -0,0 +1,99 @@
+
+::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(::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.const_set(:ASTBuilder, (::CodeTools::AST::Builder.new))
+  declare_meme(:ast, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:ASTBuilder))}
+  declare_meme(:escape_encodings, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (
+    hash = ::Myco.find_constant(:Hash).new
+    hash.__send__(
+      :[]=,
+      "\\a",
+      7.chr
+    )
+    hash.__send__(
+      :[]=,
+      "\\b",
+      8.chr
+    )
+    hash.__send__(
+      :[]=,
+      "\\e",
+      27.chr
+    )
+    hash.__send__(
+      :[]=,
+      "\\f",
+      12.chr
+    )
+    hash.__send__(
+      :[]=,
+      "\\n",
+      10.chr
+    )
+    hash.__send__(
+      :[]=,
+      "\\r",
+      13.chr
+    )
+    hash.__send__(
+      :[]=,
+      "\\s",
+      32.chr
+    )
+    hash.__send__(
+      :[]=,
+      "\\t",
+      9.chr
+    )
+    hash.__send__(
+      :[]=,
+      "\\v",
+      11.chr
+    )
+    hash
+  )}
+  declare_meme(:encode_escapes, [], nil, ::Myco.cscope.dup) { |str| (str.gsub(::Myco.find_constant(:Regexp).new("\\\\.")) { |substr| (self.escape_encodings.fetch(
+    substr,
+    substr.__send__(
+      :[],
+      -1
+    )
+  ))})}
+  declare_meme(:collapse, [], nil, ::Myco.cscope.dup) { |input, *types, &block| (
+    output = []
+    self.loop { || (
+      ::Myco.branch_op(:"||", input.count.__send__(
+        :>,
+        2
+      )) {self.__send__(:break)}
+      n0 = input.shift
+      op = input.shift
+      ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", types.__send__(
+        :include?,
+        op.type
+      )) {(
+        n1 = input.shift
+        result = ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", block) {block.call(
+          n0,
+          op,
+          n1
+        )}) {self.ast.invoke(
+          op,
+          n0,
+          op.sym,
+          self.ast.argass(
+            n1,
+            [n1]
+          )
+        )}
+        input.unshift(result)
+      )}) {(
+        output.push(n0)
+        output.push(op)
+      )}
+    )}
+    output.push(input.shift)
+    input.replace(output)
+  )}
+)}}.instance)}}.instance

data/lib/myco/code_tools/parser/MycoCharacterClasses.my

@@ -0,0 +1,20 @@
+
+MycoCharacterClasses: Pegleromyces::Grammar {
+  eol_comment: str('#') + (!eol + any).*
+  
+  # TODO: reinstate the following:
+  nl:     str("\n")
+  spc:    set(" \t\r\f\v") / str("\\\n") / eol_comment
+  spc_nl: spc / nl
+  
+  eof:    !any
+  eol:    nl / eof
+  
+  # TODO: Unicode upper and lower
+  upper:  range('A','Z')
+  lower:  range('a','z') / str('_')
+  num:    range('0','9')
+  alpha:  lower / upper
+  alnum:  alpha / num
+  suffix: str('!') / str('?')
+}

data/lib/myco/code_tools/parser/MycoCharacterClasses.my.rb

@@ -0,0 +1,56 @@
+
+::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(:MycoCharacterClasses, (::Myco::Component.new([::Myco.find_constant(:Pegleromyces)::Grammar], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+  declare_meme(:eol_comment, [], nil, ::Myco.cscope.dup) { |*| (self.str("#").__send__(
+    :+,
+    self.eol.__send__(:!).__send__(
+      :+,
+      self.any
+    ).__send__(:*)
+  ))}
+  declare_meme(:nl, [], nil, ::Myco.cscope.dup) { |*| (self.str("\n"))}
+  declare_meme(:spc, [], nil, ::Myco.cscope.dup) { |*| (self.set(" \t\r\f\v").__send__(
+    :/,
+    self.str("\\\n")
+  ).__send__(
+    :/,
+    self.eol_comment
+  ))}
+  declare_meme(:spc_nl, [], nil, ::Myco.cscope.dup) { |*| (self.spc.__send__(
+    :/,
+    self.nl
+  ))}
+  declare_meme(:eof, [], nil, ::Myco.cscope.dup) { |*| (self.any.__send__(:!))}
+  declare_meme(:eol, [], nil, ::Myco.cscope.dup) { |*| (self.nl.__send__(
+    :/,
+    self.eof
+  ))}
+  declare_meme(:upper, [], nil, ::Myco.cscope.dup) { |*| (self.range(
+    "A",
+    "Z"
+  ))}
+  declare_meme(:lower, [], nil, ::Myco.cscope.dup) { |*| (self.range(
+    "a",
+    "z"
+  ).__send__(
+    :/,
+    self.str("_")
+  ))}
+  declare_meme(:num, [], nil, ::Myco.cscope.dup) { |*| (self.range(
+    "0",
+    "9"
+  ))}
+  declare_meme(:alpha, [], nil, ::Myco.cscope.dup) { |*| (self.lower.__send__(
+    :/,
+    self.upper
+  ))}
+  declare_meme(:alnum, [], nil, ::Myco.cscope.dup) { |*| (self.alpha.__send__(
+    :/,
+    self.num
+  ))}
+  declare_meme(:suffix, [], nil, ::Myco.cscope.dup) { |*| (self.str("!").__send__(
+    :/,
+    self.str("?")
+  ))}
+)}}.instance)))}}.instance