duby 0.0.2-java → 0.0.3-java

data/lib/duby/compiler.rb

@@ -10,7 +10,16 @@ module Duby
         end
       end
     end
-    
+
+    class Regexp
+      def compile(compiler, expression)
+        if expression
+          compiler.line(line_number)
+          compiler.regexp(literal)
+        end
+      end
+    end
+
     class String
       def compile(compiler, expression)
         if expression
@@ -19,7 +28,19 @@ module Duby
         end
       end
     end
-    
+
+    class StringConcat
+      def compile(compiler, expression)
+        compiler.build_string(children, expression)
+      end
+    end
+
+    class ToString
+      def compile(compiler, expression)
+        compiler.to_string(body, expression)
+      end
+    end
+
     class Float
       def compile(compiler, expression)
         if expression
@@ -28,7 +49,7 @@ module Duby
         end
       end
     end
-    
+
     class Boolean
       def compile(compiler, expression)
         if expression
@@ -43,7 +64,7 @@ module Duby
         compiler.array(self, expression)
       end
     end
-    
+
     class Body
       def compile(compiler, expression)
         compiler.line(line_number)
@@ -51,6 +72,13 @@ module Duby
       end
     end
 
+    class ScopedBody
+      def compile(compiler, expression)
+        compiler.line(line_number)
+        compiler.scoped_body(self, expression)
+      end
+    end
+
     class Import
       def compile(compiler, expression)
         # TODO: what does it mean for import to be an expression?
@@ -74,12 +102,16 @@ module Duby
         compiler.print(self)
       end
     end
-    
+
     class Local
       def compile(compiler, expression)
         if expression
           compiler.line(line_number)
-          compiler.local(name, inferred_type)
+          if captured? && scope.has_binding?
+            compiler.captured_local(containing_scope, name, inferred_type)
+          else
+            compiler.local(containing_scope, name, inferred_type)
+          end
         end
       end
     end
@@ -87,58 +119,66 @@ module Duby
     class LocalDeclaration
       def compile(compiler, expression)
         compiler.line(line_number)
-        compiler.local_declare(name, type)
+        if captured? && scope.has_binding?
+          compiler.captured_local_declare(containing_scope, name, type)
+        else
+          compiler.local_declare(containing_scope, name, type)
+        end
       end
     end
-    
+
     class LocalAssignment
       def compile(compiler, expression)
         compiler.line(line_number)
-        compiler.local_assign(name, inferred_type, expression, value)
+        if captured? && scope.has_binding?
+          compiler.captured_local_assign(self, expression)
+        else
+          compiler.local_assign(containing_scope, name, inferred_type, expression, value)
+        end
       end
     end
-    
+
     class Script
       def compile(compiler, expression)
         # TODO: what does it mean for a script to be an expression? possible?
-        compiler.define_main(body)
+        compiler.define_main(self)
       end
     end
-    
+
     class MethodDefinition
       def compile(compiler, expression)
         # TODO: what does it mean for a method to be an expression?
         compiler.define_method(self)
       end
     end
-    
+
     class ConstructorDefinition
       def compile(compiler, expression)
         compiler.constructor(self)
       end
     end
-    
+
     class Arguments
       def compile(compiler, expression)
         # TODO: what does it mean for a method to be an expression?
         args.each {|arg| compiler.declare_argument(arg.name, arg.inferred_type)} if args
       end
     end
-    
+
     class Noop
       def compile(compiler, expression)
         # TODO: what does it mean for a noop to be an expression
         # nothing
       end
     end
-    
+
     class If
       def compile(compiler, expression)
         compiler.line(line_number)
         compiler.branch(self, expression)
       end
     end
-    
+
     class Condition
       def compile(compiler, expression)
         # TODO: can a condition ever be an expression? I don't think it can...
@@ -146,14 +186,14 @@ module Duby
         predicate.compile(compiler, expression)
       end
     end
-    
+
     class FunctionalCall
       def compile(compiler, expression)
         compiler.line(line_number)
         compiler.self_call(self, expression)
       end
     end
-    
+
     class Call
       def compile(compiler, expression)
         compiler.line(line_number)
@@ -167,20 +207,26 @@ module Duby
         compiler.super_call(self, expression)
       end
     end
