duby 0.0.1

data/lib/duby/ast/type.rb

@@ -0,0 +1,93 @@
+module Duby::AST
+  class Import < Node
+    attr_accessor :short
+    attr_accessor :long
+    def initialize(parent, line_number, short, long)
+      @short = short
+      @long = long
+      super(parent, line_number, [])
+      Duby::AST.type_factory.alias(short, long) if Duby::AST.type_factory
+    end
+
+    def to_s
+      "Import(#{short} = #{long})"
+    end
+
+    def infer(typer)
+      # add both the meta and non-meta imports
+      typer.alias_types(short, long)
+      typer.no_type
+    end
+  end
+
+  defmacro('import') do |transformer, fcall, parent|
+    args_node = fcall.args_node
+    case args_node
+    when JRubyAst::ArrayNode
+      case args_node.size
+      when 1
+        node = args_node.get(0)
+        case node
+        when JRubyAst::StrNode
+          long = node.value
+          short = long[(long.rindex('.') + 1)..-1]
+        when JRubyAst::CallNode
+          case node.args_node.size
+          when 0
+            pieces = [node.name]
+            while node.kind_of? JRubyAst::CallNode
+              node = node.receiver_node
+              pieces << node.name
+            end
+            long = pieces.reverse.join '.'
+            short = pieces[0]
+          when 1
+            arg = node.args_node.get(0)
+            unless (JRubyAst::FCallNode === arg &&
+                    arg.name == 'as' && arg.args_node.size == 1)
+              raise Duby::TransformError.new("unknown import syntax", args_node)
+            end
+            short = arg.args_node.get(0).name
+            pieces = [node.name]
+            while node.kind_of? JRubyAst::CallNode
+              node = node.receiver_node
+              pieces << node.name
+            end
+            long = pieces.reverse.join '.'
+          else
+            raise Duby::TransformError.new("unknown import syntax", args_node)
+          end
+        else
+          raise Duby::TransformError.new("unknown import syntax", args_node)
+        end
+      when 2
+        short = args_node.child_nodes[0].value
+        long = args_node.child_nodes[1].value
+      else
+        raise Duby::TransformError.new("unknown import syntax", args_node)
+      end
+    else
+      raise Duby::TransformError.new("unknown import syntax", args_node)
+    end
+    Import.new(parent, fcall.position, short, long)
+  end
+
+  class EmptyArray < Node
+    attr_accessor :size
+    attr_accessor :component_type
+    def initialize(parent, line_number, type, &block)
+      super(parent, line_number, [])
+      @component_type = type
+      @size = size
+      @inferred_type = Duby::AST::type(type.name, true)
+
+      @size = yield(self)
+    end
+
+    def infer(typer)
+      typer.infer(size)
+      resolved!
+      return @inferred_type
+    end
+  end
+end

data/lib/duby/c/compiler.rb

