rubex 0.1 → 0.1.1

data/lib/rubex/ast/expression/self.rb

@@ -0,0 +1,15 @@
+module Rubex
+  module AST
+    module Expression
+      class Self < Base
+        def c_code(local_scope)
+          local_scope.self_name
+        end
+
+        def type
+          Rubex::DataType::RubyObject.new
+        end
+      end
+    end
+  end
+end

data/lib/rubex/ast/expression/size_of.rb

@@ -0,0 +1,22 @@
+module Rubex
+  module AST
+    module Expression
+      # C sizeof operator.
+      class SizeOf < Base
+        def initialize(type, ptr_level)
+          @type, @ptr_level = type, ptr_level
+        end
+
+        def analyse_types(local_scope)
+          @size_of_type = Helpers.determine_dtype @type, @ptr_level
+          @type = DataType::ULInt.new
+          super
+        end
+
+        def c_code(_local_scope)
+          "sizeof(#{@size_of_type})"
+        end
+      end
+    end
+  end
+end

data/lib/rubex/ast/expression/struct_or_union_member_call/element_ref_member_call.rb

@@ -0,0 +1,23 @@
+module Rubex
+  module AST
+    module Expression
+      class ElementRefMemberCall < StructOrUnionMemberCall
+        def analyse_types(local_scope, struct_scope)
+          @command.analyse_types local_scope, struct_scope
+          @type = @command.type
+          @has_temp = @command.has_temp
+          @subexprs = [@command]
+        end
+
+        def generate_evaluation_code(code, local_scope)
+          @command.generate_element_ref_code @expr, code, local_scope
+          @c_code = @command.c_code(local_scope)
+        end
+
+        def c_code(local_scope)
+          @c_code
+        end
+      end
+    end
+  end
+end

data/lib/rubex/ast/expression/to_ruby_object.rb

@@ -0,0 +1,21 @@
+module Rubex
+  module AST
+    module Expression
+      # internal node for converting to ruby object.
+      class ToRubyObject < CoerceObject
+        attr_reader :type
+
+        def initialize(expr)
+          @expr = expr
+          @type = Rubex::DataType::RubyObject.new
+        end
+
+        def c_code(local_scope)
+          t = @expr.type
+          t = t.c_function? || t.alias_type? ? t.type : t
+          t.to_ruby_object(@expr.c_code(local_scope)).to_s
+        end
+      end
+    end
+  end
+end

data/lib/rubex/ast/expression/typecast.rb

@@ -0,0 +1,20 @@
+module Rubex
+  module AST
+    module Expression
+      class Typecast < Base
+        def initialize(dtype, ptr_level)
+          @dtype = dtype
+          @ptr_level = ptr_level
+        end
+
+        def analyse_types(_local_scope)
+          @type = Rubex::Helpers.determine_dtype @dtype, @ptr_level
+        end
+
+        def c_code(_local_scope)
+          "(#{@type})"
+        end
+      end
+    end
+  end
+end

data/lib/rubex/ast/expression/typecast_to.rb

@@ -0,0 +1,10 @@
+module Rubex
+  module AST
+    module Expression
+      # Internal class to typecast from a C type to another C type.
+      class TypecastTo < CoerceObject
+        def initialize(dtype); end
+      end
+    end
+  end
+end

data/lib/rubex/ast/expression/unary.rb

@@ -0,0 +1,37 @@
+require_relative 'unary_base'
+Dir['./lib/rubex/ast/expression/unary_base/*.rb'].each { |f| require f }
+module Rubex
+  module AST
+    module Expression
+      class Unary < Base
+        OP_CLASS_MAP = {
+          '&' => Rubex::AST::Expression::Ampersand,
+          '-' => Rubex::AST::Expression::UnarySub,
+          '!' => Rubex::AST::Expression::UnaryNot,
+          '~' => Rubex::AST::Expression::UnaryBitNot
+        }.freeze
+
+        def initialize(operator, expr)
+          @operator = operator
+          @expr = expr
+        end
+
+        def analyse_types(local_scope)
+          @expr = OP_CLASS_MAP[@operator].new(@expr)
+          @expr.analyse_types local_scope
+          @type = @expr.type
+          super
+        end
+
+        def generate_evaluation_code(code, local_scope)
+          @expr.generate_evaluation_code code, local_scope
+        end
+
+        def c_code(local_scope)
+          code = super
+          code << @expr.c_code(local_scope)
+        end
+      end
+    end
+  end
+end

data/lib/rubex/ast/expression/unary_base.rb

@@ -0,0 +1,24 @@
+module Rubex
+  module AST
+    module Expression
+
+      class UnaryBase < Base
+        def initialize expr
+          @expr = expr
+        end
+
+        def analyse_types local_scope
+          @expr.analyse_types local_scope
+          @expr = @expr.to_ruby_object if @expr.type.object?
+          @type = @expr.type
+          @expr.allocate_temps local_scope
+          @expr.release_temps local_scope
+        end
+
+        def generate_evaluation_code code, local_scope
+          @expr.generate_evaluation_code code, local_scope
+        end
+      end
+    end
+  end
+end

data/lib/rubex/ast/expression/unary_base/ampersand.rb

@@ -0,0 +1,16 @@
+module Rubex
+  module AST
+    module Expression
+      class Ampersand < UnaryBase
+        def analyse_types(local_scope)
+          @expr.analyse_types local_scope
+          @type = DataType::CPtr.new @expr.type
+        end
+
+        def c_code(local_scope)
+          "&#{@expr.c_code(local_scope)}"
+        end
+      end
+    end
+  end
+end

data/lib/rubex/ast/expression/unary_base/unary_bit_not.rb

@@ -0,0 +1,18 @@
+module Rubex
+  module AST
+    module Expression
+      class UnaryBitNot < UnaryBase
+        attr_reader :type
+
+        def c_code(local_scope)
+          code = @expr.c_code(local_scope)
+          if @type.object?
+            "rb_funcall(#{code}, rb_intern(\"~\"), 0)"
+          else
+            "~#{code}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubex/ast/expression/unary_base/unary_not.rb

@@ -0,0 +1,18 @@
+module Rubex
+  module AST
+    module Expression
+      class UnaryNot < UnaryBase
+        attr_reader :type
+
+        def c_code(local_scope)
+          code = @expr.c_code(local_scope)
+          if @type.object?
+            "rb_funcall(#{code}, rb_intern(\"!\"), 0)"
+          else
+            "!#{code}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubex/ast/expression/unary_base/unary_sub.rb

@@ -0,0 +1,18 @@
+module Rubex
+  module AST
+    module Expression
+      class UnarySub < UnaryBase
+        attr_reader :type
+
+        def c_code(local_scope)
+          code = @expr.c_code(local_scope)
+          if @type.object?
+            "rb_funcall(#{code}, rb_intern(\"-\"), 0)"
+          else
+            "-#{code}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubex/ast/node.rb

@@ -1,15 +1,16 @@
+require 'rubex/helpers'
 module Rubex
   module AST
     class Node
       include Rubex::Helpers::Writers
       attr_reader :statements
 
-      def initialize statements
+      def initialize(statements)
         @statements = statements.flatten
       end
 
-      def process_statements target_name, code
-        @scope = Rubex::SymbolTable::Scope::Klass.new 'Object', nil
+      def process_statements(target_name, code)
+        @scope = Rubex::SymbolTable::Scope::Klass.new('Object', nil)
         add_top_statements_to_object_scope
         analyse_statement
         rescan_declarations @scope
@@ -18,11 +19,11 @@ module Rubex
         generate_init_method target_name, code
       end
 
-      def == other
+      def ==(other)
         self.class == other.class
       end
 
-    private
+      private
 
       # Scan all the statements that do not belong to any particular class
       #   (meaning that they belong to Object) and add them to the Object class,
@@ -32,7 +33,7 @@ module Rubex
         combined_statements = []
         @statements.each do |stmt|
           if stmt.is_a?(TopStatement::Klass) || stmt.is_a?(TopStatement::CBindings)
