ytljit 0.0.2 → 0.0.3

data/lib/ytljit/vm_trans.rb

@@ -190,6 +190,25 @@ module YTLJit
       # setclassvariable
       
       def visit_getconstant(code, ins, context)
+        klass = context.expstack.pop
+        case klass
+        when ConstantRefNode
+          klass = klass.value_node
+
+
+        when LiteralNode
+          klass = klass.value
+          if klass == nil then
+            klass = context.current_class_node
+          end
+
+        else
+          raise "Umkonwn node #{klass.class}"
+        end
+        name = ins[1]
+        curnode = context.current_node
+        node = ConstantRefNode.new(curnode, klass, name)
+        context.expstack.push node
       end
 
       def visit_setconstant(code, ins, context)
@@ -305,27 +324,51 @@ module YTLJit
       def visit_defineclass(code, ins, context)
         name = ins[1]
         supklsnode = context.expstack.pop
-        klassobj = Object.const_get(name, true)
+        defat = context.expstack.pop
+        clsobj = context.current_class_node.klass_object
+        klassobj = nil
+        begin
+          klassobj = clsobj.const_get(name, true)
+        rescue NameError
+        end
 
         if klassobj == nil then
-          klassnode = context.nested_class_tab[name]
+          klassnode = context.current_class_node.constant_tab[name]
           if klassnode then
-            klassobj = klassnodne.klasss_object
+            klassobj = klassnodne.klass_object
             
           else
+            supklass = nil
+            case supklsnode
+            when LiteralNode
+              supklass = supklsnode.value
+              if supklass == nil then
+                supklass = Object
+              end
+
+            when ConstantRefNode
+              supnode = supklsnode.value_node
+              if supnode.is_a?(ClassTopNode) then
+                supklass = supnode.klass_object
+              else
+                raise "Not class #{supnode.class}"
+              end
+
+            else
+              raise "Not support #{supklsnode.class}"
+            end
+
             case ins[3]
             when 0
-              supklass = nil
-              if supklsnode then
-                supklass = supklasnode.klasss_object
-              end
               klassobj = Class.new(supklass)
               
             when 2
-              klassobj = Module.new(supklass)
+              klassobj = Module.new
             end
           end
+          clsobj.const_set(name, klassobj)
         end
+        RubyType::define_wraped_class(klassobj, RubyType::RubyTypeBoxed)
         cnode = ClassTopNode.new(context.current_class_node, klassobj, name)
         
         body = VMLib::InstSeqTree.new(code, ins[2])
@@ -333,12 +376,16 @@ module YTLJit
         ncontext.current_file_name = context.current_file_name
         ncontext.current_node = cnode
         ncontext.current_class_node = cnode
-        ncontext.top_nodes.push mtopnode
+        ncontext.top_nodes.push cnode
 
         tr = self.class.new([body])
         tr.translate(ncontext)
 
-        context.current_class_node.nested_class_tab[name] = cnode
+        context.current_class_node.constant_tab[name] = cnode
+        curnode = context.current_node
+        cvnode = ClassValueNode.new(curnode, cnode)
+        context.expstack.push cvnode
+
         context
       end
 

data/lib/ytljit/vm_type.rb

@@ -85,7 +85,7 @@ module YTLJit
         @types_tree = KlassTree.new
       end
 
-      def to_key(context, offset = -1)
+      def to_signature(context, offset = -1)
         context.current_method_signature[offset]
       end
 
@@ -143,18 +143,24 @@ module YTLJit
   module RubyType
     def self.define_wraped_class(klass, base = RubyTypeBoxed)
       cn = nil
-
-      if klass then
+      if klass.name then
         cn = klass.name.to_sym
-        basett, boxtt, unboxtt = BaseType.type_tab
-        if boxtt[cn] == nil then
-          BaseType.related_ruby_class(klass, base)
+      else
+        cns = klass.inspect
+        if /([a-zA-Z:]+)/ =~ cns then
+          cn = $1.to_sym
+        else
+          raise "Unexcepcted class format #{cns}"
         end
-
-        boxobj = boxtt[cn]
-        unboxobj = unboxtt[cn]
-        [boxobj, unboxobj]
       end
