RubyGems - duby - Versions diffs - 0.0.2-java - Mend

duby 0.0.2-java

Files changed (77) hide show

data/History.txt +8 -0
data/README.txt +39 -0
data/Rakefile +13 -0
data/bin/duby +9 -0
data/bin/dubyc +9 -0
data/bin/dubyp +9 -0
data/examples/README +16 -0
data/examples/appengine/Rakefile +72 -0
data/examples/appengine/Readme +27 -0
data/examples/appengine/config.ru +7 -0
data/examples/appengine/lib/duby/plugin/datastore.rb +171 -0
data/examples/appengine/src/com/google/appengine/ext/duby/db/Model.duby +132 -0
data/examples/appengine/src/com/ribrdb/DubyApp.duby +28 -0
data/examples/appengine/src/com/ribrdb/list.dhtml +15 -0
data/examples/construction.duby +8 -0
data/examples/edb.duby +3 -0
data/examples/fib.duby +24 -0
data/examples/fields.duby +22 -0
data/examples/fractal.duby +57 -0
data/examples/java_thing.duby +13 -0
data/examples/simple_class.duby +12 -0
data/examples/swing.duby +20 -0
data/examples/tak.duby +15 -0
data/examples/test.edb +9 -0
data/javalib/JRubyParser.jar +0 -0
data/lib/duby.rb +168 -0
data/lib/duby/ast.rb +386 -0
data/lib/duby/ast/call.rb +145 -0
data/lib/duby/ast/class.rb +154 -0
data/lib/duby/ast/flow.rb +332 -0
data/lib/duby/ast/intrinsics.rb +56 -0
data/lib/duby/ast/literal.rb +97 -0
data/lib/duby/ast/local.rb +92 -0
data/lib/duby/ast/method.rb +244 -0
data/lib/duby/ast/structure.rb +62 -0
data/lib/duby/ast/type.rb +93 -0
data/lib/duby/c/compiler.rb +134 -0
data/lib/duby/compiler.rb +282 -0
data/lib/duby/jvm/compiler.rb +766 -0
data/lib/duby/jvm/method_lookup.rb +193 -0
data/lib/duby/jvm/source_compiler.rb +605 -0
data/lib/duby/jvm/source_generator/builder.rb +387 -0
data/lib/duby/jvm/source_generator/loops.rb +110 -0
data/lib/duby/jvm/source_generator/precompile.rb +170 -0
data/lib/duby/jvm/source_generator/typer.rb +11 -0
data/lib/duby/jvm/typer.rb +131 -0
data/lib/duby/jvm/types.rb +331 -0
data/lib/duby/jvm/types/basic_types.rb +19 -0
data/lib/duby/jvm/types/boolean.rb +11 -0
data/lib/duby/jvm/types/enumerable.rb +63 -0
data/lib/duby/jvm/types/factory.rb +155 -0
data/lib/duby/jvm/types/floats.rb +70 -0
data/lib/duby/jvm/types/integers.rb +110 -0
data/lib/duby/jvm/types/intrinsics.rb +230 -0
data/lib/duby/jvm/types/literals.rb +82 -0
data/lib/duby/jvm/types/methods.rb +381 -0
data/lib/duby/jvm/types/number.rb +92 -0
data/lib/duby/nbcompiler.rb +29 -0
data/lib/duby/old/compiler_old.rb +845 -0
data/lib/duby/old/declaration.rb +72 -0
data/lib/duby/old/mapper.rb +72 -0
data/lib/duby/old/signature.rb +52 -0
data/lib/duby/old/typer_old.rb +163 -0
data/lib/duby/plugin/edb.rb +25 -0
data/lib/duby/plugin/java.rb +42 -0
data/lib/duby/plugin/math.rb +84 -0
data/lib/duby/transform.rb +1028 -0
data/lib/duby/typer.rb +369 -0
data/test/TestUser.class +0 -0
data/test/test_ast.rb +391 -0
data/test/test_compilation.rb +98 -0
data/test/test_java_typer.rb +199 -0
data/test/test_javac_compiler.rb +58 -0
data/test/test_jvm_compiler.rb +1770 -0
data/test/test_math_plugin.rb +87 -0
data/test/test_typer.rb +246 -0
metadata +156 -0

data/examples/appengine/src/com/ribrdb/DubyApp.duby ADDED

