rubex 0.1 → 0.1.1

data/lib/rubex/ast/top_statement/method_def.rb

@@ -0,0 +1,110 @@
+module Rubex
+  module AST
+    module TopStatement
+      class MethodDef
+        include Rubex::Helpers::Writers
+        # Ruby name of the method.
+        attr_reader :name
+        # Method arguments. Accessor because arguments need to be modified in
+        # case of auxillary C functions of attach classes.
+        attr_accessor :arg_list
+        # The statments/expressions contained within the method.
+        attr_reader :statements
+        # Symbol Table entry.
+        attr_reader :entry
+        # Instance of Scope::Local for this method.
+        attr_reader :scope
+        # Variable name that identifies 'self'
+        attr_reader :self_name
+
+        def initialize(name, arg_list, statements)
+          @name = name
+          @arg_list = arg_list
+          @statements = statements
+          @self_name = Rubex::ARG_PREFIX + 'self'
+        end
+
+        def analyse_statement(outer_scope)
+          @entry = outer_scope.find @name
+          @scope = @entry.type.scope
+          @scope.type = @entry.type
+          @scope.self_name = @self_name
+          @arg_list = @entry.type.arg_list
+          @statements.each do |stat|
+            stat.analyse_statement @scope
+          end
+        end
+
+        # Option c_function - When set to true, certain code that is not required
+        #   for Ruby methods will be generated too.
+        def generate_code(code, c_function: false)
+          code.block do
+            generate_function_definition code, c_function: c_function
+          end
+        end
+
+        def rescan_declarations(_scope)
+          @statements.each do |stat|
+            stat.respond_to?(:rescan_declarations) &&
+              stat.rescan_declarations(@scope)
+          end
+        end
+
+        private
+
+        def generate_function_definition(code, c_function:)
+          declare_types code, @scope
+          declare_args code unless c_function
+          declare_vars code, @scope
+          declare_carrays code, @scope
+          declare_ruby_objects code, @scope
+          declare_temps code, @scope
+          generate_arg_checking code unless c_function
+          init_args code unless c_function
+          declare_carrays_using_init_var_value code
+          generate_statements code
+        end
+
+        def declare_args(code)
+          @scope.arg_entries.each do |arg|
+            code.declare_variable type: arg.type.to_s, c_name: arg.c_name
+          end
+        end
+
+        def generate_statements(code)
+          @statements.each do |stat|
+            stat.generate_code code, @scope
+          end
+        end
+
+        def init_args(code)
+          @scope.arg_entries.each_with_index do |arg, i|
+            code << arg.c_name + '=' + arg.type.from_ruby_object("argv[#{i}]") + ';'
+            code.nl
+          end
+        end
+
+        def declare_carrays_using_init_var_value(code)
+          @scope.carray_entries.reject do |s|
+            s.type.dimension.is_a?(Rubex::AST::Expression::Literal::Base)
+          end. each do |arr|
+            type = arr.type.type.to_s
+            c_name = arr.c_name
+            dimension = arr.type.dimension.c_code(@scope)
+            value = arr.value.map { |a| a.c_code(@scope) } if arr.value
+            code.declare_carray(type: type, c_name: c_name, dimension: dimension,
+                                value: value)
+          end
+        end
+
+        def generate_arg_checking(code)
+          code << 'if (argc < ' + @scope.arg_entries.size.to_s + ')'
+          code.block do
+            code << %{rb_raise(rb_eArgError, "Need #{@scope.arg_entries.size} args, not %d", argc);\n}
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/rubex/ast/top_statement/method_def/c_function_def.rb

@@ -0,0 +1,26 @@
+module Rubex
+  module AST
+    module TopStatement
+      class CFunctionDef < MethodDef
+        attr_reader :type, :return_ptr_level
+
+        def initialize(type, return_ptr_level, name, arg_list, statements)
+          super(name, arg_list, statements)
+          @type = type
+          @return_ptr_level = return_ptr_level
+        end
+
+        def analyse_statement(outer_scope, extern: false)
+          super(outer_scope)
+        end
+
+        def generate_code(code)
+          code.write_c_method_header(type: @entry.type.type.to_s,
+                                     c_name: @entry.c_name, args: Helpers.create_arg_arrays(@arg_list))
+          super code, c_function: true
+        end
+      end
+
+    end
+  end
+end

data/lib/rubex/ast/top_statement/method_def/ruby_method_def.rb

@@ -0,0 +1,33 @@
+module Rubex
+  module AST
+    module TopStatement
+      class RubyMethodDef < MethodDef
+        attr_reader :singleton
+
+        def initialize(name, arg_list, statements, singleton: false)
+          super(name, arg_list, statements)
+          @singleton = singleton
+        end
+
+        def analyse_statement(local_scope)
+          super
+          @entry.singleton = @singleton
+        end
+
+        def generate_code(code)
+          code.write_ruby_method_header(type: @entry.type.type.to_s,
+                                        c_name: @entry.c_name)
+          super
+        end
+
+        def ==(other)
+          self.class == other.class && @name == other.name &&
+            @c_name == other.c_name && @arg_list == other.arg_list &&
+            @statements == other.statements && @entry == other.entry &&
+            @type == other.type
+        end
+      end
+
+    end
+  end
+end

data/lib/rubex/cli.rb

@@ -0,0 +1,26 @@
+require 'thor'
+module Rubex
+  # Cli for rubex using Thor(http://whatisthor.com/)
+  class Cli < Thor
+    desc 'generate FILE', 'generates directory with name specified in the argument and creates an extconf.rb file which is required for C extensions'
+    option :force, aliases: '-f', desc: 'replace existing files and directories'
+    option :dir, aliases: '-d', desc: 'specify a directory for generating files', type: :string
+    option :install, aliases: '-i', desc: 'automatically run install command after generating Makefile'
+    option :debug, aliases: '-g', desc: 'enable debugging symbols when compiling with GCC'
+    def generate(file)
+      if (force = options[:force])
+        directory = (options[:dir] ? options[:dir].to_s : Dir.pwd) + "/#{Rubex::Compiler.extract_target_name(file)}"
+        STDOUT.puts "Warning! you are about to replace contents in the directory '#{directory}', Are you sure? [Yn] "
+        confirmation = STDIN.gets.chomp
+        force = (confirmation == 'Y')
+      end
+      Rubex::Compiler.compile file, directory: options[:dir], force: force, make: options[:install], debug: options[:debug]
+    end
+
+    desc 'install PATH', 'run "make" utility to generate a shared object file required for C extensions'
+    def install(path)
+      Rubex::Compiler.run_make path
+    end
+
+  end
+end

data/lib/rubex/code_writer.rb

@@ -34,7 +34,7 @@ module Rubex
     end
 
     def write_ruby_method_header type: , c_name:
