mirah 0.0.12-java → 0.1.0-java

data/lib/mirah/jvm/source_generator/loops.rb

@@ -1,131 +0,0 @@
-# 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 JVM
-    module Compiler
-      class JavaSource < Base
-        class SimpleWhileLoop
-          attr_reader :compiler, :loop
-          def initialize(loop, compiler)
-            @loop = loop
-            @compiler = compiler
-          end
-
-          def break
-            compiler.method.puts "break;"
-          end
-
-          def next
-            compiler.method.puts "continue;"
-          end
-
-          def redo
-            raise "#{self.class.name} doesn't support redo"
-          end
-
-          def compile(expression)
-            prepare
-            @loop.init.compile(compiler, false) if @loop.init?
-            @start.call
-            compiler.method.block do
-              @loop.pre.compile(compiler, false) if @loop.pre?
-              compile_body
-              @loop.post.compile(compiler, false) if @loop.post?
-            end
-            if @end_check
-              @end_check.call
-              compiler.method.puts ';'
-            end
-            if expression
-              compiler.method.puts "#{compiler.lvalue}null;"
-            end
-          end
-
-          def compile_body
-            loop.body.compile(compiler, false) if loop.body
-          end
-
-          def prepare
-            predicate = loop.condition.predicate.precompile(compiler)
-            negative = loop.negative ? '!' : ''
-            check = lambda do
-              compiler.method.print "while (#{negative}"
-              predicate.compile(compiler, true)
-              compiler.method.print ')'
-            end
-            if loop.check_first
-              @start = check
-            else
-              @start = lambda {compiler.method.print 'do'}
-              @end_check = check
-            end
-          end
-        end
-
-        module Redoable
-          def compile_with_redo(block)
-            @redo = compiler.method.tmp(JVMTypes::Boolean)
-            compiler.method.puts "#{@inner}:"
-            compiler.method.block "do" do
-              compiler.method.puts "#{@redo} = false;"
-              block.compile(compiler, false) if block
-            end
-            compiler.method.puts "while (#{@redo});"
-          end
-
-          def break
-            compiler.method.puts "break #{@outer};"
-          end
-
-          def next
-            compiler.method.puts "break #{@inner};"
-          end
-
-          def redo
-            compiler.method.puts "#{@redo} = true;"
-            compiler.method.puts "continue #{@inner};"
-          end
-        end
-
-        class ComplexWhileLoop < SimpleWhileLoop
-          include Redoable
-          def prepare
-            super
-            @outer = compiler.method.label
-            @inner = compiler.method.label
-            @complex_predicate = !loop.condition.predicate.expr?(compiler)
-            super_start = @start
-            @start = lambda do
-              compiler.method.puts "#{@outer}:"
-              super_start.call
-            end
-          end
-
-          def compile_body
-            if @loop.redo?
-              compile_with_redo(@loop.body)
-            else
-              compiler.method.puts "#{@inner}:"
-              compiler.method.block do
-                loop.body.compile(compiler, false) if loop.body
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/mirah/jvm/source_generator/precompile.rb