+      basett, boxtt, unboxtt = BaseType.type_tab
+      if boxtt[cn] == nil then
+        BaseType.related_ruby_class(klass, base)
+      end
+
+      boxobj = boxtt[cn]
+      unboxobj = unboxtt[cn]
+      [boxobj, unboxobj]
     end
           
     class BaseType
@@ -287,13 +293,16 @@ module YTLJit
       include VM::TypeCodeGen::DefaultTypeCodeGen
     end
 
-    YTLJit::RubyType::define_wraped_class(NilClass,  RubyTypeBoxed)
-    YTLJit::RubyType::define_wraped_class(Fixnum, RubyTypeUnboxed)
-    YTLJit::RubyType::define_wraped_class(Float, RubyTypeUnboxed)
-    YTLJit::RubyType::define_wraped_class(TrueClass, RubyTypeBoxed)
-    YTLJit::RubyType::define_wraped_class(FalseClass, RubyTypeBoxed)
-    YTLJit::RubyType::define_wraped_class(String, RubyTypeBoxed)
-    YTLJit::RubyType::define_wraped_class(Array, RubyTypeBoxed)
-    YTLJit::RubyType::define_wraped_class(Hash, RubyTypeBoxed)
+    define_wraped_class(NilClass,  RubyTypeBoxed)
+    define_wraped_class(Fixnum, RubyTypeUnboxed)
+    define_wraped_class(Float, RubyTypeUnboxed)
+    define_wraped_class(TrueClass, RubyTypeBoxed)
+    define_wraped_class(FalseClass, RubyTypeBoxed)
+    define_wraped_class(Symbol, RubyTypeBoxed)
+    define_wraped_class(String, RubyTypeBoxed)
+    define_wraped_class(Array, RubyTypeBoxed)
+    define_wraped_class(Hash, RubyTypeBoxed)
+    define_wraped_class(Module, RubyTypeBoxed)
+    define_wraped_class(Class, RubyTypeBoxed)
   end
 end

data/lib/ytljit/vm_type_gen.rb

@@ -82,7 +82,6 @@ module YTLJit
         include AbsArch
 
         def gen_boxing(context)
-          p "boxingaaa"
           context
         end
 
@@ -111,7 +110,6 @@ module YTLJit
         end
 
         def gen_unboxing(context)
-          p "unboxing"
           context
         end
       end

data/test/vmtest.rb

@@ -17,7 +17,10 @@ is = RubyVM::InstructionSequence.compile(
 #        "def foo(x); if x then x = 2.0 else x = 1 end; x; end; p foo(1)", "", "", 0, 
 #         "def foo(x); yield(x) + 2; end; p foo(1) {|a| a + 1}", "", "", 0, 
 #         "def id(x); x; end; p id(1); p id(1.0)", "", "", 0, 
-         "def id(x); x; end; p id(1); p id(1.0); def id2(x) x end; id2(1)", "", "", 0, 
+#         "def id(x); x; end; p id(1); p id(1.0); def id2(x) x end; id2(1)", "", "", 0, 
+          "def mul(x); x * x; end; p mul(20);p mul(30.0)", "", "", 0,
+#          "def div(x, y); x / y; end; p div(20, 10);p div(30.0, -12.0)", "", "", 0,
+#          "def div(x, y); x / y; end; p div(-20, 10);p div(30.0, -12.0)", "", "", 0,
 #        "1.1","", "", 0,
               {  :peephole_optimization    => true,
                  :inline_const_cache       => false,
@@ -42,6 +45,7 @@ tnode.collect_candidate_type(context, [], [])
 
 tnode = Marshal.load(Marshal.dump(tnode))
 context = VM::CompileContext.new(tnode)
+context.options = {:disp_signature => true}
 tnode.compile(context)
 # context.code_space.disassemble
 p tnode.code_space

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 2
-  version: 0.0.2
+  - 3
+  version: 0.0.3
 platform: ruby
 authors: 
 - Hideki Miura
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-20 00:00:00 +09:00
+date: 2010-11-04 00:00:00 +09:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency