mirah 0.0.7-java → 0.0.8-java

data/lib/mirah/commands/compile.rb

@@ -0,0 +1,39 @@
+# Copyright (c) 2010 The Mirah project authors. All Rights Reserved.
+# All contributing project authors may be found in the NOTICE file.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'mirah/generator'
+require 'fileutils'
+
+module Mirah
+  module Commands
+    class Compile < Base
+      def execute
+        execute_base do
+          generator = Mirah::Generator.new(@state, @state.compiler_class, true, @state.verbose)
+          
+          generator.generate(@state.args).each do |result|
+            filename = "#{@state.destination}#{result.filename}"
+            FileUtils.mkdir_p(File.dirname(filename))
+            File.open(filename, 'wb') {|f| f.write(result.bytes)}
+          end
+        end
+      end
+      
+      def command_name
+        :compile
+      end
+    end
+  end
+end

data/{examples/wiki/Rakefile → lib/mirah/commands/parse.rb}

@@ -13,21 +13,22 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-# Hack to use the latest version instead of the gems when developing Mirah
-if File.exist?('../../lib/mirah.rb')
-  $: << File.expand_path('../../lib')
-end
-if File.exist?('../../../bitescript/lib/bitescript.rb')
-  $: << File.expand_path('../../../bitescript/lib/')
-end
-require 'mirah/appengine_tasks'
+require 'mirah/parser'
 
-appengine_app :app
-
-DUBY_APP = "#{Mirah.dest_path}/org/mirah/wiki/MirahWiki.class"
-Templates = Dir.glob("#{Mirah.source_path}/org/mirah/wiki/*.eduby.html")
-
-Rake::Task[DUBY_APP].enhance(Templates)
-
-task :app => DUBY_APP
-task :default => :server
+module Mirah
+  module Commands
+    class Parse < Base
+      def execute
+        execute_base do
+          parser = Mirah::Parser.new(@state, false)
+          
+          parser.parse_from_args(args)
+        end
+      end
+      
+      def command_name
+        :parse
+      end
+    end
+  end
+end

data/lib/mirah/commands/run.rb

@@ -0,0 +1,73 @@
+# Copyright (c) 2010 The Mirah project authors. All Rights Reserved.
+# All contributing project authors may be found in the NOTICE file.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'mirah/generator'
+require 'mirah/util/class_loader'
+
+module Mirah
+  module Commands
+    class Run < Base
+      def execute
+        execute_base do
+          main = nil
+          class_map = {}
+          
+          # generate all bytes for all classes
+          generator = Mirah::Generator.new(@state, @state.compiler_class, false, @state.verbose)
+          
+          generator.generate(args).each do |result|
+            class_map[result.classname.gsub(/\//, '.')] = result.bytes
+          end
+          
+          # load all classes
+          main = load_classes_and_find_main(class_map)
+          
+          # run the main method we found
+          run_main(main)
+        end
+      end
+      
+      def command_name
+        :run
+      end
+      
+      private
+      
+      def load_classes_and_find_main(class_map)
+        main = nil
+        dcl = Mirah::Util::ClassLoader.new(JRuby.runtime.jruby_class_loader, class_map)
+        class_map.each do |name,|
+          cls = dcl.load_class(name)
+          # TODO: using first main; find correct one?
+          main ||= cls.get_method("main", java::lang::String[].java_class)
+        end
+        main
+      end
+      
+      def run_main(main)
+        if main
+          begin
+            main.invoke(nil, [args.to_java(:string)].to_java)
+          rescue java.lang.Exception => e
+            e = e.cause if e.cause
+            raise e
+          end
+        else
+          puts "No main found" unless @state.version_printed || @state.help_printed
+        end
+      end
+    end
+  end
+end

data/lib/mirah/compiler.rb

@@ -13,430 +13,50 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require 'mirah'
+require 'mirah/compiler/call'
+require 'mirah/compiler/class'
+require 'mirah/compiler/flow'
+require 'mirah/compiler/literal'
+require 'mirah/compiler/local'
+require 'mirah/compiler/method'
+require 'mirah/compiler/structure'
+require 'mirah/compiler/type'
 
 module Mirah
-  module AST
-    class Fixnum
-      def compile(compiler, expression)
-        if expression
-          compiler.line(line_number)
-          compiler.fixnum(inferred_type, literal)
-        end
-      rescue Exception => ex
-        raise Mirah::InternalCompilerError.wrap(ex, self)
-      end
-    end
-
-    class Regexp
-      def compile(compiler, expression)
-        if expression
-          compiler.line(line_number)
-          compiler.regexp(literal)
-        end
-      rescue Exception => ex
-        raise Mirah::InternalCompilerError.wrap(ex, self)
-      end
-    end
-
-    class String
-      def compile(compiler, expression)
-        if expression
-          compiler.line(line_number)
-          compiler.string(literal)
-        end
-      rescue Exception => ex
-        raise Mirah::InternalCompilerError.wrap(ex, self)
-      end
-    end
-
-    class StringConcat
-      def compile(compiler, expression)
-        compiler.build_string(children, expression)
-      rescue Exception => ex
-        raise Mirah::InternalCompilerError.wrap(ex, self)
-      end
-    end
-
-    class ToString
-      def compile(compiler, expression)
-        compiler.to_string(body, expression)
-      rescue Exception => ex
-        raise Mirah::InternalCompilerError.wrap(ex, self)
-      end
-    end
-
-    class Float
-      def compile(compiler, expression)
-        if expression
-          compiler.line(line_number)
-          compiler.float(inferred_type, literal)
-        end
-      rescue Exception => ex
-        raise Mirah::InternalCompilerError.wrap(ex, self)
-      end
-    end
-
-    class Boolean
-      def compile(compiler, expression)
-        if expression
-          compiler.line(line_number)
-          compiler.boolean(literal)
-        end
-      rescue Exception => ex
-        raise Mirah::InternalCompilerError.wrap(ex, self)
-      end
-    end
-
-    class Array
-      def compile(compiler, expression)
-        compiler.array(self, expression)
-      rescue Exception => ex
-        raise Mirah::InternalCompilerError.wrap(ex, self)
-      end
-    end
-
-    class Body
-      def compile(compiler, expression)
-        compiler.line(line_number)
-        compiler.body(self, expression)
-      rescue Exception => ex
-        raise Mirah::InternalCompilerError.wrap(ex, self)
-      end
-    end
-
-    class ScopedBody
-      def compile(compiler, expression)
-        compiler.line(line_number)
-        compiler.scoped_body(self, expression)
-      rescue Exception => ex
-        raise Mirah::InternalCompilerError.wrap(ex, self)
-      end
-    end
-
-    class Import
-      def compile(compiler, expression)
-        # TODO: what does it mean for import to be an expression?
-        compiler.import(short, long)
-      rescue Exception => ex
-        raise Mirah::InternalCompilerError.wrap(ex, self)
-      end
-    end
-
-    class Constant
-      def compile(compiler, expression)
-        if expression
-          compiler.line(line_number)
-          compiler.constant(self)
-        end
-      rescue Exception => ex
-        raise Mirah::InternalCompilerError.wrap(ex, self)
-      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)
-      rescue Exception => ex
-        raise Mirah::InternalCompilerError.wrap(ex, 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)
+  module Compiler
+    class ASTCompiler
+      def initialize(compiler_class, logging)
+        @compiler_class = compiler_class
+        @logging = logging
+      end
+      
+      attr_accessor :compiler_class, :logging
+      
+      def compile_asts(nodes)
+        results = []
+        puts "Compiling..." if logging
+        nodes.each do |ast|
+          puts "  #{ast.position.file}" if logging
+          compile_ast(ast) do |filename, builder|
+            results << CompilerResult.new(filename, builder.class_name, builder.generate)
           end
         end
-      rescue Exception => ex
-        raise Mirah::InternalCompilerError.wrap(ex, self)
-      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
-      rescue Exception => ex
-        raise Mirah::InternalCompilerError.wrap(ex, self)
-      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
-      rescue Exception => ex
-        raise Mirah::InternalCompilerError.wrap(ex, self)
-      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)
-      rescue Exception => ex
-        raise Mirah::InternalCompilerError.wrap(ex, 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)
-      rescue Exception => ex
-        raise Mirah::InternalCompilerError.wrap(ex, self)
-      end
-    end
-
-    class ConstructorDefinition
-      def compile(compiler, expression)
-        compiler.constructor(self)
-      rescue Exception => ex
-        raise Mirah::InternalCompilerError.wrap(ex, 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
-      rescue Exception => ex
-        raise Mirah::InternalCompilerError.wrap(ex, self)
-      end
-    end
-
-    class Noop
-      def compile(compiler, expression)
-        # TODO: what does it mean for a noop to be an expression
-        # nothing
-      rescue Exception => ex
-        raise Mirah::InternalCompilerError.wrap(ex, self)
-      end
-    end
-
-    class If
-      def compile(compiler, expression)
-        compiler.line(line_number)
-        compiler.branch(self, expression)
-      rescue Exception => ex
-        raise Mirah::InternalCompilerError.wrap(ex, self)
-      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)
-      rescue Exception => ex
-        raise Mirah::InternalCompilerError.wrap(ex, self)
-      end
-    end
-
-    class FunctionalCall
-      def compile(compiler, expression)
-        compiler.line(line_number)
-        compiler.self_call(self, expression)
-      rescue Exception => ex
-        raise Mirah::InternalCompilerError.wrap(ex, self)
-      end
-    end
-
-    class Call
-      def compile(compiler, expression)
-        compiler.line(line_number)
-        compiler.call(self, expression)
-      rescue Exception => ex
-        raise Mirah::InternalCompilerError.wrap(ex, self)
-      end
-    end
-
-    class Super
-      def compile(compiler, expression)
-        compiler.line(line_number)
-        compiler.super_call(self, expression)
-      rescue Exception => ex
-        raise Mirah::InternalCompilerError.wrap(ex, self)
-      end
-    end
-
-    class Loop
-      def compile(compiler, expression)
-        compiler.line(line_number)
-        compiler.loop(self, expression)
-      rescue Exception => ex
-        raise Mirah::InternalCompilerError.wrap(ex, self)
-      end
-    end
-
-    class ClassDefinition
-      def compile(compiler, expression)
-        compiler.define_class(self, expression)
-      rescue Exception => ex
-        raise Mirah::InternalCompilerError.wrap(ex, self)
-      end
-    end
-
-    class ClosureDefinition
-      def compile(compiler, expression)
-        compiler.define_closure(self, expression)
-      rescue Exception => ex
-        raise Mirah::InternalCompilerError.wrap(ex, self)
-      end
-    end
-
-    class FieldDeclaration
-      def compile(compiler, expression)
-        compiler.field_declare(name, inferred_type, annotations, static)
-      rescue Exception => ex
-        raise Mirah::InternalCompilerError.wrap(ex, self)
-      end
-    end
-
-    class FieldAssignment
-      def compile(compiler, expression)
-        compiler.line(line_number)
-        compiler.field_assign(name, inferred_type, expression, value, annotations, static)
-      rescue Exception => ex
-        raise Mirah::InternalCompilerError.wrap(ex, self)
-      end
-    end
-
-    class Field
-      def compile(compiler, expression)
-        compiler.line(line_number)
-        if expression
-          compiler.field(name, inferred_type, annotations, static)
-        end
-      rescue Exception => ex
-        raise Mirah::InternalCompilerError.wrap(ex, self)
+        results
       end