-            if !temp.empty?
+            unless temp.empty?
               object_klass = TopStatement::Klass.new('Object', @scope, temp)
               combined_statements << object_klass
             end
@@ -44,23 +45,24 @@ module Rubex
           end
         end
 
-        if !temp.empty?
+        unless temp.empty?
           combined_statements << TopStatement::Klass.new('Object', @scope, temp)
         end
 
         @statements = combined_statements
       end
 
-      def generate_preamble code
+      def generate_preamble(code)
         code << "#include <ruby.h>\n"
         code << "#include <stdint.h>\n"
         code << "#include <stdbool.h>\n"
         @scope.include_files.each do |name|
-          if name[0] == '<' && name[-1] == '>'
-            code << "#include #{name}\n"
-          else
-            code << "#include \"#{name}\"\n"
-          end
+          code <<
+            if name[0] == '<' && name[-1] == '>'
+              "#include #{name}\n"
+            else
+              "#include \"#{name}\"\n"
+            end
         end
         write_usability_macros code
         @statements.grep(Rubex::AST::TopStatement::Klass).each do |klass|
@@ -73,41 +75,41 @@ module Rubex
         code.nl
       end
 
-      def write_global_variable_declarations code
+      def write_global_variable_declarations(code)
         @statements.each do |stmt|
-          if stmt.is_a?(TopStatement::Klass)
-            stmt.statements.each do |s|
-              if s.is_a?(TopStatement::MethodDef)
-                s.scope.global_entries.each do |g|
-                  code << "static #{g.type} #{g.c_name};"
-                  code.nl
-                end # .each
-              end # if
-            end # .each
-          end # if
-        end # .each
+          next unless stmt.is_a?(TopStatement::Klass)
+          stmt.statements.each do |s|
+            next unless s.is_a?(TopStatement::MethodDef)
+            s.scope.global_entries.each do |g|
+              code << "static #{g.type} #{g.c_name};"
+              code.nl
+            end
+          end
+        end
       end
 
-      def write_user_klasses code
+      def write_user_klasses(code)
         code.nl
         @scope.ruby_class_entries.each do |klass|
-          code << "VALUE #{klass.c_name};"
-          code.nl
+          unless Rubex::DEFAULT_CLASS_MAPPINGS.has_key?(klass.name)
+            code << "VALUE #{klass.c_name};" 
+            code.nl
+          end
         end
       end
 
-      def write_usability_macros code
+      def write_usability_macros(code)
         code.nl
-        code.c_macro Rubex::RUBEX_PREFIX + "INT2BOOL(arg) (arg ? Qtrue : Qfalse)"
+        code.c_macro Rubex::RUBEX_PREFIX + 'INT2BOOL(arg) (arg ? Qtrue : Qfalse)'
         code.nl
       end
 
-      def write_usability_functions code
+      def write_usability_functions(code)
         code.nl
         write_char_2_ruby_str code
       end
 
-      def write_char_2_ruby_str code
+      def write_char_2_ruby_str(code)
         code << "VALUE #{Rubex::C_FUNC_CHAR2RUBYSTR}(char ch);"
         code.nl
         code << "VALUE #{Rubex::C_FUNC_CHAR2RUBYSTR}(char ch)"
@@ -116,27 +118,27 @@ module Rubex
           code << "s[0] = ch;\n"
           code << "s[1] = '\\0';\n"
           code << "return rb_str_new2(s);\n"
-        end        
+        end
       end
 
-      def write_function_declarations code
+      def write_function_declarations(code)
         @statements.each do |stmt|
-          if stmt.is_a?(Rubex::AST::TopStatement::Klass)
-            stmt.scope.ruby_method_entries.each do |entry|
-              code.write_ruby_method_header(
-                type: entry.type.type.to_s, c_name: entry.c_name)
-              code.colon
-            end
+          next unless stmt.is_a?(Rubex::AST::TopStatement::Klass)
+          stmt.scope.ruby_method_entries.each do |entry|
+            code.write_ruby_method_header(
+              type: entry.type.type.to_s, c_name: entry.c_name
+            )
+            code.colon
+          end
 