@@ -0,0 +1,28 @@
+import javax.servlet.http.HttpServlet
+import com.google.appengine.ext.duby.db.Model
+class Post < Model
+  def initialize; end
+  property title, String
+  property body, Text
+end
+class DubyApp < HttpServlet
+  def_edb(list, 'com/ribrdb/list.dhtml')
+  def doGet(request, response)
+    returns :void
+    @posts = Post.all.run
+    response.getWriter.write(list)
+  end
+  def doPost(request, response)
+    post = Post.new
+    post.title = request.getParameter('title')
+    post.body = Text.new(request.getParameter('body'))
+    post.save
+    doGet(request, response)
+  end
+end

data/examples/appengine/src/com/ribrdb/list.dhtml ADDED

@@ -0,0 +1,15 @@
+<title>Posts</title>
+<body>
+  <h1>All Posts:</h1>
+  <% for post in @posts %>
+    <h2><%= post.title %></h2>
+    <p><%= post.body.getValue %></p>
+  <% end %>
+  <hr>
+  <h1>New Post:</h1>
+  <form method=post>
+    Title: <input type=text name=title><br>
+    Body: <textarea name=body></textarea><br>
+    <input type=submit>
+  </form>
+</body>

data/examples/construction.duby ADDED

@@ -0,0 +1,8 @@
+import "java.lang.StringBuffer"
+import "java.util.ArrayList"
+list = ArrayList.new
+sb = StringBuffer.new("Hello")
+sb.append(", world")
+list.add(sb)
+puts list

data/examples/edb.duby ADDED

@@ -0,0 +1,3 @@
+def_edb :render, 'test.edb'
+@message = "Hello"
+puts render

data/examples/fib.duby ADDED

@@ -0,0 +1,24 @@
+import "java.lang.System"
+def fib(a:int)
+  if a < 2
+    a
+  else
+    fib(a - 1) + fib(a - 2)
+  end
+end
+def bench(times:int)
+  while times > 0
+    time_start = System.currentTimeMillis
+    puts "fib(45):"
+    puts fib(45)
+    time_total = System.currentTimeMillis - time_start
+    puts "Total time:"
+    puts time_total
+    times -= 1
+  end
+  nil
+end
+bench 10

data/examples/fields.duby ADDED

@@ -0,0 +1,22 @@
+import 'java.util.ArrayList'
+class Bar
+  def initialize
+    @a = ArrayList
+  end
+  def list=(a:ArrayList)
+    @a = a
+  end
+  def foo
+    puts @a
+  end
+end
+b = Bar.new
+list = ArrayList.new
+list.add('hello')
+list.add('world')
+b.list = list
+b.foo

data/examples/fractal.duby ADDED

@@ -0,0 +1,57 @@
+import java.lang.System
+def run
+  puts "Rendering"
+  y = -39.0
+  while y <= 39.0
+    puts
+    x = -39.0
+    while x <= 39.0
+      i = iterate(x/40.0,y/40.0)
+      if (i == 0)
+        print "*"
+      else
+        print " "
+      end
+      x += 1
+    end
+    y += 1
+  end
+  puts
+end
+def iterate(x:double,y:double)
+  cr = y-0.5
+  ci = x
+  zi = 0.0
+  zr = 0.0
+  i = 0
+  result = 0
+  while true
+    i += 1
+    temp = zr * zi
+    zr2 = zr * zr
+    zi2 = zi * zi
+    zr = zr2 - zi2 + cr
+    zi = temp + temp + ci
+    if (zi2 + zr2 > 16)
+      result = i
+      break
+    end
+    if (i > 1000)
+      result = 0
+      break
+    end
+  end
+  result
+end
+i = 0
+while i < 10
+  start = System.currentTimeMillis
+  run
+  puts "Time: " + (System.currentTimeMillis - start) / 1000.0
+  i += 1
+end

data/examples/java_thing.duby ADDED

@@ -0,0 +1,13 @@
+import "java.lang.System"
+def foo
+  home = System.getProperty "java.home"
+  System.setProperty "hello.world", "something"
+  hello = System.getProperty "hello.world"
+  puts home
+  puts hello
+end
+puts "Hello world!"
+foo

data/examples/simple_class.duby ADDED

@@ -0,0 +1,12 @@
+class Foo
+  def initialize
+    puts 'constructor'
+    @hello = 'Hello, '
+  end
+  def hello(a:string)
+    puts @hello; puts a
+  end
+end
+Foo.new.hello('Duby')

data/examples/swing.duby ADDED

@@ -0,0 +1,20 @@
+import javax.swing.JFrame
+import javax.swing.JButton
+import java.awt.event.ActionListener
+frame = JFrame.new "Welcome to Duby"
+frame.setSize 300, 300
+frame.setVisible true
+button = JButton.new "Press me"
+frame.add button
+frame.show
+class AL; implements ActionListener
+  def initialize; end
+  def actionPerformed(event)
+    JButton(event.getSource).setText "Duby Rocks!"
+  end
+end
+button.addActionListener AL.new

data/examples/tak.duby ADDED

@@ -0,0 +1,15 @@
+def tak(x:fixnum, y:fixnum, z:fixnum)
+  unless y < x
+    z
+  else
+    tak( tak(x-1, y, z),
+         tak(y-1, z, x),
+         tak(z-1, x, y))
+  end
+end
+i = 0
+while i<1000
+  tak(24, 16, 8)
+  i+=1
+end

data/examples/test.edb ADDED

@@ -0,0 +1,9 @@
+<html>
+  <head>
+    <title><%= @message %></title>
+  </head>
+  <body>
+  <h1><%= @message %></h1>
+  </body>
+</html>

data/javalib/JRubyParser.jar ADDED

Binary file

data/lib/duby.rb ADDED

@@ -0,0 +1,168 @@
+require 'fileutils'
+require 'duby/transform'
+require 'duby/ast'
+require 'duby/typer'
+require 'duby/compiler'
+begin
+  require 'bitescript'
+rescue LoadError
+  $: << File.dirname(__FILE__) + '/../../bitescript/lib'
+  require 'bitescript'
+end
+require 'duby/jvm/compiler'
+require 'duby/jvm/typer'
+Dir[File.dirname(__FILE__) + "/duby/plugin/*"].each {|file| require "#{file}" if file =~ /\.rb$/}
+require 'jruby'
+module Duby
+  def self.run(*args)
+    DubyImpl.new.run(*args)
+  end
+  def self.compile(*args)
+    DubyImpl.new.compile(*args)
+  end
+  def self.parse(*args)
+    DubyImpl.new.parse(*args)
+  end
+end
+class DubyImpl
+  def run(*args)
+    ast = parse(*args)
+    main_cls = nil
+    compile_ast(ast) do |outfile, builder|
+      bytes = builder.generate
+      name = builder.class_name.gsub(/\//, '.')
+      cls = JRuby.runtime.jruby_class_loader.define_class(name, bytes.to_java_bytes)
+      proxy_cls = JavaUtilities.get_proxy_class(name)
+      # TODO: using first main; find correct one
+      if proxy_cls.respond_to? :main
+        main_cls ||= proxy_cls
+      end
+    end
+    if main_cls
+      main_cls.main(args.to_java(:string))
+    else
+      puts "No main found"
+    end
+  end
+  def compile(*args)
+    process_flags!(args)
+    expand_files(args).each do |duby_file|
+      if duby_file == '-e'
+        @filename = '-e'
+        next
+      elsif @filename == '-e'
+        ast = parse('-e', duby_file)
+      else
+        ast = parse(duby_file)
+      end
+      exit 1 if @error
+      compile_ast(ast) do |filename, builder|
+        filename = "#{@dest}#{filename}"
+        FileUtils.mkdir_p(File.dirname(filename))
+        bytes = builder.generate
+        File.open(filename, 'w') {|f| f.write(bytes)}
+      end
+      @filename = nil
+    end
+  end
+  def parse(*args)
+    process_flags!(args)
+    @filename = args.shift
+    if @filename == '-e'
+      @filename = 'dash_e'
+      src = args[0]
+    else
+      src = File.read(@filename)
+    end
+    Duby::AST.type_factory = Duby::JVM::Types::TypeFactory.new(@filename)
+    ast = Duby::AST.parse_ruby(src, @filename)
+    @transformer = Duby::Transform::Transformer.new
+    ast = @transformer.transform(ast, nil)
+    @transformer.errors.each do |ex|
+      raise ex.cause || ex if @verbose
+      puts "#@filename:#{ex.position.start_line+1}: #{ex.message}"
+    end
+    @error = @transformer.errors.size > 0
+    ast
+  end
+  def compile_ast(ast, &block)
+    typer = Duby::Typer::JVM.new(@filename, @transformer)
+    typer.infer(ast)
+    begin
+      typer.resolve(true)
+    ensure
+      typer.errors.each do |ex|
+        puts ex.message
+        puts ex.backtrace if @verbose
+      end
+    end
+    compiler = @compiler_class.new(@filename)
+    ast.compile(compiler, false)
+    compiler.generate(&block)
+  end
+  def process_flags!(args)
+    while args.length > 0
+      case args[0]
+      when '-V'
+        Duby::Typer.verbose = true
+        Duby::AST.verbose = true
+        Duby::Compiler::JVM.verbose = true
+        @verbose = true
+        args.shift
+      when '-java'
+        require 'duby/jvm/source_compiler'
+        @compiler_class = Duby::Compiler::JavaSource
+        args.shift
+      when '-d'
+        args.shift
+        @dest = File.join(args.shift, '')
+      when '-p'
+        args.shift
+        plugin = args.shift
+        require "duby/plugin/#{plugin}"
+      when '-I'
+        args.shift
+        $: << args.shift
+      else
+        break
+      end
+    end
+    @compiler_class ||= Duby::Compiler::JVM
+  end
+  def expand_files(files)
+    expanded = []
+    files.each do |filename|
+      if File.directory?(filename)
+        Dir[File.join(filename, '*')].each do |child|
+          if File.directory?(child)
+            files << child
+          elsif child =~ /\.duby$/
+            expanded << child
+          end
+        end
+      else
+        expanded << filename
+      end
+    end
+    expanded
+  end
+end
+if __FILE__ == $0
+  Duby.run(ARGV[0], *ARGV[1..-1])
+end

data/lib/duby/ast.rb ADDED

@@ -0,0 +1,386 @@
+require 'duby/transform'
+module Duby
+  module AST
+    class << self
+      attr_accessor :verbose
+    end
+    # The top of the AST class hierarchy, this represents an abstract AST node.
+    # It provides accessors for _children_, an array of all child nodes,
+    # _parent_, a reference to this node's parent (nil if none), and _newline_,
+    # whether this node represents a new line.
+    class Node
+      attr_accessor :children
+      attr_accessor :parent
+      attr_accessor :position
+      attr_accessor :newline
+      attr_accessor :inferred_type
+      def initialize(parent, position, children = [])
+        @parent = parent
+        @newline = false
+        @inferred_type = nil
+        @resolved = false
+        @position = position
+        if block_given?
+          @children = yield(self) || []
+        else
+          @children = children
+        end
+      end
+      def line_number
+        if @position
+          @position.start_line + 1
+        else
+          0
+        end
+      end
+      def log(message)
+        puts "* [AST] [#{simple_name}] " + message if AST.verbose
+      end
+      def inspect(indent = 0)
+        indent_str = ' ' * indent
+        str = indent_str + to_s
+        children.each do |child|
+          if child
+            if ::Array === child
+              child.each {|ary_child|
+                str << "\n#{ary_child.inspect(indent + 1)}"
+              }
+            elsif ::Hash === child
+              str << "\n#{indent_str} #{child.inspect}"
+            else
+              str << "\n#{child.inspect(indent + 1)}"
+            end
+          end
+        end
+        str
+      end
+      def simple_name
+        self.class.name.split("::")[-1]
+      end
+      def to_s; simple_name; end
+      def [](index) children[index] end
+      def each(&b) children.each(&b) end
+      def resolved!
+        log "#{to_s} resolved!"
+        @resolved = true
+      end
+      def resolved?; @resolved end
+      def resolve_if(typer)
+        unless resolved?
+          @inferred_type = yield
+          @inferred_type ? resolved! : typer.defer(self)
+        end
+        @inferred_type
+      end
+      def self.===(other)
+        super || (other.kind_of?(NodeProxy) && (self === other.__getobj__))
+      end
+    end
+    class ErrorNode < Node
+      def initialize(parent, error)
+        super(parent, error.position)
+        @error = error
+        @inferred_type = TypeReference::ErrorType
+        @resolved = true
+      end
+      def infer(typer)
+      end
+    end
+    module Named
+      attr_accessor :name
+      def to_s
+        "#{super}(#{name})"
+      end
+    end
+    module Typed
+      attr_accessor :type
+    end
+    module Valued
+      include Typed
+      attr_accessor :value
+    end
+    module Literal
+      include Typed
+      attr_accessor :literal
+      def to_s
+        "#{super}(#{literal.inspect})"
+      end
+    end
+    module Scoped
+      def scope
+        @scope ||= begin
+          scope = parent
+          raise "No parent for #{self.class.name} at #{line_number}" if scope.nil?
+          scope = scope.parent until scope.class.include?(Scope)
+          scope
+        end
+      end
+    end
+    module ClassScoped
+      def scope
+        @scope ||= begin
+          scope = parent
+          scope = scope.parent until scope.nil? || ClassDefinition === scope
+          scope
+        end
+      end
+    end
+    module Annotated
+      attr_accessor :annotations
+      def annotation(name)
+        name = name.to_s
+        annotations.find {|a| a.name == name}
+      end
+    end
+    module Scope; end
+    class Colon2 < Node; end
+    class Constant < Node
+      include Named
+      def initialize(parent, position, name)
+        @name = name
+        super(parent, position, [])
+      end
+      def infer(typer)
+        @inferred_type ||= begin
+          typer.type_reference(name, false, true)
+        end
+      end
+    end
+    class Self < Node
+      def infer(typer)
+        @inferred_type ||= typer.self_type
+      end
+    end
+    class VoidType < Node; end
+    class Annotation < Node
+      def initialize(parent, position, klass)
+        super(parent, position)
+        @class = klass
+        @values = []
+      end
+      def name
+        @class.name
+      end
+      def type
+        @class
+      end
+      def []=(name, value)
+        # TODO support annotation arguments
+      end
+    end
+    class TypeReference < Node
+      include Named
+      attr_accessor :array
+      alias array? array
+      attr_accessor :meta
+      alias meta? meta
+      def initialize(name, array = false, meta = false, position=nil)
+        super(nil, position)
+        @name = name
+        @array = array
+        @meta = meta
+      end
+      def to_s
+        "Type(#{name}#{array? ? ' array' : ''}#{meta? ? ' meta' : ''})"
+      end
+      def ==(other)
+        to_s == other.to_s
+      end
+      def eql?(other)
+        self == other
+      end
+      def hash
+        to_s.hash
+      end
+      def is_parent(other)
+        # default behavior now is to disallow any polymorphic types
+        self == other
+      end
+      def compatible?(other)
+        # default behavior is only exact match right now
+        self == other ||
+            error? || other.error? ||
+            unreachable? || other.unreachable?
+      end
+      def iterable?
+        array?
+      end
+      def component_type
+        AST.type(name) if array?
+      end
+      def narrow(other)
+        # only exact match allowed for now, so narrowing is a noop
+        if error? || unreachable?
+          other
+        else
+          self
+        end
+      end
+      def unmeta
+        TypeReference.new(name, array, false)
+      end
+      def meta
+        TypeReference.new(name, array, true)
+      end
+      def error?
+        name == :error
+      end
+      def unreachable?
+        name == :unreachable
+      end
+      def block?
+        name == :block
+      end
+      def primitive?
+        true
+      end
+      NoType = TypeReference.new(:notype)
+      NullType = TypeReference.new(:null)
+      ErrorType = TypeReference.new(:error)
+      UnreachableType = TypeReference.new(:unreachable)
+      BlockType = TypeReference.new(:block)
+    end
+    class TypeDefinition < TypeReference
+      attr_accessor :superclass, :interfaces
+      def initialize(name, superclass, interfaces)
+        super(name, false)
+        @superclass = superclass
+        @interfaces = interfaces
+      end
+    end
+    def self.type_factory
+      Thread.current[:ast_type_factory]
+    end
+    def self.type_factory=(factory)
+      Thread.current[:ast_type_factory] = factory
+    end
+    # Shortcut method to construct type references
+    def self.type(typesym, array = false, meta = false)
+      factory = type_factory
+      if factory
+        factory.type(typesym, array, meta)
+      else
+        TypeReference.new(typesym, array, meta)
+      end
+    end
+    def self.no_type
+      factory = type_factory
+      if factory
+        factory.no_type
+      else
+        TypeReference::NoType
+      end
+    end
+    def self.error_type
+      TypeReference::ErrorType
+    end
+    def self.unreachable_type
+      TypeReference::UnreachableType
+    end
+    def self.block_type
+      TypeReference::BlockType
+    end
+    def self.fixnum(parent, position, literal)
+      factory = type_factory
+      if factory
+        factory.fixnum(parent, position, literal)
+      else
+        Fixnum.new(parent, position, literal)
+      end
+    end
+    def self.float(parent, position, literal)
+      factory = type_factory
+      if factory
+        factory.float(parent, position, literal)
+      else
+        Float.new(parent, position, literal)
+      end
+    end
+    def self.defmacro(name, &block)
+      @macros ||= {}
+      raise "Conflicting macros for #{name}" if @macros[name]
+      @macros[name] = block
+    end
+    def self.macro(name)
+      @macros[name]
+    end
+  end
+end
+require 'duby/ast/local'
+require 'duby/ast/call'
+require 'duby/ast/flow'
+require 'duby/ast/literal'
+require 'duby/ast/method'
+require 'duby/ast/class'
+require 'duby/ast/structure'
+require 'duby/ast/type'
+require 'duby/ast/intrinsics'