@@ -1,210 +0,0 @@
-# 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/ast'
-
-module Mirah::AST
-  class TempValue
-    def initialize(node, compiler=nil, value=nil)
-      if compiler.nil?
-        @tempname = node
-      else
-        @tempname = compiler.temp(node, value)
-        @tempvalue = value || node
-      end
-    end
-
-    def compile(compiler, expression)
-      if expression
-        compiler.method.print @tempname
-      end
-    end
-
-    def reload(compiler)
-      compiler.assign(@tempname, @tempvalue)
-    end
-  end
-
-  class Node
-    def expr?(compiler)
-      true
-    end
-
-    def precompile(compiler)
-      if expr?(compiler)
-        self
-      else
-        temp(compiler)
-      end
-    end
-
-    def temp(compiler, value=nil)
-      TempValue.new(self, compiler, value)
-    end
-  end
-
-  class Body
-    def expr?(compiler)
-      false
-    end
-  end
-
-  class If
-    def expr?(compiler)
-      return false unless condition.predicate.expr?(compiler)
-      return false unless body.nil? || body.expr?(compiler)
-      return false unless self.else.nil? || self.else.expr?(compiler)
-      true
-    end
-  end
-
-  class Loop
-    def expr?(compiler)
-      false
-    end
-
-    def precompile(compiler)
-      compile(compiler, false)
-      temp(compiler, 'null')
-    end
-  end
-
-  class Call
-    def method(compiler=nil)
-      @method ||= begin
-        arg_types = parameters.map {|p| p.inferred_type}
-        target.inferred_type.get_method(name, arg_types)
-      end
-    end
-
-    def expr?(compiler)
-      target.expr?(compiler) &&
-          parameters.all? {|p| p.expr?(compiler)} &&
-          cast || (
-            !method.return_type.kind_of?(Mirah::AST::InlineCode) &&
-            !method.return_type.void?)
-    end
-
-    def precompile_target(compiler)
-      if method.return_type.void? && target.expr?(compiler)
-        TempValue.new(target, compiler)
-      else
-        target.precompile(compiler)
-      end
-    end
-  end
-
-  class FunctionalCall
-    def method(compiler)
-      @method ||= begin
-        arg_types = parameters.map {|p| p.inferred_type}
-        @self_type.get_method(name, arg_types)
-      end
-    end
-
-    def expr?(compiler)
-      parameters.all? {|p| p.expr?(compiler)} &&
-          (cast? || !method(compiler).return_type.void?)
-    end
-  end
-
-  # TODO merge with FunctionalCall logic (almost identical)
-  class Super
-    def method(compiler)
-      @method ||= begin
-        arg_types = parameters.map {|p| p.inferred_type}
-        compiler.self_type.superclass.get_method(name, arg_types)
-      end
-    end
-
-    def expr?(compiler)
-      parameters.all? {|p| p.expr?(compiler)} &&
-          !method(compiler).return_type.void?
-    end
-  end
-
-  class EmtpyArray
-    def expr?(compiler)
-      size.expr?(compiler)
-    end
-  end
-
-  class LocalAssignment
-    def expr?(compiler)
-      compiler.method.local?(name) && value.expr?(compiler)
-    end
-
-    def precompile(compiler)
-      if expr?(compiler)
-        self
-      else
-        compile(compiler, false)
-        TempValue.new(name)
-      end
-    end
-  end
-
-  class ToString
-    def expr?(compiler)
-      body.expr?(compiler)
-    end
-
-    def temp(compiler, value=nil)
-      TempValue.new(body, compiler, value)
-    end
-  end
-
-  class StringConcat
-    def expr?(compiler)
-      children.all? {|x| x.expr?(compiler)}
-    end
-  end
-
-  class Return
-    def expr?(compiler)
-      false
-    end
-  end
-
-  class Raise
-    def expr?(compiler)
-      false
-    end
-  end
-
-  class Rescue
-    def expr?(compiler)
-      false
-    end
-  end
-
-  class Ensure
-    def expr?(compiler)
-      false
-    end
-  end
-
-  class FieldAssignment
-    def expr?(compiler)
-      false
-    end
-  end
-
-  class Colon2
-    def expr?(compiler)
-      true
-    end
-  end
-end

data/lib/mirah/plugin/gwt.rb

