myco 0.1.1 → 0.1.2

data/lib/myco/parser/ast/ToRuby.my.rb

@@ -0,0 +1,574 @@
+::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(:ToRuby, ::Myco::Component.new([
+      ::Myco::Object
+    ], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+    .tap { |__c__| __c__.__last__ = __c__.component_eval {(
+      declare_meme(:lines, [
+        [:var, []]
+      ], nil, ::Myco.cscope.dup) { |*| (
+        [
+          ""
+        ]
+      )}
+      declare_meme(:to_s, [], nil, ::Myco.cscope.dup) { |*| (
+        self.lines.join("\n")
+      )}
+      declare_meme(:add, [], nil, ::Myco.cscope.dup) { |*strings| (
+        strings.each { |string| (
+          ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", string.__send__(
+            :is_a?,
+            ::Myco.find_constant(:String)
+          )) {self.lines.last.concat(string.dup)}) {string.to_ruby(self)}
+        )}
+      )}
+      declare_meme(:line, [], nil, ::Myco.cscope.dup) { |*strings| (
+        self.lines.push(self.indents.last.dup)
+        self.add(*strings)
+      )}
+      declare_meme(:list, [], nil, ::Myco.cscope.dup) { |items, separator="", auto_lines:false, &block| (
+        ::Myco.branch_op(:"&&", items.__send__(:any?)) {(
+          items = items.dup
+          last_item = items.pop
+          use_lines = ::Myco.branch_op(:"&&", items.__send__(:any?)) {auto_lines}
+          ::Myco.branch_op(:"&&", use_lines) {self.push_indent}
+          items.each { |item| (
+            ::Myco.branch_op(:"&&", use_lines) {self.line}
+            ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", block) {block.call(item)}) {self.add(item)}
+            self.add(separator)
+          )}
+          ::Myco.branch_op(:"&&", use_lines) {self.line}
+          ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", block) {block.call(last_item)}) {self.add(last_item)}
+          ::Myco.branch_op(:"&&", use_lines) {self.pop_indent}
+          ::Myco.branch_op(:"&&", use_lines) {self.line}
+        )}
+      )}
+      declare_meme(:indents, [
+        [:var, []]
+      ], nil, ::Myco.cscope.dup) { |*| (
+        [
+          ""
+        ]
+      )}
+      declare_meme(:indent_amount, [
+        [:var, []]
+      ], nil, ::Myco.cscope.dup) { |*| (
+        2
+      )}
+      declare_meme(:pop_indent, [], nil, ::Myco.cscope.dup) { |*| (
+        self.indents.pop
+      )}
+      declare_meme(:push_indent, [], nil, ::Myco.cscope.dup) { |amount=self.indent_amount| (
+        self.indents.push(self.indents.last.__send__(
+          :+,
+          " ".__send__(
+            :*,
+            amount
+          )
+        ))
+      )}
+      declare_meme(:var_scopes, [
+        [:var, []]
+      ], nil, ::Myco.cscope.dup) { |*| (
+        []
+      )}
+      declare_meme(:var_scope, [], nil, ::Myco.cscope.dup) { |*| (
+        self.var_scopes.last
+      )}
+      declare_meme(:with_nested_var_scope, [], nil, ::Myco.cscope.dup) { |node, &block| (
+        self.var_scopes.push(node)
+        block.call
+        self.var_scopes.pop
+      )}
+      declare_meme(:var_scope_declare_local, [], nil, ::Myco.cscope.dup) { |name| (
+        self.var_scope.variables.__send__(
+          :[]=,
+          name,
+          true
+        )
+      )}
+      declare_meme(:var_scope_declare_locals, [], nil, ::Myco.cscope.dup) { |*names| (
+        names.each { |name| (
+          self.var_scope_declare_local(name)
+        )}
+      )}
+      declare_meme(:var_scope_has_local?, [], nil, ::Myco.cscope.dup) { |name| (
+        self.var_scopes.reverse.detect { |scope| (
+          scope.variables.__send__(
+            :has_key?,
+            name
+          )
+        )}.__send__(:!).__send__(:!)
+      )}
+      declare_meme(:easy_ident?, [], nil, ::Myco.cscope.dup) { |sym| (
+        str = sym.to_s
+        ::Myco.branch_op(:"&&", str.__send__(
+          :=~,
+          ::Myco.find_constant(:Regexp).new("^[a-z_][A-Za-z_]*$")
+        )) {[
+          :if,
+          :unless,
+          :and,
+          :or,
+          :def,
+          :do,
+          :class,
+          :module,
+          :end,
+          :break,
+          :begin,
+          :rescue,
+          :ensure
+        ].__send__(
+          :include?,
+          sym
+        ).__send__(:!)}
+      )}
+    )}})
+    .tap { |__c__| __c__.__name__ = :ToRuby }
+    ::Myco.find_constant(:Node).component_eval {(
+      declare_meme(:to_ruby_code, [], nil, ::Myco.cscope.dup) { |*| (
+        g = ::Myco.find_constant(:ToRuby).new
+        self.to_ruby(g)
+        g.to_s
+      )}
+    )}
+    ::Myco.find_constant(:Self).component_eval {(
+      declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
+        g.add("self")
+      )}
+    )}
+    ::Myco.find_constant(:NullLiteral).component_eval {(
+      declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
+        g.add("nil")
+      )}
+    )}
+    ::Myco.find_constant(:VoidLiteral).component_eval {(
+      declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
+        g.add("::Myco::Void")
+      )}
+    )}
+    ::Myco.find_constant(:TrueLiteral).component_eval {(
+      declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
+        g.add("true")
+      )}
+    )}
+    ::Myco.find_constant(:FalseLiteral).component_eval {(
+      declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
+        g.add("false")
+      )}
+    )}
+    ::Myco.find_constant(:StringLiteral).component_eval {(
+      declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
+        g.add(self.string.inspect)
+      )}
+    )}
+    ::Myco.find_constant(:SymbolLiteral).component_eval {(
+      declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
+        g.add(self.value.inspect)
+      )}
+    )}
+    ::Myco.find_constant(:DynamicString).component_eval {(
+      declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
+        inspect_escape = ::Myco.find_constant(: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))
+        )}
+        g.add("\"")
+      )}
+    )}
+    ::Myco.find_constant(:DynamicSymbol).component_eval {(
+      declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
+        g.add(":")
+        ::Myco.find_constant(:DynamicString).instance_method(:to_ruby).bind(self).call(g)
+      )}
+    )}
+    ::Myco.find_constant(:HashLiteral).component_eval {(
+      declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
+        g.add("{")
+        g.list(
+          self.array.each_slice(2).to_a,
+          ",",
+          {
+            :auto_lines => true
+          }
+        ) { |pair| (
+          g.add(
+            pair.first,
+            " => ",
+            pair.last
+          )
+        )}
+        g.add("}")
+      )}
+    )}
+    ::Myco.find_constant(:ArrayAssembly).component_eval {(
+      declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
+        g.add("[")
+        g.list(
+          self.body,
+          ",",
+          {
+            :auto_lines => true
+          }
+        )
+        g.add("]")
+      )}
+    )}
+    ::Myco.find_constant(:ScopedConstant).component_eval {(
+      declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
+        g.add(self.parent)
+        g.add("::#{self.name}")
+      )}
+      declare_meme(:to_ruby_assign, [], nil, ::Myco.cscope.dup) { |g, value| (
+        self.to_ruby(g)
+        g.add(" = ")
+        g.add(value)
+      )}
+    )}
+    ::Myco.find_constant(:ToplevelConstant).component_eval {(
+      declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
+        g.add("::#{self.name}")
+      )}
+      declare_meme(:to_ruby_assign, [], nil, ::Myco.cscope.dup) { |g, value| (
+        self.to_ruby(g)
+        g.add(" = ")
+        g.add(value)
+      )}
+    )}
+    ::Myco.find_constant(:ConstantAccess).component_eval {(
+      declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
+        g.add("::Myco.find_constant(#{self.name.inspect})")
+      )}
+      declare_meme(:to_ruby_assign, [], nil, ::Myco.cscope.dup) { |g, value| (
+        g.add("::Myco.cscope.for_method_definition.const_set(#{self.name.inspect}, ")
+        g.add(value)
+        g.add(")")
+      )}
+    )}
+    ::Myco.find_constant(:ConstantAssignment).component_eval {(
+      declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
+        self.constant.to_ruby_assign(
+          g,
+          self.value
+        )
+      )}
+    )}
+    ::Myco.find_constant(:ConstantDefine).component_eval {(
+      declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
+        g.add(self.implementation)
+        g.line(".tap { |__c__| __c__.__name__ = ")
+        g.add(self.name.name.inspect)
+        g.add(" }")
+      )}
+    )}
+    ::Myco.find_constant(:ConstantReopen).component_eval {(
+      declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
+        g.add(self.name)
+        g.add(".component_eval {")
+        g.add(self.body)
+        g.add("}")
+      )}
+    )}
+    ::Myco.find_constant(:MycoModuleScope).component_eval {(
+      declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
+        g.with_nested_var_scope(self) { || (
+          g.add(self.body)
+        )}
+      )}
+    )}
+    ::Myco.find_constant(:EvalExpression).component_eval {(
+      declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
+        g.add(self.body)
+      )}
+    )}
+    ::Myco.find_constant(:DeclareFile).component_eval {(
+      declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
+        self.implementation.to_ruby(g)
+      )}
+    )}
+    ::Myco.find_constant(:DeclareObject).component_eval {(
+      declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
+        g.add("::Myco::Component.new(")
+        g.add(self.types)
+        g.add(", ::Myco.cscope.for_method_definition, __FILE__, __LINE__)")
+        g.line(".tap { |__c__| __c__.__last__ = __c__.component_eval {")
+        g.add(self.scope_implementation)
+        g.add("}}")
+        ::Myco.branch_op(:"&&", self.create) {g.add(".instance")}
+      )}
+    )}
+    ::Myco.find_constant(:DeclareString).component_eval {(
+      declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
+        g.add(self.implementation)
+      )}
+    )}
+    ::Myco.find_constant(:DeclareCategory).component_eval {(
+      declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
+        g.add("__category__(#{self.name.value.inspect})")
+        g.add(".component_eval {")
+        g.add(self.body)
+        g.add("}")
+      )}
+    )}
+    ::Myco.find_constant(:DeclareMeme).component_eval {(
+      declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
+        g.with_nested_var_scope(self.body_implementation) { || (
+          g.var_scope_declare_locals(*self.arguments.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.body)
+          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("]")
+      )}
+    )}
+    ::Myco.find_constant(:Parameters).component_eval {(
+      declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
+        list = []
+        list_add = ::Myco.find_constant(:Proc).new { |&blk| (
+          list.push(::Myco.find_constant(:Proc).new(&blk))
+        )}
+        self.required.each { |item| (
+          list_add.call { || (
+            g.add(item.to_s)
+          )}
+        )}
+        ::Myco.branch_op(:"&?", self.defaults) {self.defaults.arguments.each { |asgn| (
+          name = asgn.name
+          value = asgn.value
+          list_add.call { || (
+            g.add("#{name}=")
+            ::Myco.branch_op(:"||", ::Myco.branch_op(:"&&", value.__send__(
+              :is_a?,
+              ::Myco.find_constant(:SymbolLiteral)
+            )) {value.value.__send__(
+              :==,
+              :*
+            )}) {g.add(value)}
+          )}
+        )}}
+        ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.splat.__send__(
+          :==,
+          :*
+        )) {list_add.call { || (
+          g.add("*")
+        )}}) {::Myco.branch_op(:"&?", self.splat) {list_add.call { || (
+          g.add("*#{self.splat}")
+        )}}}
+        ::Myco.branch_op(:"&?", self.keywords) {(
+          self.keywords.arguments.each { |asgn| (
+            name = asgn.name
+            value = asgn.value
+            list_add.call { || (
+              g.add("#{name}:")
+              ::Myco.branch_op(:"||", ::Myco.branch_op(:"&&", value.__send__(
+                :is_a?,
+                ::Myco.find_constant(:SymbolLiteral)
+              )) {value.value.__send__(
+                :==,
+                :*
+              )}) {g.add(value)}
+            )}
+          )}
+          ::Myco.branch_op(:"&?", ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.keywords.kwrest.__send__(
+            :==,
+            true
+          )) {list_add.call { || (
+            g.add("**")
+          )}}) {self.keywords.kwrest}) {list_add.call { || (
+            g.add("**#{self.keywords.kwrest.name}")
+          )}}
+        )}
+        ::Myco.branch_op(:"&?", self.block_arg) {list_add.call { || (
+          g.add("&#{self.block_arg.name}")
+        )}}
+        g.add("|")
+        g.list(
+          list,
+          ", "
+        ) { |proc| (
+          proc.call
+        )}
+        g.add("|")
+      )}
+    )}
+    ::Myco.find_constant(:Block).component_eval {(
+      declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
+        g.add("(")
+        g.list(
+          self.array,
+          "",
+          {
+            :auto_lines => true
+          }
+        )
+        g.add(")")
+      )}
+    )}
+    ::Myco.find_constant(:Invoke).component_eval {(
+      declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
+        g.add(self.implementation)
+      )}
+    )}
+    ::Myco.find_constant(:InvokeMethod).component_eval {(
+      declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
+        list = ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.arguments) {self.arguments.body.dup}) {[]}
+        ::Myco.branch_op(:"&&", self.arguments.block.__send__(
+          :is_a?,
+          ::Myco.find_constant(:BlockPass)
+        )) {list.push(self.arguments.block)}
+        g.add(self.receiver)
+        ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", g.__send__(
+          :easy_ident?,
+          self.name
+        )) {g.add(".#{self.name}")}) {(
+          g.add(".__send__")
+          list.unshift(::Myco.find_constant(:SymbolLiteral).new(
+            self.line,
+            self.name
+          ))
+        )}
+        ::Myco.branch_op(:"&&", list.__send__(:any?)) {(
+          g.add("(")
+          g.list(
+            list,
+            ",",
+            {
+              :auto_lines => true
+            }
+          )
+          g.add(")")
+        )}
+        ::Myco.branch_op(:"&&", self.arguments.block.__send__(
+          :is_a?,
+          ::Myco.find_constant(:Iter)
+        )) {(
+          g.add(" {")
+          g.add(self.arguments.block)
+          g.add("}")
+        )}
+      )}
+    )}
+    ::Myco.find_constant(:LocalVariableAssignment).component_eval {(
+      declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
+        g.var_scope_declare_local(self.name)
+        g.var_scope.variables.__send__(
+          :[]=,
+          self.name,
+          true
+        )
+        g.add(self.name.to_s)
+        g.add(" = ")
+        g.add(self.value)
+      )}
+    )}
+    ::Myco.find_constant(:LocalVariableAccessAmbiguous).component_eval {(
+      declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
+        ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", g.__send__(
+          :var_scope_has_local?,
+          self.name
+        )) {g.add(self.name.to_s)}) {(
+          g.add("self")
+          ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", g.__send__(
+            :easy_ident?,
+            self.name
+          )) {g.add(".#{self.name}")}) {g.add(".__send__(#{self.name.inspect})")}
+        )}
+      )}
+    )}
+    ::Myco.find_constant(:SplatValue).component_eval {(
+      declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
+        ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.value.__send__(
+          :is_a?,
+          self.__send__(:class)
+        )) {self.value.to_ruby(g)}) {(
+          g.add("*")
+          self.value.to_ruby(g)
+        )}
+      )}
+    )}
+    ::Myco.find_constant(:CollectSplat).component_eval {(
+      declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| nil}
+    )}
+    ::Myco.find_constant(:ConcatArgs).component_eval {(
+      declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| nil}
+    )}
+    ::Myco.find_constant(:PushArgs).component_eval {(
+      declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| nil}
+    )}
+    ::Myco.find_constant(:BlockPass).component_eval {(
+      declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
+        g.add("&")
+        g.add(self.body)
+      )}
+    )}
+    ::Myco.find_constant(:Iter).component_eval {(
+      declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
+        g.with_nested_var_scope(self) { || (
+          g.var_scope_declare_locals(*self.arguments.names)
+          g.add(" ")
+          g.add(self.arguments)
+          g.add(" ")
+          g.add(self.body)
+        )}
+      )}
+    )}
+    ::Myco.find_constant(:Quest).component_eval {(
+      declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
+        associated_questable = self.questable.dup
+        associated_questable.__send__(
+          :receiver=,
+          self.receiver
+        )
+        g.add("(")
+        g.add(self.receiver)
+        g.add(".respond_to?(#{self.questable.name.inspect}).false?")
+        g.add(" ? ::Myco::Void : ")
+        g.add(associated_questable)
+        g.add(")")
+      )}
+    )}
+    ::Myco.find_constant(:BranchOperator).component_eval {(
+      declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
+        g.add("::Myco.branch_op(")
+        g.add(self.type.inspect)
+        g.add(", ")
+        g.add(self.left)
+        g.add(") {")
+        g.add(self.right)
+        g.add("}")
+      )}
+    )}
+    ::Myco.find_constant(:Return).component_eval {(
+      declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
+        g.add("return ")
+        g.add(self.value)
+      )}
+    )}
+  )}
+)}}.instance

