mirah 0.0.4-java

data/lib/mirah/compiler.rb

@@ -0,0 +1,341 @@
+require 'mirah'
+
+module Duby
+  module AST
+    class Fixnum
+      def compile(compiler, expression)
+        if expression
+          compiler.line(line_number)
+          compiler.fixnum(inferred_type, literal)
+        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
+          compiler.line(line_number)
+          compiler.string(literal)
+        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
+          compiler.line(line_number)
+          compiler.float(inferred_type, literal)
+        end
+      end
+    end
+
+    class Boolean
+      def compile(compiler, expression)
+        if expression
+          compiler.line(line_number)
+          compiler.boolean(literal)
+        end
+      end
+    end
+
+    class Array
+      def compile(compiler, expression)
+        compiler.array(self, expression)
+      end
+    end
+
+    class Body
+      def compile(compiler, expression)
+        compiler.line(line_number)
+        compiler.body(self, expression)
+      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?
+        compiler.import(short, long)
+      end
+    end
+
+    class Constant
+      def compile(compiler, expression)
+        if expression
+          compiler.line(line_number)
+          compiler.constant(self)
+        end
+      end
+    end
+
+    class Print
+      def compile(compiler, expression)
+        # TODO: what does it mean for printline to be an expression?
+        compiler.line(line_number)
+        compiler.print(self)
+      end
+    end
+
+    class Local
+      def compile(compiler, expression)
+        if expression
+          compiler.line(line_number)
+          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
+
+    class LocalDeclaration
+      def compile(compiler, expression)
+        compiler.line(line_number)
+        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)
+        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(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...
+        compiler.line(line_number)
+        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)
+        compiler.call(self, expression)
+      end
+    end
+
+    class Super
+      def compile(compiler, expression)
+        compiler.line(line_number)
+        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, static)
+      end
+    end
+
+    class FieldAssignment
+      def compile(compiler, expression)
+        compiler.line(line_number)
+        compiler.field_assign(name, inferred_type, expression, value, annotations, static)
+      end
+    end
+
+    class Field
+      def compile(compiler, expression)
+        compiler.line(line_number)
+        if expression
+          compiler.field(name, inferred_type, annotations, static)
+        end
+      end
+    end
+
+    class AccessLevel
+      def compile(compiler, expression); end
+    end
+
+    class Return
+      def compile(compiler, expression)
+        compiler.line(line_number)
+        compiler.return(self)
+      end
+    end
+
+    class EmptyArray
+      def compile(compiler, expression)
+        if expression
+          compiler.line(line_number)
+          compiler.empty_array(component_type, size)
+        end
+      end
+    end
+
+    class Null
+      def compile(compiler, expression)
+        if expression
+          compiler.line(line_number)
+          compiler.null
+        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)
+        compiler.redo(self)
+      end
+    end
+
+    class Raise
+      def compile(compiler, expression)
+        compiler.line(line_number)
+        compiler._raise(exception)
+      end
+    end
+
+    class Rescue
+      def compile(compiler, expression)
+        compiler.line(line_number)
+        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
+          compiler.line(line_number)
+          compiler.compile_self
+        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/mirah/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/mirah/jvm/base.rb

@@ -0,0 +1,258 @@
+module Duby
+  module Compiler
+    class JVMCompilerBase
+      attr_accessor :filename, :method, :static, :class
+
+      class CompilationError < Exception
+        attr_accessor :node
+        def initialize(msg, node = nil)
+          super(msg)
+          @node = node
+        end
+      end
+
+      def initialize
+        @jump_scope = []
+        @bindings = Hash.new {|h, type| h[type] = type.define(@file)}
+        @captured_locals = Hash.new {|h, binding| h[binding] = {}}
+        @self_scope = nil
+      end
+
+      def error(message, node)
+        raise CompilationError.new(message, node)
+      end
+
+      def compile(ast, expression = false)
+        begin
+          ast.compile(self, expression)
+        rescue => ex
+          Duby.print_error(ex.message, ast.position)
+          raise ex
+        end
+        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, 'wb') {|f| f.write(builder.generate)}
+          end
+        end
+        log "...done!"
+      end
+
+      def define_main(script)
+        @static = true
+        @filename = File.basename(script.filename)
+        classname = JVM.classname_from_filename(@filename)
+        @type = AST.type(script, classname)
+        @file = file_builder(@filename)
+        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
+            declare_locals(@current_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
+
+      # arg_types must be an Array
+      def create_method_builder(name, node, static, exceptions, return_type, arg_types)
+        @class.build_method(name.to_s, node.visibility, static,
+          exceptions, return_type, *arg_types)
+      end
+
+      def base_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]
+
+        with :static => @static || node.static?, :current_scope => node.static_scope do
+          method = create_method_builder(name, node, @static, exceptions,
+                                         return_type, arg_types)
+          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
+              method = create_method_builder(name, node, @static, exceptions,
+                                             return_type, new_args)
+              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.build_constructor(node.visibility, 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)
+        saved_self = @self_scope
+        if body.kind_of?(Duby::AST::ScopedBody)
+          scope = body.static_scope
+          declare_locals(scope)
+          if scope != @self_scope
+            @self_scope = scope
+            if scope.self_node
+              # FIXME This is a horrible hack!
+              # Instead we should eliminate unused self's.
+              unless scope.self_type.name == 'mirah.impl.Builtin'
+                local_assign(
+                    scope, 'self', scope.self_type, false, scope.self_node)
+              end
+            end
+          end
+        end
+        # 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
+        @self_scope = saved_self
+      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 fixnum(type, value)
+        type.literal(method, value)
+      end
+      alias float fixnum
+
+      def compile_self
+        if @self_scope && @self_scope.self_node
+          local(@self_scope, 'self', @self_scope.self_type)
+        else
+          real_self
+        end
+      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