-    
+
     class Loop
       def compile(compiler, expression)
         compiler.line(line_number)
         compiler.loop(self, expression)
       end
     end
-    
+
     class ClassDefinition
       def compile(compiler, expression)
         compiler.define_class(self, expression)
       end
     end
 
+    class ClosureDefinition
+      def compile(compiler, expression)
+        compiler.define_closure(self, expression)
+      end
+    end
+
     class FieldDeclaration
       def compile(compiler, expression)
         compiler.field_declare(name, inferred_type, annotations)
@@ -218,7 +264,7 @@ module Duby
         end
       end
     end
-    
+
     class Null
       def compile(compiler, expression)
         if expression
@@ -227,21 +273,21 @@ module Duby
         end
       end
     end
-    
+
     class Break
       def compile(compiler, expression)
         compiler.line(line_number)
         compiler.break(self)
       end
     end
-    
+
     class Next
       def compile(compiler, expression)
         compiler.line(line_number)
         compiler.next(self)
       end
     end
-    
+
     class Redo
       def compile(compiler, expression)
         compiler.line(line_number)
@@ -252,7 +298,7 @@ module Duby
     class Raise
       def compile(compiler, expression)
         compiler.line(line_number)
-        compiler._raise(@exception)
+        compiler._raise(exception)
       end
     end
 
@@ -262,14 +308,14 @@ module Duby
         compiler.rescue(self, expression)
       end
     end
-    
+
     class Ensure
       def compile(compiler, expression)
         compiler.line(line_number)
         compiler.ensure(self, expression)
       end
     end
-    
+
     class Self
       def compile(compiler, expression)
         if expression
@@ -278,5 +324,14 @@ module Duby
         end
       end
     end
+
+    class BindingReference
+      def compile(compiler, expression)
+        if expression
+          compiler.line(line_number)
+          compiler.binding_reference
+        end
+      end
+    end
   end
 end

data/lib/duby/env.rb

@@ -0,0 +1,33 @@
+require 'rbconfig'
+
+module Duby
+  module Env
+
+    # Returns the system PATH_SEPARATOR environment variable value. This is used when
+    # separating multiple paths in one string. If none is defined then a : (colon)
+    # is returned
+    def self.path_seperator
+      ps = RbConfig::CONFIG['PATH_SEPARATOR']
+      ps = ':' if ps.nil? || ps == ''
+      ps
+    end
+
+    # Takes an array of strings and joins them using the path_separator returning
+    # a single string value
+    def self.encode_paths(paths)
+      paths.join(path_seperator)
+    end
+
+    # Takes a single string value "paths" and returns an array of strings containing the
+    # original string separated using the path_separator. An option second parameter
+    # is an array that will have the strings appended to it. If the optional array parameter
+    # is supplied it is returned as the result
+    def self.decode_paths(paths, dest = nil)
+      result = dest ? dest : []
+      paths.split(path_seperator).each do |path|
+        result << path
+      end
+      result
+    end
+  end
+end

data/lib/duby/jvm/base.rb