-            stmt.scope.c_method_entries.each do |entry|
-              if !entry.extern?
-                code.write_c_method_header(
-                  type: entry.type.type.to_s, 
-                  c_name: entry.c_name, 
-                  args: Helpers.create_arg_arrays(entry.type.arg_list))
-                code.colon
-              end
-            end
+          stmt.scope.c_method_entries.each do |entry|
+            next if entry.extern?
+            code.write_c_method_header(
+              type: entry.type.type.to_s,
+              c_name: entry.c_name,
+              args: Helpers.create_arg_arrays(entry.type.arg_list)
+            )
+            code.colon
           end
         end
       end
@@ -150,76 +152,76 @@ module Rubex
 
       def create_symtab_entries_for_top_statements
         @statements.each do |stat|
-          if stat.is_a? Rubex::AST::TopStatement::Klass
-            name = stat.name
-            # The top level scope in Ruby is Object. The Object class's immediate
-            # ancestor is also Object. Hence, it is important to set the class
-            # scope and ancestor scope of Object as Object, and make sure that
-            # the same scope object is used for 'Object' class every single time
-            # throughout the compilation process.
-            if name != 'Object'
-              ancestor_entry = @scope.find(stat.ancestor)
-              if !ancestor_entry && Rubex::DEFAULT_CLASS_MAPPINGS[stat.ancestor]
-                ancestor_c_name = Rubex::DEFAULT_CLASS_MAPPINGS[stat.ancestor]
-                ancestor_scope = object_or_stdlib_klass_scope stat.ancestor
-                @scope.add_ruby_class(name: stat.ancestor, c_name: ancestor_c_name,
-                  scope: @scope, ancestor: nil, extern: true)
-              else
-                ancestor_scope = ancestor_entry&.type&.scope || @scope
-              end
-              klass_scope = Rubex::SymbolTable::Scope::Klass.new(
-                name, ancestor_scope)
+          next unless stat.is_a? Rubex::AST::TopStatement::Klass
+          name = stat.name
+          # The top level scope in Ruby is Object. The Object class's immediate
+          # ancestor is also Object. Hence, it is important to set the class
+          # scope and ancestor scope of Object as Object, and make sure that
+          # the same scope object is used for 'Object' class every single time
+          # throughout the compilation process.
+          if name != 'Object'
+            ancestor_entry = @scope.find(stat.ancestor)
+            if !ancestor_entry && Rubex::DEFAULT_CLASS_MAPPINGS[stat.ancestor]
+              ancestor_c_name = Rubex::DEFAULT_CLASS_MAPPINGS[stat.ancestor]
+              ancestor_scope = object_or_stdlib_klass_scope stat.ancestor
+              @scope.add_ruby_class(name: stat.ancestor, c_name: ancestor_c_name,
+                                    scope: @scope, ancestor: nil, extern: true)
             else
-              ancestor_scope = @scope
-              klass_scope = @scope
+              ancestor_scope = ancestor_entry&.type&.scope || @scope
             end
-            c_name = c_name_for_class name
-
-            @scope.add_ruby_class(name: name, c_name: c_name, scope: klass_scope,
-              ancestor: ancestor_scope, extern: false)
+            klass_scope = Rubex::SymbolTable::Scope::Klass.new(
+              name, ancestor_scope
+            )
+          else
+            ancestor_scope = @scope
+            klass_scope = @scope
           end
+          c_name = c_name_for_class name
+
+          @scope.add_ruby_class(name: name, c_name: c_name, scope: klass_scope,
+                                ancestor: ancestor_scope, extern: false)
         end
       end
 
-      def object_or_stdlib_klass_scope name
-        name != 'Object' ? Rubex::SymbolTable::Scope::Klass.new(name, nil) : 
+      def object_or_stdlib_klass_scope(name)
+        name != 'Object' ? Rubex::SymbolTable::Scope::Klass.new(name, nil) :
           @scope
       end
 