data/lib/myco/parser/ast.rb

@@ -18,4 +18,4 @@ require_relative "ast/branch_operator"
 
 require_relative "ast/misc"
 
-require_relative "ast/to_ruby"
+Myco.eval_file 'ast/ToRuby.my'

data/lib/myco/version.rb

@@ -1,6 +1,6 @@
 
 module Myco
-  MYCO_VERSION = '0.1.1'
+  MYCO_VERSION = '0.1.2'
   
   MYCO_REQUIRED_GEMS = [
     ['rubinius-toolset',   '~> 2.3'],

data/lib/myco.rb

@@ -2,8 +2,6 @@
 require_relative 'myco/version'
 Myco.activate_required_gems
 
-require_relative 'myco/toolset'
-require_relative 'myco/parser'
 require_relative 'myco/code_loader'
 require_relative 'myco/eval'
 require_relative 'myco/misc'
@@ -15,3 +13,27 @@ Myco.rescue do
   Myco::CoreLoadPath = File.expand_path('myco', File.dirname(__FILE__))
   Myco.eval_file 'myco/bootstrap.my'
 end
+
+# Load the boot toolset from (possibly old) cached bytecode files
+module Myco
+  ToolSet = Rubinius::ToolSets.create :myco_boot do
+    require "rubinius/melbourne"
+    require "rubinius/processor"
+    require "rubinius/compiler"
+    require "rubinius/ast"
+    
+    require_relative 'myco/parser'
+  end
+end
+
+# Load the runtime toolset from the latest code
+module Myco
+  ToolSet = Rubinius::ToolSets.create :myco do
+    require "rubinius/melbourne"
+    require "rubinius/processor"
+    require "rubinius/compiler"
+    require "rubinius/ast"
+    
+    require_relative 'myco/parser'
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: myco
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Joe McIlvain
@@ -223,6 +223,8 @@ files:
 - lib/myco/misc.rb
 - lib/myco/parser.rb
 - lib/myco/parser/ast.rb
+- lib/myco/parser/ast/ToRuby.my
+- lib/myco/parser/ast/ToRuby.my.rb
 - lib/myco/parser/ast/argument_assembly.rb
 - lib/myco/parser/ast/array_assembly.rb
 - lib/myco/parser/ast/branch_operator.rb
@@ -241,50 +243,11 @@ files:
 - lib/myco/parser/ast/misc.rb
 - lib/myco/parser/ast/myco_module_scope.rb
 - lib/myco/parser/ast/quest.rb
-- lib/myco/parser/ast/to_ruby.rb
-- lib/myco/parser/ast/to_ruby/array_assembly.rb
-- lib/myco/parser/ast/to_ruby/block.rb
-- lib/myco/parser/ast/to_ruby/block_pass.rb
-- lib/myco/parser/ast/to_ruby/branch_operator.rb
-- lib/myco/parser/ast/to_ruby/constant_access.rb
-- lib/myco/parser/ast/to_ruby/constant_assignment.rb
-- lib/myco/parser/ast/to_ruby/constant_define.rb
-- lib/myco/parser/ast/to_ruby/constant_reopen.rb
-- lib/myco/parser/ast/to_ruby/declare_category.rb
-- lib/myco/parser/ast/to_ruby/declare_decorator.rb
-- lib/myco/parser/ast/to_ruby/declare_file.rb
-- lib/myco/parser/ast/to_ruby/declare_meme.rb
-- lib/myco/parser/ast/to_ruby/declare_object.rb
-- lib/myco/parser/ast/to_ruby/declare_string.rb
-- lib/myco/parser/ast/to_ruby/dynamic_string.rb
-- lib/myco/parser/ast/to_ruby/dynamic_symbol.rb
-- lib/myco/parser/ast/to_ruby/eval_expression.rb
-- lib/myco/parser/ast/to_ruby/false_literal.rb
-- lib/myco/parser/ast/to_ruby/hash_literal.rb
-- lib/myco/parser/ast/to_ruby/invoke.rb
-- lib/myco/parser/ast/to_ruby/invoke_method.rb
-- lib/myco/parser/ast/to_ruby/iter.rb
-- lib/myco/parser/ast/to_ruby/local_variable_access_ambiguous.rb
-- lib/myco/parser/ast/to_ruby/local_variable_assignment.rb
-- lib/myco/parser/ast/to_ruby/myco_module_scope.rb
-- lib/myco/parser/ast/to_ruby/null_literal.rb
-- lib/myco/parser/ast/to_ruby/parameters.rb
-- lib/myco/parser/ast/to_ruby/quest.rb
-- lib/myco/parser/ast/to_ruby/return.rb
-- lib/myco/parser/ast/to_ruby/scoped_constant.rb
-- lib/myco/parser/ast/to_ruby/self.rb
-- lib/myco/parser/ast/to_ruby/splat_value.rb
-- lib/myco/parser/ast/to_ruby/string_literal.rb
-- lib/myco/parser/ast/to_ruby/symbol_literal.rb
-- lib/myco/parser/ast/to_ruby/toplevel_constant.rb
-- lib/myco/parser/ast/to_ruby/true_literal.rb
-- lib/myco/parser/ast/to_ruby/void_literal.rb
 - lib/myco/parser/peg_parser.rb
 - lib/myco/tools/BasicCommand.my
 - lib/myco/tools/BasicCommand.my.rb
 - lib/myco/tools/mycompile.my
 - lib/myco/tools/mycompile.my.rb
-- lib/myco/toolset.rb
 - lib/myco/version.rb
 homepage: https://github.com/jemc/myco/
 licenses: