mirah 0.0.12-java → 0.1.0-java

data/lib/mirah/jvm/types/unreachable_type.rb

@@ -24,4 +24,4 @@ module Mirah
       end
     end
   end
-end
+end

data/lib/mirah/jvm/types/void_type.rb

@@ -2,8 +2,8 @@ module Mirah
   module JVM
     module Types
       class VoidType < PrimitiveType
-        def initialize
-          super('void', Java::JavaLang::Void)
+        def initialize(types)
+          super(types, 'void', Java::JavaLang::Void)
         end
 
         def void?
@@ -16,4 +16,4 @@ module Mirah
       end
     end
   end
-end
+end

data/lib/mirah/parser.rb

@@ -14,22 +14,22 @@
 # limitations under the License.
 
 require 'mirah/util/process_errors'
+require 'mirah/util/logging'
 require 'mirah/transform'
 require 'java'
 
 module Mirah
   class Parser
     include Mirah::Util::ProcessErrors
-    
-    def initialize(state, logging)
-      @transformer = Mirah::Transform::Transformer.new(state)
-      Java::MirahImpl::Builtin.initialize_builtins(@transformer)
+    include Mirah::Logging::Logged
+
+    def initialize(state, typer, logging)
+      @transformer = Mirah::Transform::Transformer.new(state, typer)
       @logging = logging
-      @verbose = state.verbose
     end
-    
+
     attr_accessor :transformer, :logging
-    
+
     def parse_from_args(files_or_scripts)
       nodes = []
       inline = false
@@ -46,25 +46,31 @@ module Mirah
         end
       end
       raise 'nothing to parse? ' + files_or_scripts.inspect unless nodes.length > 0
-      nodes.compact
+      nodes = nodes.compact
+      if self.logging
+        nodes.each {|node| log "Parsed:\n #{format_ast(node)}"}
+      end
+      nodes
     end
-    
+
     def parse_inline(source)
       puts "  <inline script>" if logging
       parse_and_transform('DashE', source)
     end
-    
+
     def parse_file(filename)
       puts "  #{filename}" if logging
       parse_and_transform(filename, File.read(filename))
     end
-    
+
     def parse_and_transform(filename, src)
-      mirah_ast = AST.parse src, filename, false, transformer
-      process_errors(transformer.errors)
-      mirah_ast
+      Mirah::AST.parse_ruby(transformer, src, filename)
     end
-      
+
+    def format_ast(ast)
+      AstPrinter.new.scan(ast, ast)
+    end
+
     def expand_files(files_or_scripts)
       expanded = []
       files_or_scripts.each do |filename|
@@ -82,5 +88,137 @@ module Mirah
       end
       expanded
     end
+
+    class AstPrinter < NodeScanner
+      java_import "mirah.lang.ast.Node"
+      def initialize
+        @out = ""
+        @indent = 0
+        @newline = true
+      end
+      def puts(*args)
+        print(*args)
+        @newline = true
+        @out << "\n"
+      end
+      def print(*args)
+        @out << (" " * @indent) if @newline
+        args.each {|arg| @out << arg}
+        @newline = false
+        @out
+      end
+      def indent
+        @indent += 2
+      end
+      def dedent
+        @indent -= 2
+      end
+      def enterNullChild(obj)
+        puts("nil")
+      end
+
+      def startNode(node)
+        print("[#{node.java_class.simple_name}")
+        indent
+      end
+
+      def enterDefault(node, arg)
+        startNode(node)
+        puts
+        true
+      end
+
+      def exitDefault(node, arg)
+        dedent
+        if @out[-2,2] =~ /^[\[\]"]\n/
+          @out[-1,0] = "]"
+          @out
+        else
+          no_children = @out.rindex(/[\]\n]/, -2) < @out.rindex("[")
+          if no_children
+            @out[-1,0] = "]"
+          else
+            puts("]")
+          end
+        end
+      end
+
+      %w(Boolean Fixnum Float CharLiteral).each do |name|
+        eval(<<-EOF)
+          def enter#{name}(node, arg)
+            startNode(node)
+            print(" ", node.value.to_s)
+            true
+          end
+        EOF
+      end
+
+      def enterSimpleString(node, arg)
+        first_child = @out.rindex(/[\]\n]/, -2) < @out.rindex("[")
+        if first_child
+          @newline = false
+          @out[-1,1] = " "
+        end
+        print '"', node.value
+        true
+      end
+
+      def exitSimpleString(node, arg)
+        puts '"'
+      end
+
+      def enterTypeRefImpl(node, arg)
+        startNode(node)
+        print " #{node.name}"
+        print " array" if node.isArray
+        print " static" if node.isStatic
+        true
+      end
+
+      def enterNodeList(node, arg)
+        puts "["
+        indent
+        true
+      end
+
+      def enterBlockArgument(node, arg)
+        enterDefault(node, arg)
+        puts "optional" if node.optional
+        true
+      end
+
+      def enterLoop(node, arg)
+        enterDefault(node, arg)
+        puts "skipFirstCheck" if node.skipFirstCheck
+        puts "negative" if node.negative
+        true
+      end
+
+      def exitFieldAccess(node, arg)
+        puts "static" if node.isStatic
+        exitDefault(node, arg)
+      end
+      alias exitFieldAssign exitFieldAccess
+
+      def enterUnquote(node, arg)
+        enterDefault(node, arg)
+        object = node.object
+        if object
+          if object.kind_of?(Node)
+            scan(object, arg)
+          elsif object.kind_of?(java.util.List) && object.all? {|i| i.kind_of?(Node)}
+            object.each {|o| scan(o, arg)}
+          else
+            str = if node.object.respond_to?(:toString)
+              node.object.toString
+            else
+              node.object.inspect
+            end
+            puts "<", str, ">"
+          end
+        end
+        object.nil?
+      end
+    end
   end
-end
+end

data/lib/mirah/plugin/edb.rb

@@ -24,7 +24,7 @@ Mirah::AST.defmacro('def_edb') do |transformer, fcall, parent|
   compiler.pre_cmd = ["def #{name}", "_edbout = StringBuilder.new"]
   compiler.post_cmd = ["_edbout.toString", "end"]
   src = compiler.compile(IO.read(path))
-  ast = Mirah::AST.parse_ruby(src, path)
+  ast = Mirah::AST.parse_ruby(transformer, src, path)
   transformer.filename = path
   script = transformer.transform(ast, parent)
   script.body.parent = parent

data/lib/mirah/transform.rb

@@ -15,8 +15,7 @@
 
 require 'base64'
 require 'jruby'
+
 require 'mirah/errors'
-require 'mirah/transform/error'
 require 'mirah/transform/transformer'
 require 'mirah/transform/ast_ext'
-require 'mirah/transform/helper'

data/lib/mirah/transform/ast_ext.rb

@@ -1,57 +1,38 @@
 module Mirah
   module AST
-    begin
-      java_import 'mirah.impl.MirahParser'
-    rescue NameError
-      $CLASSPATH << File.dirname(__FILE__) + '/../../../javalib/mirah-parser.jar'
-      java_import 'mirah.impl.MirahParser'
-    end
-    java_import 'jmeta.ErrorHandler'
-
-    class MirahErrorHandler
-      include ErrorHandler
-      def warning(messages, positions)
-        print "Warning: "
-        messages.each_with_index do |message, i|
-          jpos = positions[i]
-          if jpos
-            dpos = Mirah::Transform::Transformer::JMetaPosition.new(jpos, jpos)
-            print "#{message} at "
-            Mirah.print_error("", dpos)
-          else
-            print message
-          end
-        end
-      end
-    end
+    java_import 'mirah.impl.MirahParser'
+    java_import 'mirah.lang.ast.StringCodeSource'
+    java_import 'org.mirah.macros.Macro'
+    java_import 'org.mirah.util.SimpleDiagnostics'
 
     def parse(src, filename='dash_e', raise_errors=false, transformer=nil)
-      ast = parse_ruby(src, filename)
-      transformer ||= Transform::Transformer.new(Mirah::Util::CompilationState.new)
-      transformer.filename = filename
-      ast = transformer.transform(ast, nil)
-      if raise_errors
-        transformer.errors.each do |e|
-          raise e.cause || e
-        end
-      end
-      ast
+      raise ArgumentError unless transformer
+      parse_ruby(transformer, src, filename)
     end
     module_function :parse
 
-    def parse_ruby(src, filename='-')
+    def parse_ruby(transformer, src, filename='-')
       raise ArgumentError if src.nil?
+      #filename = transformer.tag_filename(src, filename)
       parser = MirahParser.new
-      parser.filename = filename
-      parser.errorHandler = MirahErrorHandler.new
+      source = StringCodeSource.new(filename, src)
+      parser.diagnostics = SimpleDiagnostics.new(true)
       begin
