myco 0.1.9 → 0.1.10

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

@@ -2,14 +2,30 @@
 ::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::BlockParameter = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-  declare_meme(:blkprm, [[:node_type, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:name, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:map_local, [], nil, ::Myco.cscope.dup) { |scope| (scope.new_local(self.name))}
-  declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
-    self.pos(g)
-    g.push_proc
-    g.state.scope.search_local(self.name).set_bytecode(g)
-    g.pop
-  )}
+  declare_meme(
+    :blkprm,
+    [:node_type],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :name,
+    [:field],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :map_local,
+    [],
+    ::Object::Proc.new { |scope| (scope.new_local(self.name))}
+  )
+  declare_meme(
+    :bytecode,
+    [],
+    ::Object::Proc.new { |g| (
+      self.pos(g)
+      g.push_proc
+      g.state.scope.search_local(self.name).set_bytecode(g)
+      g.pop
+    )}
+  )
 )}}
 .tap { |__c__| __c__.__name__ = :BlockParameter })})}}.instance

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

@@ -2,81 +2,101 @@
 ::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::BranchOperator = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-  declare_meme(:branch_op, [[:node_type, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:type, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:left, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:right, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
-    self.pos(g)
-    done_label = g.new_label
-    right_label = g.new_label
-    otherwise_push_void = false
-    self.left.bytecode(g)
-    ::Myco.branch_op(:"&&", self.type.__send__(
-      :==,
-      :"&&"
-    )) {(
-      g.dup_top
-      g.send(
-        :false?,
-        0
-      )
-      g.goto_if_true(done_label)
-      g.pop
+  declare_meme(
+    :branch_op,
+    [:node_type],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :type,
+    [:field],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :left,
+    [:field],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :right,
+    [:field],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :bytecode,
+    [],
+    ::Object::Proc.new { |g| (
+      self.pos(g)
+      done_label = g.new_label
+      right_label = g.new_label
+      otherwise_push_void = false
+      self.left.bytecode(g)
+      ::Myco.branch_op(:"&&", self.type.__send__(
+        :==,
+        :"&&"
+      )) {(
+        g.dup_top
+        g.send(
+          :false?,
+          0
+        )
+        g.goto_if_true(done_label)
+        g.pop
+      )}
+      ::Myco.branch_op(:"&&", self.type.__send__(
+        :==,
+        :"||"
+      )) {(
+        g.dup_top
+        g.send(
+          :false?,
+          0
+        )
+        g.goto_if_false(done_label)
+        g.pop
+      )}
+      ::Myco.branch_op(:"&&", self.type.__send__(
+        :==,
+        :"??"
+      )) {(
+        g.dup_top
+        g.send(
+          :void?,
+          0
+        )
+        g.goto_if_false(done_label)
+        g.pop
+      )}
+      ::Myco.branch_op(:"&&", self.type.__send__(
+        :==,
+        :"&?"
+      )) {(
+        g.send(
+          :false?,
+          0
+        )
+        g.goto_if_false(right_label)
+        otherwise_push_void = true
+      )}
+      ::Myco.branch_op(:"&&", self.type.__send__(
+        :==,
+        :"|?"
+      )) {(
+        g.send(
+          :false?,
+          0
+        )
+        g.goto_if_true(right_label)
+        otherwise_push_void = true
+      )}
+      ::Myco.branch_op(:"&&", otherwise_push_void) {(
+        g.push_void
+        g.goto(done_label)
+        right_label.__send__(:set!)
+      )}
+      self.right.bytecode(g)
+      done_label.__send__(:set!)
     )}
-    ::Myco.branch_op(:"&&", self.type.__send__(
-      :==,
-      :"||"
-    )) {(
-      g.dup_top
-      g.send(
-        :false?,
-        0
-      )
-      g.goto_if_false(done_label)
-      g.pop
-    )}
-    ::Myco.branch_op(:"&&", self.type.__send__(
-      :==,
-      :"??"
-    )) {(
-      g.dup_top
-      g.send(
-        :void?,
-        0
-      )
-      g.goto_if_false(done_label)
-      g.pop
-    )}
-    ::Myco.branch_op(:"&&", self.type.__send__(
-      :==,
-      :"&?"
-    )) {(
-      g.send(
-        :false?,
-        0
-      )
-      g.goto_if_false(right_label)
-      otherwise_push_void = true
-    )}
-    ::Myco.branch_op(:"&&", self.type.__send__(
-      :==,
-      :"|?"
-    )) {(
-      g.send(
-        :false?,
-        0
-      )
-      g.goto_if_true(right_label)
-      otherwise_push_void = true
-    )}
-    ::Myco.branch_op(:"&&", otherwise_push_void) {(
-      g.push_void
-      g.goto(done_label)
-      right_label.__send__(:set!)
-    )}
-    self.right.bytecode(g)
-    done_label.__send__(:set!)
-  )}
+  )
 )}}
 .tap { |__c__| __c__.__name__ = :BranchOperator })})}}.instance

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