@@ -1,189 +0,0 @@
-# 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/jvm/source_generator/builder'
-
-module Mirah::JavaSource
-  class ClassBuilder
-    def build_jsni_method(name, visibility, static, exceptions, type, *args)
-      finish_declaration
-      type ||= Mirah::AST.type(nil, :void)
-      @methods << JsniMethodBuilder.new(self,
-        :name => name,
-        :visibility => visibility,
-        :static => static,
-        :return => type,
-        :args => args,
-        :exceptions => exceptions)
-      @methods[-1]
-    end
-  end
-
-  class JsniMethodBuilder < MethodBuilder
-    include Helper
-
-    attr_accessor :name, :type, :out
-
-    def initialize(cls, options)
-      super(cls, options)
-    end
-
-    # Based on superclass's method.
-    def start
-      print "public#{@static} native #{@typename} #{@name}("
-      @args.each_with_index do |(type, name), i|
-        print ', ' unless i == 0
-        print "#{type.to_source} #{name}"
-      end
-      print ')'
-      unless @exceptions.empty?
-        print ' throws '
-        @exceptions.each_with_index do |exception, i|
-          print ', ' unless i == 0
-          print exception.name
-        end
-      end
-      puts ' /*-{'
-    end
-
-    # Based on superclass's method.
-    def stop
-      puts '}-*/;'
-    end
-  end
-end
-
-module Mirah::JVM::Compiler
-  class Base
-    alias :original_create_method_builder :create_method_builder
-    # arg_types must be an Array
-    def create_method_builder(name, node, static, exceptions, return_type, arg_types)
-      unless node.class == Mirah::AST::JsniMethodDefinition
-        original_create_method_builder(name, node, static, exceptions, return_type, arg_types)
-      else
-        @class.build_jsni_method(name.to_s, node.visibility, static,
-          exceptions, return_type, *arg_types)
-      end
-    end
-  end
-
-  class JavaSource < Base
-    def define_jsni_method(node)
-      base_define_method(node, false) do |method, arg_types|
-        with :method => method do
-          log "Starting new JSNI method #{node.name}"
-          @method.start
-
-          @method.puts node.body.literal.chomp
-
-          log "JSNI method #{node.name} complete!"
-          @method.stop
-        end
-      end
-    end
-  end
-end
-
-module Mirah::AST
-  class JsniMethodDefinition < MethodDefinition
-    def initialize(static, parent, line_number, name, annotations=[], &block)
-      super(parent, line_number, name, annotations, &block)
-      @static = static
-    end
-
-    def compile(compiler, expression)
-      compiler.define_jsni_method(self)
-    end
-
-    def infer(typer, expression)
-      @static ||= scope.static_scope.self_type.meta? unless scope.nil?
-      @defining_class ||= begin
-        static_scope.self_node = :self
-        static_scope.self_type = if static?
-          scope.static_scope.self_type.meta
-        else
-          scope.static_scope.self_type
-        end
-      end
-      resolve_if(typer) do
-        argument_types = typer.infer(arguments, true)
-        if argument_types.all?
-          typer.learn_method_type(defining_class, name, argument_types,
-            signature[:return], signature[:throws])
-        end
-      end
-    end
-
-    # JSNI can't be abstract.
-    def abstract?
-      false
-    end
-
-    def static?
-      @static
-    end
-  end
-
-  defmacro 'def_jsni' do |transformer, fcall, parent|
-    args = fcall.parameters
-
-    unless args.size == 3
-      raise "def_jsni must have 3 arguments."
-    end
-
-    call_node = args[1]
-    if Self === call_node.target
-      is_static = true
-    end
-
-    JsniMethodDefinition.new(is_static,
-      parent,
-      fcall.position,
-      call_node.name,
-      transformer.annotations) do |defn|
-
-      signature = {:return => Mirah::AST.type(nil, args[0].name)}
-      method = call_node.parameters[0]
-
-      unless method.nil?
-        hash_node = method.parameters[0]
-
-        args = Arguments.new(defn, defn.position) do |args_new|
-          arg_list = []
-          hash_node.child_nodes.each_slice(2) do |name, type|
-            position = name.position + type.position
-            name = name.literal
-            type = Mirah::AST.type(nil, type.name)
-            signature[name.intern] = type
-            arg_list.push(RequiredArgument.new(args_new, position, name))
-          end
-          [arg_list, nil, nil, nil]
-        end
-      else
-        args = Arguments.new(defn, defn.position) do |args_new|
-          [nil, nil, nil, nil]
-        end
-      end
-
-      body_node = fcall.parameters[-1]
-
-      [
-        signature,
-        args,
-        body_node
-      ]
-    end
-  end
-end