-        parser.parse(src)
-      rescue => ex
-        if ex.cause.kind_of? Java::Jmeta::SyntaxError
-          ex = SyntaxError.wrap ex.cause, nil
+        ast = parser.parse(source)
+        if parser.diagnostics.error_count > 0
+          puts "#{parser.diagnostics.error_count} errors, exiting"
+          throw :exit, 1
         end
+        return ast
+      rescue NativeException => ex
+        ex.cause.printStackTrace
+        raise ex
+      rescue => ex
+        # if ex.cause.kind_of? Java::OrgMirahMmeta::SyntaxError
+        #   ex = SyntaxError.wrap ex.cause, nil
+        # end
 
-        if ex.cause.respond_to? :position
+        if ex.respond_to? :position
           position = ex.cause.position
           Mirah.print_error(ex.cause.message, position)
         end
@@ -60,4 +41,4 @@ module Mirah
     end
     module_function :parse_ruby
   end
-end
+end

data/lib/mirah/transform/transformer.rb

@@ -1,41 +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.
+
 module Mirah
   module Transform
     class Transformer
       begin
-        include Java::DubyLangCompiler.Compiler
+        java_import 'org.mirah.macros.Compiler'
       rescue NameError
-        $CLASSPATH << File.dirname(__FILE__) + '/../../../javalib/mirah-bootstrap.jar'
-        include Java::DubyLangCompiler.Compiler
+        # builtins not compiled yet
       end
 
       attr_reader :errors, :state
       attr_accessor :filename
-      def initialize(state)
+
+      def initialize(state, typer)
         @errors = []
         @tmp_count = 0
         @annotations = []
-        @scopes = []
         @extra_body = nil
         @state = state
-        @helper = Mirah::Transform::Helper.new(self)
-      end
-
-      def destination
-        @state.destination
-      end
-
-      def verbose?
-        @state.verbose
-      end
-
-      def annotations
-        result, @annotations = @annotations, []
-        return result
-      end
-
-      def add_annotation(annotation)
-        @annotations << annotation
-        Mirah::AST::Noop.new(annotation.parent, annotation.position)
+        @typer = typer
+        @types = typer.type_system if typer
+        @files = {""=>{:filename => "", :line => 0, :code => ""}}
       end
 
       def tmp(format="__xform_tmp_%d")
@@ -44,214 +42,21 @@ module Mirah
 
       class JMetaPosition
         attr_accessor :start_line, :end_line, :start_offset, :end_offset, :file
-        attr_accessor :startpos, :endpos, :start_col, :end_col
+        attr_accessor :startpos, :endpos, :start_column, :end_column, :source
 
-        def initialize(startpos, endpos)
+        def initialize(transformer, startpos, endpos, source)
           @startpos = startpos
           @endpos = endpos
-          @file = startpos.filename
+          @transformer = transformer
           @start_line = startpos.line
           @start_offset = startpos.pos
-          @start_col = startpos.col
+          @start_column = startpos.col
           @end_line = endpos.line
           @end_offset = endpos.pos
-          @end_col = endpos.col
-        end
-
-        def +(other)
-          JMetaPosition.new(@startpos, other.endpos)
-        end
-      end
-
-      def position(node)
-        JMetaPosition.new(node.start_position, node.end_position)
-      end
-
-      def camelize(name)
-        name.gsub(/([a-z])([A-Z])/, '\1_\2').downcase
-      end
-
-      def transform(node, parent)
-        return nil if node.nil?
-        begin
-          top = @extra_body.nil?
-          if top
-            return nil if !node.children.empty? && node.children.all?(&:nil?)
-            
-            @extra_body = Mirah::AST::Body.new(nil, position(node))
-          end
-          method = "transform_#{camelize(node[0])}"
-          result = @helper.send method, node, parent
-          if top
-            body = result.body
-            if body.kind_of?(Mirah::AST::Body) && @extra_body.empty?
-              @extra_body = body
-            else
-              result.body = @extra_body
-              body.parent = @extra_body
-              @extra_body.children.insert(0, body)
-            end
-          end
-          return result
-        rescue Error => ex
-          @errors << ex
-          Mirah::AST::ErrorNode.new(parent, ex)
-        # rescue Exception => ex
-        #   error = Error.new(ex.message, position(node), ex)
-        #   @errors << error
-        #   Mirah::AST::ErrorNode.new(parent, error)
-        end
-      end
-
-      def captured?(node)
-        depth = node.depth
-        scope = @scopes[-1]
-        while depth > 0
-          depth -= 1
-          scope = scope.enclosing_scope
-        end
-        scope.isCaptured(node.index)
-      end
-
-      def eval(src, filename='-', parent=nil, *vars)
-        node = Mirah::AST.parse_ruby(src, filename)
-        mirah_node = transform(node, nil).body
-        mirah_node.parent = parent
-        mirah_node
-      end
-
-      def dump_ast(node, call=nil)
-        encoded = nil
-        values = Mirah::AST::Unquote.extract_values do
-          encoded = Base64.encode64(Marshal.dump(node))
-        end
-        scope = call.scope.static_scope if call
-        result = Mirah::AST::Array.new(nil, node.position)
-        if encoded.size < 65535
-          result << Mirah::AST::String.new(result, node.position, encoded)
-        else
-          strings = Mirah::AST::StringConcat.new(result, node.position)
-          result << strings
-          while encoded.size >= 65535
-            chunk = encoded[0, 65535]
-            encoded[0, 65535] = ""
-            strings << Mirah::AST::String.new(strings, node.position, chunk)
-          end
-          strings << Mirah::AST::String.new(strings, node.position, encoded)
-        end
-        values.each do |value|
-          if call
-            scoped_value = Mirah::AST::ScopedBody.new(result, value.position)
-            scoped_value << value
-            scoped_value.static_scope = scope
-          else
-            scoped_value = value
-          end
-          result << scoped_value
-        end
-        return result
-      end
-
-      def load_ast(args)
-        nodes = args.to_a
-        encoded = nodes.shift
-        Mirah::AST::Unquote.inject_values(nodes) do
-          result = Marshal.load(Base64.decode64(encoded))
-          if Mirah::AST::UnquotedValue === result
-            result.node
-          else
-            result
-          end
-        end
-      end
-
-      def __ruby_eval(code, arg)
-        self.instance_eval(code)
-      end
-
-      def fixnum(value)
-        node = eval("1")
-        node.literal = value
-        node
-      end
-
-      def constant(name, array=false)
-        node = eval("Foo")
-        node.name = name
-        node.array = array
-        node
-      end
-
-      def cast(type, value)
-        if value.kind_of?(String)
-          value = Mirah::AST::Local.new(@extra_body, @extra_body.position, value)
-        end
-        fcall = eval("Foo()")
-        fcall.name = type
-        fcall.parameters = [value]
-        fcall
-      end
-
-      def string(value)
-        node = eval('"Foo"')
-        node.literal = value
-        node
-      end
-
-      def empty_array(type_node, size_node)
-        node = eval('int[0]')
-        node.type_node = type_node
-        node.size = size_node
-        node
-      end
-
-      def find_class(name)
-        AST.type(nil, name, false, false)
-      end
-
-      def expand(fvcall, parent)
-        result = yield self, fvcall, parent
-        unless AST::Node === result
-          raise Error.new('Invalid macro result', fvcall.position)
-        end
-        result
-      end
-
-      def append_node(node)
-        @extra_body << node
-        node
-      end
-
-      def define_class(position, name, &block)
-        append_node Mirah::AST::ClassDefinition.new(@extra_body, position, name, &block)
-      end
-
-      def defineClass(name, superclass=nil, interfaces=nil)
-        define_class(@extra_body.position, name) do |class_def|
-          superclass = Mirah::AST::Constant.new(class_def, class_def.position, superclass)
-          superclass.parent = class_def
-          if interfaces
-            class_def.implements(*interfaces.map {|i|  Mirah::AST::Constant.new(class_def, class_def.position, i)})
-          end
-          [superclass, body(class_def)]
-        end
-      end
-
-      def body(parent=nil)
-        parent ||= @extra_body
-        Mirah::AST::Body.new(parent, parent.position)
-      end
-
-      def define_closure(position, name, enclosing_type)
-        target = self
-        parent = @extra_body
-        enclosing_type = enclosing_type.unmeta
-        if enclosing_type.respond_to?(:node) && enclosing_type.node
-          parent = target = enclosing_type.node
+          @end_column = endpos.col
+          @source = source
         end
-        target.append_node(Mirah::AST::ClosureDefinition.new(
-            parent, position, name, enclosing_type))
       end
     end
   end
-end
+end