-    end
-
-    class AccessLevel
-      def compile(compiler, expression); end
-    end
-
-    class Return
-      def compile(compiler, expression)
-        compiler.line(line_number)
-        compiler.return(self)
-      rescue Exception => ex
-        raise Mirah::InternalCompilerError.wrap(ex, self)
-      end
-    end
-
-    class EmptyArray
-      def compile(compiler, expression)
-        if expression
-          compiler.line(line_number)
-          compiler.empty_array(component_type, size)
-        end
-      rescue Exception => ex
-        raise Mirah::InternalCompilerError.wrap(ex, self)
-      end
-    end
-
-    class Null
-      def compile(compiler, expression)
-        if expression
-          compiler.line(line_number)
-          compiler.null
-        end
-      rescue Exception => ex
-        raise Mirah::InternalCompilerError.wrap(ex, self)
-      end
-    end
-
-    class Break
-      def compile(compiler, expression)
-        compiler.line(line_number)
-        compiler.break(self)
-      rescue Exception => ex
-        raise Mirah::InternalCompilerError.wrap(ex, self)
-      end
-    end
-
-    class Next
-      def compile(compiler, expression)
-        compiler.line(line_number)
-        compiler.next(self)
-      rescue Exception => ex
-        raise Mirah::InternalCompilerError.wrap(ex, self)
-      end
-    end
-
-    class Redo
-      def compile(compiler, expression)
-        compiler.line(line_number)
-        compiler.redo(self)
-      rescue Exception => ex
-        raise Mirah::InternalCompilerError.wrap(ex, self)
-      end
-    end
-
-    class Raise
-      def compile(compiler, expression)
-        compiler.line(line_number)
-        compiler._raise(exception)
-      rescue Exception => ex
-        raise Mirah::InternalCompilerError.wrap(ex, self)
+      
+      def compile_ast(ast, &block)
+        compiler = compiler_class.new
+        ast.compile(compiler, false)
+        compiler.generate(&block)
       end
     end
-
-    class Rescue
-      def compile(compiler, expression)
-        compiler.line(line_number)
-        compiler.rescue(self, expression)
-      rescue Exception => ex
-        raise Mirah::InternalCompilerError.wrap(ex, self)
-      end
-    end
-
-    class Ensure
-      def compile(compiler, expression)
-        compiler.line(line_number)
-        compiler.ensure(self, expression)
-      rescue Exception => ex
-        raise Mirah::InternalCompilerError.wrap(ex, self)
-      end
-    end
-
-    class Self
-      def compile(compiler, expression)
-        if expression
-          compiler.line(line_number)
-          compiler.compile_self
-        end
-      rescue Exception => ex
-        raise Mirah::InternalCompilerError.wrap(ex, self)
-      end
-    end
-
-    class BindingReference
-      def compile(compiler, expression)
-        if expression
-          compiler.line(line_number)
-          compiler.binding_reference
-        end
-      rescue Exception => ex
-        raise Mirah::InternalCompilerError.wrap(ex, self)
+    
+    class CompilerResult
+      def initialize(filename, classname, bytes)
+        @filename, @classname, @bytes = filename, classname, bytes
       end
+      
+      attr_accessor :filename, :classname, :bytes
     end
   end
-end
+end