@@ -0,0 +1,134 @@
+require 'duby'
+require 'duby/compiler'
+
+module Duby
+  module Compiler
+    class C
+      class MathCompiler
+        def call(compiler, call)
+          call.target.compile(compiler)
+
+          compiler.src << " #{call.name} "
+
+          call.parameters.each {|param| param.compile(compiler)}
+        end
+      end
+      
+      attr_accessor :filename, :src
+
+      def initialize(filename)
+        @filename = filename
+        @src = ""
+        
+        self.type_mapper[AST::TypeReference.new(:fixnum)] = "int"
+        
+        self.call_compilers[AST::TypeReference.new(:fixnum)] = MathCompiler.new
+      end
+
+      def compile(ast)
+        ast.compile(self)
+      end
+
+      def define_main(body)
+        old_src, @src = @src, "int main(int argc, char **argv)\n{\n"
+
+        body.compile(self)
+
+        @src << "}\n\n"
+
+        @src = old_src + @src
+      end
+      
+      def define_method(name, signature, args, body)
+        old_src, @src =  @src, "#{type_mapper[signature[:return]]} #{name}("
+        
+        args.compile(self)
+        
+        @src << ")\n{\n"
+        
+        body.compile(self)
+        
+        @src << "\n}\n\n"
+
+        @src = old_src + @src
+      end
+      
+      def declare_argument(name, type)
+        @src << "#{type_mapper[type]} #{name}"
+      end
+      
+      def branch(iff)
+        @src << "if ("
+        
+        iff.condition.compile(self)
+        
+        @src << ") {"
+        
+        iff.body.compile(self)
+        
+        if iff.else
+          @src << "} else {"
+          
+          iff.else.compile(self)
+        end
+        
+        @src << "}"
+      end
+      
+      def call(call)
+        call_compilers[call.target.inferred_type].call(self, call)
+      end
+      
+      def call_compilers
+        @call_compilers ||= {}
+      end
+      
+      def self_call(fcall)
+        @src << "#{fcall.name}("
+        
+        fcall.parameters.each {|param| param.compile(self)}
+        
+        @src << ")"
+      end
+      
+      def local(name, type)
+        @src << name
+      end
+      
+      def fixnum(value)
+        @src << value.to_s
+      end
+      
+      def newline
+        @src << ";\n"
+      end
+      
+      def ret
+        @src << "return "
+        
+        yield
+      end
+      
+      def generate
+        @src
+      end
+      
+      def type_mapper
+        @type_mapper ||= {}
+      end
+    end
+  end
+end
+
+if __FILE__ == $0
+  ast = Duby::AST.parse(File.read(ARGV[0]))
+  
+  typer = Duby::Typer::Simple.new(:script)
+  ast.infer(typer)
+  typer.resolve(true)
+  
+  compiler = Duby::Compiler::C.new("#{ARGV[0]}.c")
+  ast.compile(compiler)
+  
+  File.open(compiler.filename, "w") {|file| file.write(compiler.generate)}
+end

data/lib/duby/compiler.rb

@@ -0,0 +1,261 @@
+require 'duby'
+
+module Duby
+  module AST
+    class Fixnum
+      def compile(compiler, expression)
+        if expression
+          compiler.line(line_number)
+          compiler.fixnum(literal)
+        end
+      end
+    end
+    
+    class String
+      def compile(compiler, expression)
+        if expression
+          compiler.line(line_number)
+          compiler.string(literal)
+        end
+      end
+    end
+    
+    class Float
+      def compile(compiler, expression)
+        if expression
+          compiler.line(line_number)
+          compiler.float(literal)
+        end
+      end
+    end
+    
+    class Boolean
+      def compile(compiler, expression)
+        if expression
+          compiler.line(line_number)
+          compiler.boolean(literal)
+        end
+      end
+    end
+    
+    class Body
+      def compile(compiler, expression)
+        compiler.line(line_number)
+        compiler.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)
+          compiler.local(name, inferred_type)
+        end
+      end
+    end
+
+    class LocalDeclaration
+      def compile(compiler, expression)
+        compiler.line(line_number)
+        compiler.local_declare(name, type)
+      end
+    end
+    
+    class LocalAssignment
+      def compile(compiler, expression)
+        compiler.line(line_number)
+        compiler.local_assign(name, inferred_type, expression, value)
+      end
+    end
+    
+    class Script
+      def compile(compiler, expression)
+        # TODO: what does it mean for a script to be an expression? possible?
+        compiler.define_main(body)
+      end
+    end
+    
+    class MethodDefinition
+      def compile(compiler, expression)
+        # TODO: what does it mean for a method to be an expression?
+        compiler.define_method(name, signature, arguments, body, static?)
+      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 WhileLoop
+      def compile(compiler, expression)
+        compiler.line(line_number)
+        compiler.while_loop(self, expression)
+      end
+    end
+    
+    class ForLoop
+      def compile(compiler, expression)
+        compiler.line(line_number)
+        compiler.for_loop(self, expression)
+      end
+    end
+
+    class ClassDefinition
+      def compile(compiler, expression)
+        compiler.define_class(self, expression)
+      end
+    end
+
+    class FieldDeclaration
+      def compile(compiler, expression)
+        compiler.field_declare(name, inferred_type)
+      end
+    end
+
+    class FieldAssignment
+      def compile(compiler, expression)
+        compiler.line(line_number)
+        compiler.field_assign(name, inferred_type, expression, value)
+      end
+    end
+
+    class Field
+      def compile(compiler, expression)
+        compiler.line(line_number)
+        if expression
+          compiler.field(name, inferred_type)
+        end
+      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
+  end
+end