-      args = [["int", "argc"], ["VALUE*", "argv"], 
+      args = [["int", "argc"], ["VALUE*", "argv"],
         ["VALUE", "#{Rubex::ARG_PREFIX + "self"}"]]
       write_func_prototype type, c_name, args
     end

data/lib/rubex/compiler.rb

@@ -1,64 +1,65 @@
+require 'fileutils'
 module Rubex
   class Compiler
     CONFIG = Rubex::CompilerConfig.new
 
     class << self
-      def compile path, test: false, directory: nil
+      def compile path, test: false, directory: nil, force: false, make: false, debug: false
         tree = ast path, test: test
         target_name = extract_target_name path
         code = generate_code tree, target_name
         ext = extconf target_name, directory: directory
         CONFIG.flush
-        
+        CONFIG.debug = debug
+
         return [tree, code, ext] if test
-        write_files target_name, code, ext, directory: directory
+        write_files target_name, code, ext, directory: directory, force: force
+        full_path = build_path(directory, target_name)
+        load_extconf full_path
+        run_make full_path if make
       end
 
       def ast path, test: false
-        if test
-          parser = Rubex::Parser.new
-          parser.parse(path)
-          parser.do_parse
-        else
-          begin
-            parser = Rubex::Parser.new
-            parser.parse(path)
-            parser.do_parse
-          rescue Racc::ParseError => e
-            error_msg = "\nPARSE ERROR:\n"
-            error_msg << "Line: #{parser.string.split("\n")[parser.lineno-1]}\n"
-            error_msg << "Location: #{parser.location}\n"
-            error_msg << "Error:\n#{e}"
-            STDERR.puts error_msg
-          end
-        end
+        parser = Rubex::Parser.new
+        parser.parse(path)
+        parser.do_parse
+      rescue Racc::ParseError => e
+        raise e if test
+
+        error_msg = "\nPARSE ERROR:\n"
+        error_msg << "Line: #{parser.string.split("\n")[parser.lineno-1]}\n"
+        error_msg << "Location: #{parser.location}\n"
+        error_msg << "Error:\n#{e}"
+        STDERR.puts error_msg
       end
 
       def extconf target_name, directory: nil
-        path = directory ? directory : "#{Dir.pwd}/#{target_name}"
+        path = build_path(directory, target_name)
         extconf = ""
         extconf << "require 'mkmf'\n"
         extconf << "$libs += \" #{CONFIG.link_flags}\"\n"
+        extconf << "$CFLAGS += \" -g \"\n" if CONFIG.debug
         extconf << "create_makefile('#{path}/#{target_name}')\n"
         extconf
       end
 
       def generate_code tree, target_name
         code = Rubex::CodeWriter.new target_name
-        raise "Must be a Rubex::AST::Node, not #{tree.class}" unless 
+        raise "Must be a Rubex::AST::Node, not #{tree.class}" unless
           tree.is_a? Rubex::AST::Node
         tree.process_statements target_name, code
         code
       end
 
       def extract_target_name path
-        File.basename(path).split('.')[0]      
+        File.basename(path).split('.')[0]
       end
 
-      def write_files target_name, code, ext, directory: nil
-        path = directory ? directory : "#{Dir.pwd}/#{target_name}"
-        Dir.mkdir(path) unless directory
-        
+      def write_files target_name, code, ext, directory: nil, force: false
+        path = build_path(directory, target_name)
+        FileUtils.rm_rf(path) if force && Dir.exist?(path)
+        Dir.mkdir(path) unless Dir.exist?(path)
+
         code_file = File.new "#{path}/#{target_name}.c", "w+"
         code_file.puts code.to_s
         code_file.close
@@ -67,6 +68,26 @@ module Rubex
         extconf_file.puts ext
         extconf_file.close
       end
+
+      def load_extconf path
+        Dir.chdir(path) do
+          system("ruby #{path}/extconf.rb")
+        end
+      end
+
+      def run_make path
+        Dir.chdir(path) do
+          system("make -C #{path}")
+        end
+      end
+
+      def build_path directory, target_name
+        directory = (directory ? directory.to_s : Dir.pwd)
+        unless directory.end_with?(target_name)
+          directory += "/#{target_name}"
+        end
+        directory
+      end
     end
   end
-end
+end

data/lib/rubex/compiler_config.rb

@@ -1,7 +1,9 @@
 module Rubex
   class CompilerConfig
+    attr_accessor :debug
+    
     def initialize
-      @links = []  
+      @links = []
     end
 
     def add_link link_str
@@ -16,4 +18,4 @@ module Rubex
       @links = []
     end
   end
-end
+end

data/lib/rubex/constants.rb

@@ -1,7 +1,7 @@
 module Rubex
   RUBEX_PREFIX = "__rubex_"
   GLOBAL_PREFIX = "global_"
-  
+
   TEMP_PREFIX = RUBEX_PREFIX + "temp_"
   RUBY_FUNC_PREFIX = RUBEX_PREFIX + "rb_f_"
   C_FUNC_PREFIX = RUBEX_PREFIX + "c_f_"
@@ -50,75 +50,75 @@ module Rubex
   CUSTOM_TYPES = {}
 
   DEFAULT_CLASS_MAPPINGS = {
-    "Kernel" => "rb_mKernel",
-    "Comparable" => "rb_mComparable",
-    "Enumerable" => "rb_mEnumerable",
-    "Errno" => "rb_mErrno",
-    "FileTest" => "rb_mFileTest",
-    "GC" => "rb_mGC",
-    "Math" => "rb_mMath",
-    "Process" => "rb_mProcess",
-    "WaitReadable" => "rb_mWaitReadable",
-    "WaitWritable" => "rb_mWaitWritable",
-    "BasicObject" => "rb_cBasicObject",
-    "Object" => "rb_cObject",
-    "Array" => "rb_cArray",
-    "Bignum" => "rb_cBignum",
-    "Binding" => "rb_cBinding",
-    "Class" => "rb_cClass",
-    "Cont" => "rb_cCont",
-    "Dir" => "rb_cDir",
-    "Data" => "rb_cData",
-    "FalseClass" => "rb_cFalseClass",
-    "Encoding" => "rb_cEncoding",
-    "Enumerator" => "rb_cEnumerator",
-    "File" => "rb_cFile",
-    "Fixnum" => "rb_cFixnum",
-    "Float" => "rb_cFloat",
-    "Hash" => "rb_cHash",
-    "Integer" => "rb_cInteger",
-    "IO" => "rb_cIO",
-    "Match" => "rb_cMatch",
-    "Method" => "rb_cMethod",
-    "Module" => "rb_cModule",
-    "NameErrorMesg" => "rb_cNameErrorMesg",
-    "NilClass" => "rb_cNilClass",
-    "Numeric" => "rb_cNumeric",
-    "Proc" => "rb_cProc",
-    "Random" => "rb_cRandom",
-    "Range" => "rb_cRange",
-    "Rational" => "rb_cRational",
-    "Complex" => "rb_cComplex",
-    "Regexp" => "rb_cRegexp",
-    "Stat" => "rb_cStat",
-    "String" => "rb_cString",
-    "Struct" => "rb_cStruct",
-    "Symbol" => "rb_cSymbol",
-    "Thread" => "rb_cThread",
-    "Time" => "rb_cTime",
-    "TrueClass" => "rb_cTrueClass",
-    "UnboundMethod" => "rb_cUnboundMethod",
-    "Exception" => "rb_eException",
-    "StandardError" => "rb_eStandardError",
-    "SystemExit" => "rb_eSystemExit",
-    "Interrupt" => "rb_eInterrupt",
-    "Signal" => "rb_eSignal",
-    "Fatal" => "rb_eFatal",
-    "ArgumentError" => "rb_eArgError",
-    "EOFError" => "rb_eEOFError",
-    "IndexError" => "rb_eIndexError",
-    "StopIteration" => "rb_eStopIteration",
-    "KeyError" => "rb_eKeyError",
-    "RangeError" => "rb_eRangeError",
-    "IOError" => "rb_eIOError",
-    "RuntimeError" => "rb_eRuntimeError",
-    "SecurityError" => "rb_eSecurityError",
-    "SystemCallError" => "rb_eSystemCallError",
-    "ThreadError" => "rb_eThreadError",
-    "TypeError" => "rb_eTypeError",
-    "ZeroDivError" => "rb_eZeroDivError",
-    "NotImpError" => "rb_eNotImpError",
-    "NoMemError" => "rb_eNoMemError",
+    "Kernel"           => "rb_mKernel",
+    "Comparable"       => "rb_mComparable",
+    "Enumerable"       => "rb_mEnumerable",
+    "Errno"            => "rb_mErrno",
+    "FileTest"         => "rb_mFileTest",
+    "GC"               => "rb_mGC",
+    "Math"             => "rb_mMath",
+    "Process"          => "rb_mProcess",
+    "WaitReadable"     => "rb_mWaitReadable",
+    "WaitWritable"     => "rb_mWaitWritable",
+    "BasicObject"      => "rb_cBasicObject",
+    "Object"           => "rb_cObject",
+    "Array"            => "rb_cArray",
+    "Bignum"           => "rb_cBignum",
+    "Binding"          => "rb_cBinding",
+    "Class"            => "rb_cClass",
+    "Cont"             => "rb_cCont",
+    "Dir"              => "rb_cDir",
+    "Data"             => "rb_cData",
+    "FalseClass"       => "rb_cFalseClass",
+    "Encoding"         => "rb_cEncoding",
+    "Enumerator"       => "rb_cEnumerator",
+    "File"             => "rb_cFile",
+    "Fixnum"           => "rb_cFixnum",
+    "Float"            => "rb_cFloat",
+    "Hash"             => "rb_cHash",
+    "Integer"          => "rb_cInteger",
+    "IO"               => "rb_cIO",
+    "Match"            => "rb_cMatch",
+    "Method"           => "rb_cMethod",
+    "Module"           => "rb_cModule",
+    "NameErrorMesg"    => "rb_cNameErrorMesg",
+    "NilClass"         => "rb_cNilClass",
+    "Numeric"          => "rb_cNumeric",
+    "Proc"             => "rb_cProc",
+    "Random"           => "rb_cRandom",
+    "Range"            => "rb_cRange",
+    "Rational"         => "rb_cRational",
+    "Complex"          => "rb_cComplex",
+    "Regexp"           => "rb_cRegexp",
+    "Stat"             => "rb_cStat",
+    "String"           => "rb_cString",
+    "Struct"           => "rb_cStruct",
+    "Symbol"           => "rb_cSymbol",
+    "Thread"           => "rb_cThread",
+    "Time"             => "rb_cTime",
+    "TrueClass"        => "rb_cTrueClass",
+    "UnboundMethod"    => "rb_cUnboundMethod",
+    "Exception"        => "rb_eException",
+    "StandardError"    => "rb_eStandardError",
+    "SystemExit"       => "rb_eSystemExit",
+    "Interrupt"        => "rb_eInterrupt",
+    "Signal"           => "rb_eSignal",
+    "Fatal"            => "rb_eFatal",
+    "ArgumentError"    => "rb_eArgError",
+    "EOFError"         => "rb_eEOFError",
+    "IndexError"       => "rb_eIndexError",
+    "StopIteration"    => "rb_eStopIteration",
+    "KeyError"         => "rb_eKeyError",
+    "RangeError"       => "rb_eRangeError",
+    "IOError"          => "rb_eIOError",
+    "RuntimeError"     => "rb_eRuntimeError",
+    "SecurityError"    => "rb_eSecurityError",
+    "SystemCallError"  => "rb_eSystemCallError",
+    "ThreadError"      => "rb_eThreadError",
+    "TypeError"        => "rb_eTypeError",
+    "ZeroDivError"     => "rb_eZeroDivError",
+    "NotImpError"      => "rb_eNotImpError",
+    "NoMemError"       => "rb_eNoMemError",
     "NoMethodError"    => "rb_eNoMethodError",
     "FloatDomainError" => "rb_eFloatDomainError",
     "LocalJumpError"   => "rb_eLocalJumpError",
@@ -138,7 +138,7 @@ module Rubex
 
   C_MACRO_INT2BOOL = Rubex::RUBEX_PREFIX + "INT2BOOL"
   C_FUNC_CHAR2RUBYSTR = Rubex::RUBEX_PREFIX + "char2rubystr"
-  
+
   ALLOC_FUNC_NAME      = 'allocate'
   DEALLOC_FUNC_NAME    = 'deallocate'
   MEMCOUNT_FUNC_NAME   = 'memcount'