@@ -0,0 +1,210 @@
+module Duby
+  module Compiler
+    class JVMCompilerBase
+      attr_accessor :filename, :method, :static, :class
+
+      def initialize(filename)
+        @filename = File.basename(filename)
+        @static = true
+        classname = JVM.classname_from_filename(filename)
+        @type = AST::type(classname)
+        @jump_scope = []
+        @bindings = Hash.new {|h, type| h[type] = type.define(@file)}
+        @captured_locals = Hash.new {|h, binding| h[binding] = {}}
+      end
+
+      def compile(ast, expression = false)
+        ast.compile(self, expression)
+        log "Compilation successful!"
+      end
+
+      def log(message); JVM.log(message); end
+
+      def toplevel_class
+        @class = @type.define(@file)
+      end
+
+      def generate
+        log "Generating #{output_type}..."
+        @file.generate do |filename, builder|
+          log "  #{builder.class_name}"
+          if block_given?
+            yield filename, builder
+          else
+            File.open(filename, 'w') {|f| f.write(builder.generate)}
+          end
+        end
+        log "...done!"
+      end
+
+      def define_main(script)
+        body = script.body
+        body = body[0] if body.children.size == 1
+        if body.class != AST::ClassDefinition
+          @class = @type.define(@file)
+          with :method => @class.main do
+            log "Starting main method"
+
+            @method.start
+            @current_scope = script.static_scope
+            begin_main
+
+            prepare_binding(script) do
+              body.compile(self, false)
+            end
+
+            finish_main
+            @method.stop
+          end
+          @class.stop
+        else
+          body.compile(self, false)
+        end
+
+        log "Main method complete!"
+      end
+
+      def begin_main; end
+      def finish_main; end
+
+      def define_method(node, args_are_types)
+        name, signature, args = node.name, node.signature, node.arguments.args
+        if name == "initialize" && node.static?
+          name = "<clinit>"
+        end
+        if args_are_types
+          arg_types = args.map { |arg| arg.inferred_type } if args
+        else
+          arg_types = args
+        end
+        arg_types ||= []
+        return_type = signature[:return]
+        exceptions = signature[:throws]
+        puts "exceptions: #{exceptions.inspect}" if exceptions && exceptions.size > 0
+
+        with :static => @static || node.static?, :current_scope => node.static_scope do
+          if @static
+            method = @class.public_static_method(name.to_s, exceptions, return_type, *arg_types)
+          else
+            method = @class.public_method(name.to_s, exceptions, return_type, *arg_types)
+          end
+          annotate(method, node.annotations)
+          yield method, arg_types
+        end
+
+        arg_types_for_opt = []
+        args_for_opt = []
+        if args
+          args.each do |arg|
+            if AST::OptionalArgument === arg
+              new_args = if args_are_types
+                arg_types_for_opt
+              else
+                args_for_opt
+              end
+              if @static
+                method = @class.public_static_method(name.to_s, exceptions, return_type, *new_args)
+              else
+                method = @class.public_method(name.to_s, exceptions, return_type, *new_args)
+              end
+
+              with :method => method do
+                log "Starting new method #{name}(#{arg_types_for_opt})"
+
+                annotate(method, node.annotations)
+                @method.start
+
+                define_optarg_chain(name, arg,
+                                    return_type,
+                                    args_for_opt,
+                                    arg_types_for_opt)
+
+                @method.stop
+              end
+            end
+            arg_types_for_opt << arg.inferred_type
+            args_for_opt << arg
+          end
+        end
+      end
+
+      def constructor(node, args_are_types)
+        args = node.arguments.args || []
+        arg_types = if args_are_types
+          args.map { |arg| arg.inferred_type }
+        else
+          args
+        end
+        exceptions = node.signature[:throws]
+        method = @class.public_constructor(exceptions, *arg_types)
+        annotate(method, node.annotations)
+        with :current_scope => node.static_scope do
+          yield(method, args)
+        end
+      end
+
+      def define_class(class_def, expression)
+        with(:type => class_def.inferred_type,
+             :class => class_def.inferred_type.define(@file),
+             :static => false) do
+          annotate(@class, class_def.annotations)
+          class_def.body.compile(self, false) if class_def.body
+          @class.stop
+        end
+      end
+
+      def declare_argument(name, type)
+        # declare local vars for arguments here
+      end
+
+      def body(body, expression)
+        # all except the last element in a body of code is treated as a statement
+        i, last = 0, body.children.size - 1
+        while i < last
+          body.children[i].compile(self, false)
+          i += 1
+        end
+        yield body.children[last] if last >= 0
+      end
+
+      def scoped_body(scope, expression)
+        body(scope, expression)
+      end
+
+      def scoped_local_name(name, scope=nil)
+        if scope.nil? || scope == @current_scope
+          name
+        else
+          "#{name}$#{scope.object_id}"
+        end
+      end
+
+      def import(short, long)
+      end
+
+      def get_binding(type)
+        @bindings[type]
+      end
+
+      def declared_captures(binding=nil)
+        @captured_locals[binding || @binding]
+      end
+
+      def with(vars)
+        orig_values = {}
+        begin
+          vars.each do |name, new_value|
+            name = "@#{name}"
+            orig_values[name] = instance_variable_get name
+            instance_variable_set name, new_value
+          end
+          yield
+        ensure
+          orig_values.each do |name, value|
+            instance_variable_set name, value
+          end
+        end
+      end
+    end
+  end
+end