@@ -2,39 +2,59 @@
 ::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::ConstantAccess = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-  declare_meme(:const, [[:node_type, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:toplevel, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:names, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
-    self.pos(g)
-    name_list = self.names.map(&:to_sym)
-    first_name = name_list.shift
-    ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.toplevel) {self.case(
-      first_name,
-      :Myco,
-      ::Object::Proc.new { || (g.push_myco)},
-      :Ruby,
-      ::Object::Proc.new { || (g.push_cpath_top)},
-      :Rubinius,
-      ::Object::Proc.new { || (g.push_rubinius)},
-      ::Object::Proc.new { || (
-        g.push_myco
-        g.find_const(first_name)
+  declare_meme(
+    :const,
+    [:node_type],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :toplevel,
+    [:field],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :names,
+    [:field],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :bytecode,
+    [],
+    ::Object::Proc.new { |g| (
+      self.pos(g)
+      name_list = self.names.map(&:to_sym)
+      first_name = name_list.shift
+      ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.toplevel) {self.case(
+        first_name,
+        :Myco,
+        ::Object::Proc.new { |*| (g.push_myco)},
+        :Ruby,
+        ::Object::Proc.new { |*| (g.push_cpath_top)},
+        :Rubinius,
+        ::Object::Proc.new { |*| (g.push_rubinius)},
+        ::Object::Proc.new { |*| (
+          g.push_myco
+          g.find_const(first_name)
+        )}
+      )}) {::Myco.find_constant(:Myco).find_constant_bytecode(
+        g,
+        first_name
       )}
-    )}) {::Myco.find_constant(:Myco).find_constant_bytecode(
-      g,
-      first_name
+      name_list.each { |name| (g.find_const(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_myco
-    g.push_literal(name)
-    g.push_scope
-    g.send(
-      :find_constant,
-      2
-    )
-  )})}
+  )
+  ::Myco::SingletonClass.component_eval {(declare_meme(
+    :find_constant_bytecode,
+    [],
+    ::Object::Proc.new { |g, name| (
+      g.push_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.rb

@@ -2,43 +2,59 @@
 ::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::ConstantAssignment = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-  declare_meme(:cdecl, [[:node_type, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:constant, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:value, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
-    self.pos(g)
-    name_list = self.constant.names.map(&:to_sym)
-    last_name = name_list.pop
-    first_name = ::Myco.branch_op(:"&&", name_list.__send__(:any?)) {name_list.shift}
-    ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.constant.toplevel) {::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", first_name) {self.case(
-      first_name,
-      :Myco,
-      ::Object::Proc.new { || (g.push_myco)},
-      :Ruby,
-      ::Object::Proc.new { || (g.push_cpath_top)},
-      :Rubinius,
-      ::Object::Proc.new { || (g.push_rubinius)},
-      ::Object::Proc.new { || (
-        g.push_myco
-        g.find_const(first_name)
-      )}
-    )}) {g.push_myco}}) {::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", first_name) {::Myco.find_constant(:Myco).find_constant_bytecode(
-      g,
-      first_name
-    )}) {(
-      g.push_scope
+  declare_meme(
+    :cdecl,
+    [:node_type],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :constant,
+    [:field],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :value,
+    [:field],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :bytecode,
+    [],
+    ::Object::Proc.new { |g| (
+      self.pos(g)
+      name_list = self.constant.names.map(&:to_sym)
+      last_name = name_list.pop
+      first_name = ::Myco.branch_op(:"&&", name_list.__send__(:any?)) {name_list.shift}
+      ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.constant.toplevel) {::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", first_name) {self.case(
+        first_name,
+        :Myco,
+        ::Object::Proc.new { |*| (g.push_myco)},
+        :Ruby,
+        ::Object::Proc.new { |*| (g.push_cpath_top)},
+        :Rubinius,
+        ::Object::Proc.new { |*| (g.push_rubinius)},
+        ::Object::Proc.new { |*| (
+          g.push_myco
+          g.find_const(first_name)
+        )}
+      )}) {g.push_myco}}) {::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", first_name) {::Myco.find_constant(:Myco).find_constant_bytecode(
+        g,
+        first_name
+      )}) {(
+        g.push_scope
+        g.send(
+          :for_method_definition,
+          0
+        )
+      )}}
+      name_list.each { |name| (g.find_const(name))}
+      g.push_literal(last_name)
+      self.value.bytecode(g)
       g.send(
-        :for_method_definition,
-        0
+        :const_set,
+        2
       )
-    )}}
-    name_list.each { |name| (g.find_const(name))}
-    g.push_literal(last_name)
-    self.value.bytecode(g)
-    g.send(
-      :const_set,
-      2
-    )
-  )}
+    )}
+  )
 )}}
 .tap { |__c__| __c__.__name__ = :ConstantAssignment })})}}.instance

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

@@ -2,31 +2,55 @@
 ::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::ConstantDefine = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-  declare_meme(:cdefn, [[:node_type, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:constant, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:object, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:implementation, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:ConstantAssignment).new({
-    :line => self.line,
-    :constant => self.constant,
-    :value => self.object
-  }))}
-  declare_meme(:object, [[:setter, []]], nil, ::Myco.cscope.dup) { |given| (
-    given.__send__(
-      :create=,
-      false
-    )
-    given
-  )}
-  declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
-    self.pos(g)
-    self.implementation.bytecode(g)
-    g.dup_top
-    g.push_literal(self.constant.names.last)
-    g.send(
-      :__name__=,
-      1
-    )
-    g.pop
-  )}
+  declare_meme(
+    :cdefn,
+    [:node_type],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :constant,
+    [:field],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :object,
+    [:field],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :implementation,
+    [],
+    ::Object::Proc.new { |*| (::Myco.find_constant(:ConstantAssignment).new({
+      :line => self.line,
+      :constant => self.constant,
+      :value => self.object
+    }))}
+  )
+  declare_meme(
+    :object,
+    [:setter],
+    ::Object::Proc.new { |given| (
+      given.__send__(
+        :create=,
+        false
+      )
+      given
+    )}
+  )
+  declare_meme(
+    :bytecode,
+    [],
+    ::Object::Proc.new { |g| (
+      self.pos(g)
+      self.implementation.bytecode(g)
+      g.dup_top
+      g.push_literal(self.constant.names.last)
+      g.send(
+        :__name__=,
+        1
+      )
+      g.pop
+    )}
+  )
 )}}
 .tap { |__c__| __c__.__name__ = :ConstantDefine })})}}.instance