myco 0.1.3 → 0.1.4

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

@@ -0,0 +1,33 @@
+
+::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(:Script, ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+  declare_meme(:file, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:body, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:variable_scope, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  ::Myco.cscope.for_method_definition.const_set(:Form, ([
+    :script,
+    :file,
+    :body
+  ]))
+  declare_meme(:nest_scope, [], nil, ::Myco.cscope.dup) { |scope| (scope.__send__(
+    :parent=,
+    self
+  ))}
+  declare_meme(:search_local, [], nil, ::Myco.cscope.dup) { |*| (nil)}
+  declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
+    g.__send__(
+      :name=,
+      :__script__
+    )
+    g.__send__(
+      :file=,
+      self.file.to_sym
+    )
+    g.push_state(self)
+    self.body.bytecode(g)
+    g.ret
+    g.pop_state
+  )}
+)}})
+.tap { |__c__| __c__.__name__ = :Script })})}}.instance

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

@@ -0,0 +1,23 @@
+
+CodeTools::AST << {
+  
+  SplatValue < Node {
+    var value
+    
+    Form: [:splat, :value]
+    
+    bytecode: |g| {
+      self.value.bytecode(g)
+      
+      # TODO: determine if coercion from other types is necessary here
+      g.dup
+      g.push_rubinius
+      g.find_const(:"Runtime")
+      g.swap
+      g.send(:dup_as_array, 1, true)
+      
+      g.swap
+      g.pop
+    }
+  }
+}

data/lib/myco/code_tools/AST/SplatValue.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 {(::Myco.find_constant(:CodeTools)::AST.component_eval {(::Myco.cscope.for_method_definition.const_set(:SplatValue, ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+  declare_meme(:value, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  ::Myco.cscope.for_method_definition.const_set(:Form, ([
+    :splat,
+    :value
+  ]))
+  declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
+    self.value.bytecode(g)
+    g.dup
+    g.push_rubinius
+    g.find_const(:Runtime)
+    g.swap
+    g.send(
+      :dup_as_array,
+      1,
+      true
+    )
+    g.swap
+    g.pop
+  )}
+)}})
+.tap { |__c__| __c__.__name__ = :SplatValue })})}}.instance

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

@@ -0,0 +1,17 @@
+
+CodeTools::AST << {
+  
+  StringLiteral < Node {
+    var value
+    
+    Form: [:str, :value]
+    
+    bytecode: |g| {
+      pos(g)
+      
+      g.push_literal(self.value)
+      g.string_dup
+    }
+  }
+  
+}

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

@@ -0,0 +1,16 @@
+
+::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(:StringLiteral, ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+  declare_meme(:value, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  ::Myco.cscope.for_method_definition.const_set(:Form, ([
+    :str,
+    :value
+  ]))
+  declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
+    self.pos(g)
+    g.push_literal(self.value)
+    g.string_dup
+  )}
+)}})
+.tap { |__c__| __c__.__name__ = :StringLiteral })})}}.instance

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

@@ -0,0 +1,16 @@
+
+CodeTools::AST << {
+  
+  SymbolLiteral < Node {
+    var value
+    
+    Form: [:lit, :value]
+    
+    bytecode: |g| {
+      pos(g)
+      
+      g.push_literal(self.value)
+    }
+  }
+  
+}

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

@@ -0,0 +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(:SymbolLiteral, ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+  declare_meme(:value, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  ::Myco.cscope.for_method_definition.const_set(:Form, ([
+    :lit,
+    :value
+  ]))
+  declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
+    self.pos(g)
+    g.push_literal(self.value)
+  )}
+)}})
+.tap { |__c__| __c__.__name__ = :SymbolLiteral })})}}.instance

data/lib/myco/{parser/ast → code_tools/AST}/ToRuby.my

@@ -104,18 +104,15 @@ CodeTools::AST << {
   TrueLiteral  << { to_ruby: |g| g.add("true") }
   FalseLiteral << { to_ruby: |g| g.add("false") }
   
-  StringLiteral << { to_ruby: |g| g.add(self.string.inspect) }
+  StringLiteral << { to_ruby: |g| g.add(self.value.inspect) }
   SymbolLiteral << { to_ruby: |g| g.add(self.value.inspect) }
   
   DynamicString << {
     to_ruby: |g| {
-      inspect_escape = Proc.new |str| { str.inspect.slice(::Range.new(1, -2)) }
-      
       g.add('"')
-        g.add(inspect_escape.call(self.string))
-        self.array.each_slice(2) |interpolated, inner_string| {
-          g.add('#{'); g.add(interpolated.value); g.add('}')
-          g.add(inspect_escape.call(inner_string.value))
+        self.body.each_slice(2) |string, to_string| {
+          g.add(string.value.to_s.inspect.slice(::Range.new(1, -2)))
+          to_string && (g.add('#{'); g.add(to_string); g.add('}'))
         }
       g.add('"')
     }
@@ -123,69 +120,78 @@ CodeTools::AST << {
   
   DynamicSymbol << {
     to_ruby: |g| {
-      g.add(":")
-      # TODO: use super here
-      DynamicString.instance_method(:to_ruby).bind(self).call(g)
+      g.add(':"')
+        self.body.each_slice(2) |string, to_string| {
+          g.add(string.value.to_s.inspect.slice(::Range.new(1, -2)))
+          to_string && (g.add('#{'); g.add(to_string); g.add('}'))
+        }
+      g.add('"')
     }
   }
   
-  HashLiteral << {
+  ArrayAssembly << {
+    to_ruby: |g|
+      g.add("["); g.list(self.body, ",", auto_lines:true); g.add("]")
+  }
+  
+  KeywordAssembly << {
     to_ruby: |g| {
       g.add("{")
-      g.list(self.array.each_slice(2).to_a, ",", auto_lines:true) |pair| {
+      g.list(self.body.each_slice(2).to_a, ",", auto_lines:true) |pair| {
         g.add(pair.first, " => ", pair.last)
       }
       g.add("}")
     }
   }
   
-  ArrayAssembly << {
-    to_ruby: |g|
-      g.add("["); g.list(self.body, ",", auto_lines:true); g.add("]")
-  }
-  
-  ScopedConstant << {
-    to_ruby: |g|
-      g.add(self.parent); g.add("::"self.name"")
-    
-    to_ruby_assign: |g, value|
-      to_ruby(g); g.add(" = "); g.add(value)
-  }
-  
-  ToplevelConstant << {
-    to_ruby: |g|
-      g.add("::"self.name"")
-    
-    to_ruby_assign: |g, value|
-      to_ruby(g); g.add(" = "); g.add(value)
-  }
-  
   ConstantAccess << {
-    to_ruby: |g|
-      g.add("::Myco.find_constant("self.name.inspect")")
-    
-    to_ruby_assign: |g, value| {
-      g.add("::Myco.cscope.for_method_definition.const_set("self.name.inspect", ")
-      g.add(value); g.add(")")
+    to_ruby: |g| {
+      name_list = self.names.map(&:to_sym)
+      first_name = name_list.shift
+      
+      self.toplevel &? (
+        g.add("::"first_name"")
+      ) ?? (
+        g.add("::Myco.find_constant("first_name.inspect")")
+      )
+      name_list.each |name| { g.add("::"name"") }
     }
   }
   
   ConstantAssignment << {
-    to_ruby: |g| self.constant.to_ruby_assign(g, self.value)
+    to_ruby: |g| {
+      name_list = self.constant.names.map(&:to_sym)
+      last_name = name_list.pop
+      first_name = name_list.any? && name_list.shift
+      
+      self.constant.toplevel &? (
+        first_name && g.add("::"first_name"")
+      ) ?? (
+        first_name &? (
+          g.add("::Myco.find_constant("first_name.inspect")")
+        ) ?? (
+          g.add("::Myco.cscope.for_method_definition")
+        )
+      )
+      name_list.each |name| { g.add("::"name"") }
+      g.add("::"last_name" = ")
+      
+      g.add(self.value)
+    }
   }
   
   ConstantDefine << {
     to_ruby: |g| {
       g.add(implementation)
       g.line(".tap { |__c__| __c__.__name__ = ")
-        g.add(self.name.name.inspect)
+        g.add(self.constant.names.last.inspect)
       g.add(" }")
     }
   }
   
   ConstantReopen << {
     to_ruby: |g| {
-      g.add(self.name); g.add(".component_eval {")
+      g.add(self.constant); g.add(".component_eval {")
       g.add(self.body); g.add("}")
     }
   }
@@ -195,7 +201,7 @@ CodeTools::AST << {
       g.with_nested_var_scope(self) { g.add(self.body) }
   }
   
-  EvalExpression << { to_ruby: |g| g.add(self.body) }
+  Script      << { to_ruby: |g| g.add(self.body) }
   DeclareFile << { to_ruby: |g| g.line; implementation.to_ruby(g); g.line }
   
   DeclareObject << {
@@ -210,7 +216,7 @@ CodeTools::AST << {
   
   DeclareCategory << {
     to_ruby: |g| {
-      g.add("__category__("self.name.value.inspect")")
+      g.add("__category__("self.name.inspect")")
       g.add(".component_eval {"); g.add(self.body); g.add("}")
     }
   }
@@ -218,13 +224,13 @@ CodeTools::AST << {
   DeclareMeme << {
     to_ruby: |g| {
       g.with_nested_var_scope(body_implementation) {
-        g.var_scope_declare_locals(*self.arguments.names)
+        g.var_scope_declare_locals(*self.parameters.names)
         
         g.add("declare_meme(")
         g.add(""self.name.inspect", ")
         g.add(self.decorations); g.add(", nil, ::Myco.cscope.dup)")
         g.add(" { ");
-          g.add(self.arguments); g.add(" ")
+          g.add(self.parameters); g.add(" ")
           g.add(self.body);
         g.add("}")
       }
@@ -236,56 +242,56 @@ CodeTools::AST << {
       g.add("["self.name.value.inspect", "); g.add(self.arguments); g.add("]")
   }
   
-  Parameters << {
+  BlockParameter << {
+    to_ruby: |g| g.add("&"self.name"")
+  }
+  
+  ParameterAssembly << {
     to_ruby: |g| {
       list = []
       list_add = Proc.new |&blk| { list.push(Proc.new(&blk)) }
       
       self.required.each |item| { list_add.call { g.add(item.to_s) } }
       
-      self.defaults &? (
-        self.defaults.arguments.each |asgn| {
-          name = asgn.name
-          value = asgn.value
-          list_add.call {
-            g.add(""name"=")
-            (value.is_a?(SymbolLiteral) && value.value==:"*") || g.add(value)
-          }
+      self.optional.each |asgn| {
+        name = asgn.name
+        value = asgn.value
+        list_add.call {
+          g.add(""name"=")
+          (value.is_a?(SymbolLiteral) && value.value==:"*") || g.add(value)
         }
-      )
+      }
       
-      (self.splat == :"*") &? (
+      (self.splat == true) &? (
         list_add.call { g.add("*") }
       ) ?? (self.splat &? ( # TODO: make prettier elsif alternative
         list_add.call { g.add("*"self.splat"") }
       ))
       
-      self.keywords &? (
-        self.keywords.arguments.each |asgn| {
-          name = asgn.name
-          value = asgn.value
-          list_add.call {
-            g.add(""name":")
-            (value.is_a?(SymbolLiteral) && value.value==:"*") || g.add(value)
-          }
+      self.post.each |item| { list_add.call { g.add(item.to_s) } }
+      
+      self.kwargs.each |asgn| {
+        name = asgn.name
+        value = asgn.value
+        list_add.call {
+          g.add(""name":")
+          (value.is_a?(SymbolLiteral) && value.value==:"*") || g.add(value)
         }
-        
-        (self.keywords.kwrest == true) &? (
-          list_add.call { g.add("**") }
-        ) ?? self.keywords.kwrest &? (
-          list_add.call { g.add("**"self.keywords.kwrest.name"") }
-        )
-      )
+      }
       
-      self.block_arg &? (
-        list_add.call { g.add("&"self.block_arg.name"") }
-      )
+      (self.kwrest == true) &? (
+        list_add.call { g.add("**") }
+      ) ?? (self.kwrest &? ( # TODO: make prettier elsif alternative
+        list_add.call { g.add("**"self.kwrest"") }
+      ))
+      
+      self.block && list_add.call { g.add(self.block) }
       
       g.add("|"); g.list(list, ", ") |proc| { proc.call }; g.add("|")
     }
   }
   
-  Block << {
+  Body << {
     to_ruby: |g|
       g.add("("); g.list(self.array, "", auto_lines:true); g.add(")")
   }
@@ -295,7 +301,7 @@ CodeTools::AST << {
   InvokeMethod << {
     to_ruby: |g| {
       list = self.arguments &? self.arguments.body.dup ?? []
-      self.arguments.block.is_a?(BlockPass) &&
+      self.arguments.block.is_a?(BlockArgument) && # TODO: receive block as part of arguments list
         list.push(self.arguments.block)
       
       g.add(self.receiver)
@@ -304,7 +310,7 @@ CodeTools::AST << {
         g.add("."self.name"")
       ) ?? (
         g.add(".__send__")
-        list.unshift(SymbolLiteral.new(self.line, self.name))
+        list.unshift(SymbolLiteral.new(line:self.line, value:self.name))
       )
       
       list.any? && (
@@ -313,7 +319,7 @@ CodeTools::AST << {
         g.add(")")
       )
       
-      self.arguments.block.is_a?(Iter) && (
+      self.arguments.block.is_a?(BlockLiteral) && (
         g.add(" {"); g.add(self.arguments.block); g.add("}")
       )
     }
@@ -353,20 +359,17 @@ CodeTools::AST << {
       )
     }
   }
-  CollectSplat << { to_ruby: |g| { } } # TODO
-  ConcatArgs   << { to_ruby: |g| { } } # TODO
-  PushArgs     << { to_ruby: |g| { } } # TODO
   
-  BlockPass << {
+  BlockArgument << {
     to_ruby: |g| g.add("&"); g.add(self.body)
   }
   
-  Iter << {
+  BlockLiteral << {
     to_ruby: |g| {
       g.with_nested_var_scope(self) {
-        g.var_scope_declare_locals(*self.arguments.names)
+        g.var_scope_declare_locals(*self.parameters.names)
         
-        g.add(" "); g.add(self.arguments); g.add(" "); g.add(self.body)
+        g.add(" "); g.add(self.parameters); g.add(" "); g.add(self.body)
       }
     }
   }
@@ -393,8 +396,4 @@ CodeTools::AST << {
         g.add(self.right); g.add('}')
     }
   }
-  
-  Return << {
-    to_ruby: |g| g.add("return "); g.add(self.value)
-  }
 }