-      def c_name_for_class name
+      def c_name_for_class(name)
         c_name =
-        if Rubex::DEFAULT_CLASS_MAPPINGS.has_key? name
-          Rubex::DEFAULT_CLASS_MAPPINGS[name]
-        else
-          Rubex::RUBY_CLASS_PREFIX + name
-        end
+          if Rubex::DEFAULT_CLASS_MAPPINGS.key? name
+            Rubex::DEFAULT_CLASS_MAPPINGS[name]
+          else
+            Rubex::RUBY_CLASS_PREFIX + name
+          end
 
         c_name
       end
 
-      def rescan_declarations scope
+      def rescan_declarations(_scope)
         @statements.each do |stat|
-          stat.respond_to?(:rescan_declarations) and
+          stat.respond_to?(:rescan_declarations) &&
             stat.rescan_declarations(@scope)
         end
       end
 
-      def generate_code code
+      def generate_code(code)
         @statements.each do |stat|
           stat.generate_code code
         end
       end
 
-      def generate_init_method target_name, code
+      def generate_init_method(target_name, code)
         name = "Init_#{target_name}"
         code.new_line
-        code.write_func_declaration type: "void", c_name: name, args: [], static: false
-        code.write_c_method_header type: "void", c_name: name, args: [], static: false
+        code.write_func_declaration type: 'void', c_name: name, args: [], static: false
+        code.write_c_method_header type: 'void', c_name: name, args: [], static: false
         code.block do
           @statements.each do |top_stmt|
             if top_stmt.is_a?(TopStatement::Klass) && top_stmt.name != 'Object'
               entry = @scope.find top_stmt.name
-              code.declare_variable type: "VALUE", c_name: entry.c_name
+              code.declare_variable type: 'VALUE', c_name: entry.c_name
             end
           end
           code.nl
@@ -235,35 +237,33 @@ module Rubex
             end
 
             # specify allocation method in case of attached class
-            if top_stmt.is_a?(TopStatement::AttachedKlass)
-              entry = top_stmt.entry
-              scope = top_stmt.scope
-              alloc = ""
-              alloc << "rb_define_alloc_func(#{entry.c_name}, "
-              alloc << "#{scope.find(TopStatement::AttachedKlass::ALLOC_FUNC_NAME).c_name});\n"
+            next unless top_stmt.is_a?(TopStatement::AttachedKlass)
+            entry = top_stmt.entry
+            scope = top_stmt.scope
+            alloc = ''
+            alloc << "rb_define_alloc_func(#{entry.c_name}, "
+            alloc << "#{scope.find(TopStatement::AttachedKlass::ALLOC_FUNC_NAME).c_name});\n"
 
-              code << alloc
-            end
+            code << alloc
           end
           code.nl
 
           @statements.each do |top_stmt|
-            if top_stmt.is_a? TopStatement::Klass
-              entry = @scope.find top_stmt.name
-              klass_scope = entry.type.scope
-              klass_scope.ruby_method_entries.each do |meth|
-                if meth.singleton?
-                  code.write_singleton_method klass: entry.c_name,
-                    method_name: meth.name, method_c_name: meth.c_name
-                else
-                  code.write_instance_method klass: entry.c_name, 
-                    method_name: meth.name, method_c_name: meth.c_name
-                end
+            next unless top_stmt.is_a? TopStatement::Klass
+            entry = @scope.find top_stmt.name
+            klass_scope = entry.type.scope
+            klass_scope.ruby_method_entries.each do |meth|
+              if meth.singleton?
+                code.write_singleton_method klass: entry.c_name,
+                                            method_name: meth.name, method_c_name: meth.c_name
+              else
+                code.write_instance_method klass: entry.c_name,
+                                           method_name: meth.name, method_c_name: meth.c_name
               end
             end
           end
         end
       end
-    end # class Node
-  end # module AST
-end # module Rubex
+    end
+  end
+end