rubex 0.1 → 0.1.1

data/lib/rubex/data_type/u_l_int/size_t.rb

@@ -0,0 +1,10 @@
+module Rubex
+  module DataType
+    class Size_t < ULInt
+      def to_s
+        'size_t'
+      end
+    end
+
+  end
+end

data/lib/rubex/data_type/u_l_l_int.rb

@@ -0,0 +1,26 @@
+module Rubex
+  module DataType
+    class ULLInt
+      include UIntHelpers
+      def to_s
+        'unsigned long long int'
+      end
+
+      def to_ruby_object(arg)
+        "ULL2NUM(#{arg})"
+      end
+
+      def from_ruby_object(arg)
+        "NUM2ULL(#{arg})"
+      end
+
+      def ullint?
+        true
+      end
+
+      def p_formatter
+        '%llu'
+      end
+    end
+  end
+end

data/lib/rubex/data_type/void.rb

@@ -0,0 +1,15 @@
+module Rubex
+  module DataType
+    class Void
+      include Helpers
+
+      def void?
+        true
+      end
+
+      def to_s
+        'void'
+      end
+    end
+  end
+end

data/lib/rubex/data_type_helpers/float_helpers.rb

@@ -0,0 +1,8 @@
+module Rubex
+  module DataType
+    module FloatHelpers
+      include Helpers
+    end
+
+  end
+end

data/lib/rubex/data_type_helpers/helpers.rb

@@ -0,0 +1,48 @@
+module Rubex
+  module DataType
+    # Citations
+    #   Printf arguments:
+    #     http://www.thinkage.ca/english/gcos/expl/c/lib/printf.html
+    module Helpers
+      include ::Comparable
+      %i[
+    float? float32? float64?
+    int? int8? int16? int32? int64?
+    uint? uint8? uint16? uint32? uint64?
+    lint? ulint? llint? ullint?
+    char? object? bool? carray? cbool?
+    cptr? nil_type? struct_or_union?
+    alias_type? string? cstr? ruby_class?
+    ruby_method? c_function? ruby_constant? void?
+    ruby_string? uchar? ruby_array? ruby_hash?
+  ].each do |dtype|
+        define_method(dtype) { return false }
+      end
+
+      def ==(other)
+        self.class == other.class
+      end
+
+      def to_ruby_object(arg)
+        arg
+      end
+
+      def from_ruby_object(arg)
+        arg
+      end
+
+      def base_type
+        self
+      end
+
+      # Helper function to know if a dtype is a char pointer.
+      def char_ptr?
+        cptr? && base_type.char?
+      end
+
+      def c_function_ptr?
+        cptr? && base_type.c_function?
+      end
+    end
+  end
+end

data/lib/rubex/data_type_helpers/int_helpers.rb

@@ -0,0 +1,10 @@
+module Rubex
+  module DataType
+    module IntHelpers
+      include Helpers
+      def to_ruby_object(arg)
+        "INT2NUM(#{arg})"
+      end
+    end
+  end
+end

data/lib/rubex/data_type_helpers/u_int_helpers.rb

@@ -0,0 +1,11 @@
+module Rubex
+  module DataType
+    module UIntHelpers
+      include Helpers
+      def to_ruby_object(arg)
+        "UINT2NUM(#{arg})"
+      end
+    end
+
+  end
+end

data/lib/rubex/helpers.rb

@@ -1,154 +1,71 @@
+require 'rubex/ast'
+require_relative 'helpers/writers'
+require_relative 'helpers/node_type_methods'
+
 module Rubex
   module Helpers
     class << self
-      def to_lhs_type lhs, rhs
+      def construct_function_argument(data)
+        if data[:variables][0][:ident].is_a?(Hash)
+          Rubex::AST::Expression::FuncPtrArgDeclaration.new(data)
+        else
+          Rubex::AST::Expression::ArgDeclaration.new(data)
+        end
+      end
+
+      def to_lhs_type(lhs, rhs)
         if lhs.type.object?
-          return rhs.to_ruby_object
+          rhs.to_ruby_object
         elsif !lhs.type.object? && rhs.type.object?
-          return rhs.from_ruby_object(lhs)
+          rhs.from_ruby_object(lhs)
         else
-          return rhs
-        end  
+          rhs
+        end
       end
 
-      def result_type_for left, right
-        begin
-          return left.dup if left == right
-          return (left < right ? right.dup : left.dup)
-        rescue ArgumentError => e
-          raise Rubex::TypeError, e.to_s
-        end
+      def result_type_for(left, right)
+        return left.dup if left == right
+
+        (left < right ? right.dup : left.dup)
+      rescue ArgumentError => e
+        raise Rubex::TypeError, e.to_s
       end
 
-      def determine_dtype data, ptr_level
-        if ptr_level && ptr_level[-1] == "*"
+      def determine_dtype(data, ptr_level)
+        if ptr_level && ptr_level[-1] == '*'
           ptr_level = ptr_level.dup
           base_type = Rubex::DataType::CPtr.new simple_dtype(data)
           ptr_level.chop!
 
-          ptr_level.each_char do |star|
+          ptr_level.each_char do |_star|
             base_type = Rubex::DataType::CPtr.new base_type
           end
 
-          return base_type
+          base_type
         else
-          return simple_dtype(data)
+          simple_dtype(data)
         end
       end
 
-      def simple_dtype dtype
+      def simple_dtype(dtype)
         if dtype.is_a?(Rubex::DataType::CFunction)
           dtype
         else
           begin
-            Rubex::CUSTOM_TYPES[dtype] || Rubex::TYPE_MAPPINGS[dtype].new  
-          rescue
+            Rubex::CUSTOM_TYPES[dtype] || Rubex::TYPE_MAPPINGS[dtype].new
+          rescue StandardError
             raise Rubex::TypeError, "Type #{dtype} not previously declared."
-          end          
+          end
         end
       end
 
-      def create_arg_arrays arg_list
-        arg_list.inject([]) do |array, arg|
+      def create_arg_arrays(arg_list)
+        arg_list.each_with_object([]) do |arg, array|
           entry = arg.entry
-          c_name = entry.type.base_type.c_function? ? "" : entry.c_name
+          c_name = entry.type.base_type.c_function? ? '' : entry.c_name
           array << [entry.type.to_s, c_name]
-          array
-        end
-      end
-    end
-
-    module Writers
-      def declare_temps code, scope
-        scope.temp_entries.each do |var|
-          code.declare_variable type: var.type.to_s, c_name: var.c_name
-        end  
-      end
-
-      def declare_vars code, scope
-        scope.var_entries.each do |var|
-          if var.type.base_type.c_function?
-            code.declare_func_ptr var: var
-          else
-            code.declare_variable type: var.type.to_s, c_name: var.c_name
-          end
-        end
-      end
-
-      def declare_carrays code, scope
-        scope.carray_entries.select { |s|
-          s.type.dimension.is_a? Rubex::AST::Expression::Literal::Base
-        }. 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 declare_types code, scope
-        scope.type_entries.each do |entry|
-          # if !entry.extern
-            type = entry.type
-
-            if type.alias_type?
-              base = type.old_type
-              if base.respond_to?(:base_type) && base.base_type.c_function?
-                func = base.base_type
-                str = "typedef #{func.type} (#{type.old_type.ptr_level} #{type.new_type})"
-                str << "(" + func.arg_list.map { |e| e.type.to_s }.join(',') + ")"
-                str << ";"
-                code << str
-              else
-                code << "typedef #{type.old_type} #{type.new_type};"
-              end
-            elsif type.struct_or_union? && !entry.extern?
-              code << sue_header(entry)
-              code.block(sue_footer(entry)) do
-                declare_vars code, type.scope
-                declare_carrays code, type.scope
-                declare_ruby_objects code, type.scope
-              end
-            end
-            code.nl
-          # end
-        end
-      end
-
-      def sue_header entry
-        type = entry.type
-        str = "#{type.kind} #{type.name}"
-        if !entry.extern
-          str.prepend "typedef "
-        end
-
-        str
-      end
-
-      def sue_footer entry
-        str =
-        if entry.extern
-          ";"
-        else
-          " #{entry.type.c_name};"
-        end
-
-        str
-      end
-
-      def declare_ruby_objects code, scope
-        scope.ruby_obj_entries.each do |var|
-          code.declare_variable type: var.type.to_s, c_name: var.c_name
-        end
-      end
-    end
-
-    module NodeTypeMethods
-      [:expression?, :statement?, :literal?, :ruby_method?].each do |meth|
-        define_method(meth) { false }
-      end
     end
   end
 end

data/lib/rubex/helpers/node_type_methods.rb

@@ -0,0 +1,9 @@
+module Rubex
+  module Helpers
+    module NodeTypeMethods
+      [:expression?, :statement?, :literal?, :ruby_method?].each do |meth|
+        define_method(meth) { false }
+      end
+    end
+  end
+end

data/lib/rubex/helpers/writers.rb

@@ -0,0 +1,79 @@
+module Rubex
+  module Helpers
+    module Writers
+      def declare_temps(code, scope)
+        scope.temp_entries.each do |var|
+          code.declare_variable type: var.type.to_s, c_name: var.c_name
+        end
+      end
+
+      def declare_vars(code, scope)
+        scope.var_entries.each do |var|
+          if var.type.base_type.c_function?
+            code.declare_func_ptr var: var
+          else
+            code.declare_variable type: var.type.to_s, c_name: var.c_name
+          end
+        end
+      end
+
+      def declare_carrays(code, scope)
+        scope.carray_entries.select 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 declare_types(code, scope)
+        scope.type_entries.each do |entry|
+          # if !entry.extern
+          type = entry.type
+
+          if type.alias_type?
+            base = type.old_type
+            if base.respond_to?(:base_type) && base.base_type.c_function?
+              func = base.base_type
+              str = "typedef #{func.type} (#{type.old_type.ptr_level} #{type.new_type})"
+              str << '(' + func.arg_list.map { |e| e.type.to_s }.join(',') + ')'
+              str << ';'
+              code << str
+            else
+              code << "typedef #{type.old_type} #{type.new_type};"
+            end
+          elsif type.struct_or_union? && !entry.extern?
+            code << sue_header(entry)
+            code.block(sue_footer(entry)) do
+              declare_vars code, type.scope
+              declare_carrays code, type.scope
+              declare_ruby_objects code, type.scope
+            end
+          end
+          code.nl
+          # end
+        end
+      end
+
+      def sue_header(entry)
+        type = entry.type
+        str = "#{type.kind} #{type.name}"
+        str.prepend 'typedef ' unless entry.extern
+        str
+      end
+
+      def sue_footer(entry)
+        entry.extern ? ';' : " #{entry.type.c_name};"
+      end
+
+      def declare_ruby_objects(code, scope)
+        scope.ruby_obj_entries.each do |var|
+          code.declare_variable type: var.type.to_s, c_name: var.c_name
+        end
+      end
+    end
+  end
+end

data/lib/rubex/parser.racc

@@ -133,10 +133,10 @@ rule
 
   c_func_args:
     { result = [] }
-  | c_func_normal_arg { result = [Expression::ArgDeclaration.new(val[0])] }
+  | c_func_normal_arg { result = [construct_function_argument(val[0])] }
   | c_func_args tCOMMA c_func_normal_arg
       { 
-        result = [*val[0], Expression::ArgDeclaration.new(val[2])] 
+        result = [*val[0], construct_function_argument(val[2])] 
       }
 
   opt_c_func_arg_list:
@@ -144,7 +144,7 @@ rule
   | tLPAREN c_func_args tRPAREN
       { 
         # self is a compulsory implicit argument for C methods.
-        val[1] << Expression::ArgDeclaration.new(
+        val[1] << construct_function_argument(
             { dtype: 'object', variables: [ {ident: 'self' }] })
         result = Statement::ArgumentList.new(val[1])
       }
@@ -209,6 +209,8 @@ rule
       }
   | dtype opt_star tLPAREN opt_star opt_identifier tRPAREN opt_c_func_arg_list
       {
+        force_into_func_ptr_internal_args(val[6])
+        
         result = {
           dtype: val[0],
           variables: [
@@ -245,7 +247,7 @@ rule
         if val[4].empty? # since last arg of cfunc must be self.
           val[4] = Statement::ArgumentList.new(
             [
-              Expression::ArgDeclaration.new(
+              construct_function_argument(
                 { dtype: 'object', variables: [ { ident: 'self' }] }
               )
             ]
@@ -311,19 +313,19 @@ rule
       {
         result = Statement::While.new val[1], val[3], location
       }
-  | op_assign {}
+  | op_assign {result = val[0]}
   | struct_or_union_def
   | forward_declaration
   | alias_stmt
   | expr { result = Statement::Expression.new(val[0], location) }
   | kRAISE opt_lparen command_arg_list opt_rparen
       { 
-        result = Statement::Raise.new(Statement::ActualArgList.new(val[2]))
+        result = Statement::Raise.new(Expression::ActualArgList.new(val[2]))
       }
   | kBREAK { result = Statement::Break.new(location) }
   | kYIELD opt_lparen command_arg_list opt_rparen
       {
-        result = Statement::Yield.new(Statement::ActualArgList.new(val[2]))
+        result = Statement::Yield.new(Expression::ActualArgList.new(val[2]))
       }
   | begin_block
 
@@ -431,6 +433,7 @@ rule
         result = {}
 
         if val[5] # function (pointer) decl
+          force_into_func_ptr_internal_args(val[5])          
           result[:ptr_level] = val[2]
           result[:ident] = {
             :return_ptr_level => val[0],
@@ -446,7 +449,8 @@ rule
       {
         result = {}
 
-        if !val[2].empty?
+        if !val[2].empty? # function pointer
+          force_into_func_ptr_internal_args(val[5])
           result[:ptr_level] = val[0]
           result[:ident] = {
             :name => val[1],
@@ -491,7 +495,7 @@ rule
   | method_or_attr tASSIGN expr
     {
       result = {
-        name: Expression::CommandCall.new(val[0][0], val[0][1], []),
+        name: Expression::CommandCall.new(val[0][0], val[0][1], Expression::ActualArgList.new([])),
         value: val[2]
       }
     }
@@ -535,11 +539,11 @@ rule
   f_args:
     f_normal_arg 
       { 
-        result = [Expression::ArgDeclaration.new(val[0])] 
+        result = [construct_function_argument(val[0])] 
       }
   | f_args tCOMMA f_normal_arg
       {
-        result = [*val[0], Expression::ArgDeclaration.new(val[2])]
+        result = [*val[0], construct_function_argument(val[2])]
       }
 
   f_normal_arg:
@@ -579,8 +583,8 @@ rule
         val[1].typecast = val[0]
         result = val[1]
       }
-  | expr    tANDOP    expr  { result = binary_op val }
-  | expr    tOROP     expr  { result = binary_op val }
+  | expr    tANDOP    expr  { result = Expression::BinaryBoolAnd.new(val[0], val[1], val[2]) }
+  | expr    tOROP     expr  { result = Expression::BinaryBoolOr.new(val[0], val[1], val[2]) }
 
   typecast:
     tLT dtype opt_star tGT { result = Expression::Typecast.new(val[1], val[2]) }
@@ -592,17 +596,17 @@ rule
   | tLPAREN expr      tRPAREN    { result = val[1] }
 
   expr_value:
-    expr_value tPLUS       expr_value { result = binary_op val }
-  | expr_value tMINUS      expr_value { result = binary_op val }
-  | expr_value tSTAR       expr_value { result = binary_op val }
-  | expr_value tDIVIDE     expr_value { result = binary_op val }
-  | expr_value tEXPO       expr_value { result = binary_op val }
-  | expr_value tMODULUS    expr_value { result = binary_op val }
-  | expr_value tBIT_AND    expr_value { result = binary_op val }
-  | expr_value tBIT_OR     expr_value { result = binary_op val }
-  | expr_value tBIT_XOR    expr_value { result = binary_op val }
-  | expr_value tBIT_LSHIFT expr_value { result = binary_op val }
-  | expr_value tBIT_RSHIFT expr_value { result = binary_op val }
+    expr_value tPLUS       expr_value { result = Expression::BinaryAdd.new(val[0], val[1], val[2]) }
+  | expr_value tMINUS      expr_value { result = Expression::BinaryMinus.new(val[0], val[1], val[2]) }
+  | expr_value tSTAR       expr_value { result = Expression::BinaryMultiply.new(val[0], val[1], val[2]) }
+  | expr_value tDIVIDE     expr_value { result = Expression::BinaryDivide.new(val[0], val[1], val[2]) }
+  | expr_value tEXPO       expr_value { result = Expression::BinaryExpo.new(val[0], val[1], val[2]) }
+  | expr_value tMODULUS    expr_value { result = Expression::BinaryMod.new(val[0], val[1], val[2]) }
+  | expr_value tBIT_AND    expr_value { result = Expression::BinaryAnd.new(val[0], val[1], val[2]) }
+  | expr_value tBIT_OR     expr_value { result = Expression::BinaryOr.new(val[0], val[1], val[2]) }
+  | expr_value tBIT_XOR    expr_value { result = Expression::BinaryXor.new(val[0], val[1], val[2]) }
+  | expr_value tBIT_LSHIFT expr_value { result = Expression::BinaryLShift.new(val[0], val[1], val[2]) }
+  | expr_value tBIT_RSHIFT expr_value { result = Expression::BinaryRShift.new(val[0], val[1], val[2]) }
   | tMINUS     expr_value  =UMINUS    { result = unary_op val  }
   | tBIT_AND   expr_value  =ADDRESS_OF{ result = unary_op val  }
   | tBIT_NOT   expr_value             { result = unary_op val  } 
@@ -610,12 +614,12 @@ rule
   | atomic_value {}
 
   expr_cmp:
-    expr_value tEQ       expr_value { result = binary_op val }
-  | expr_value tNEQ      expr_value { result = binary_op val }
-  | expr_value tLT       expr_value { result = binary_op val }
-  | expr_value tLTEQ     expr_value { result = binary_op val }
-  | expr_value tGT       expr_value { result = binary_op val }
-  | expr_value tGTEQ     expr_value { result = binary_op val }
+    expr_value tEQ       expr_value { result = Expression::BinaryBoolEq.new(val[0], val[1], val[2]) }
+  | expr_value tNEQ      expr_value { result = Expression::BinaryBoolNEq.new(val[0], val[1], val[2]) }
+  | expr_value tLT       expr_value { result = Expression::BinaryBoolLt.new(val[0], val[1], val[2]) }
+  | expr_value tLTEQ     expr_value { result = Expression::BinaryBoolLtEq.new(val[0], val[1], val[2]) }
+  | expr_value tGT       expr_value { result = Expression::BinaryBoolGt.new(val[0], val[1], val[2]) }
+  | expr_value tGTEQ     expr_value { result = Expression::BinaryBoolGtEq.new(val[0], val[1], val[2]) }
   | tLPAREN    expr_cmp  tRPAREN    { result = val[1] }
 
   atomic_value:
@@ -660,8 +664,8 @@ rule
     }
 
   command_opt_args:
-    { result = [] }
-  | tLPAREN command_arg_list tRPAREN { result = val[1] }
+    { result = Expression::ActualArgList.new([]) }
+  | tLPAREN command_arg_list tRPAREN { result = Expression::ActualArgList.new(val[1]) }
 
   command_arg_list:
     { result = [] }
@@ -724,8 +728,10 @@ end
 ---- header
 require_relative 'lexer.rex.rb'
 require_relative 'ast.rb'
+require_relative 'helpers.rb'
 
 include Rubex::AST
+include Rubex::Helpers
 
 ---- inner
 
@@ -867,6 +873,10 @@ def check_for_primitive_dtype token
   token
 end
 
+def construct_function_argument data
+  Rubex::Helpers.construct_function_argument data
+end
+
 def binary_op val
   Expression::Binary.new val[0], val[1], val[2]
 end
@@ -877,7 +887,40 @@ end
 
 # expr, op_assign, expr => expr = expr op expr
 def op_assign val
-  Statement::Assign.new(val[0], binary_op([val[0], val[1][0], val[2]]), location)
+  left = val[0]
+  right = val[2]
+  operator = val[1][0]
+  
+  expression =
+    case operator
+    when '+'
+      Expression::BinaryAdd.new(left, operator, right)
+    when '-'
+      Expression::BinaryMinus.new(left, operator, right)
+    when '*'
+      Expression::BinaryMultiply.new(left, operator, right)
+    when '/'
+      Expression::BinaryDivide.new(left, operator, right)
+    when '**'
+      Expression::BinaryExpo.new(left, operator, right)
+    when '%'
+      Expression::BinaryMod.new(left, operator, right)
+    when '&'
+      Expression::BinaryAnd.new(left, operator, right)
+    when '|'
+      Expression::BinaryOr.new(left, operator, right)
+    when '<<'
+      Expression::BinaryLShift.new(left, operator, right)
+    when '>>'
+      Expression::BinaryRShift.new(left, operator, right)
+    when '^'
+      Expression::BinaryXor.new(left, operator, right)
+    else
+      raise "Cannot identify operator #{operator}"
+    end
+
+  
+   Statement::Assign.new(left.dup, expression, location)
 end
 
 def variable_decl_nodes val
@@ -891,7 +934,7 @@ def variable_decl_nodes val
     statement =
     if ident.is_a?(Hash) # only if function pointer
       dtype = { dtype: type, ident: ident }
-      Statement::CPtrDecl.new(dtype, ident[:name], var[:value], ptr_level,
+      Statement::CPtrFuncDecl.new(dtype, ident[:name], var[:value], ptr_level,
         location)
     else
       if ptr_level
@@ -913,3 +956,9 @@ end
 def add_dtype_to_lexer dtype
   @custom_dtypes[dtype] = true
 end
+
+def force_into_func_ptr_internal_args data
+  data.map! do |arg|
+    Expression::FuncPtrInternalArgDeclaration.new(arg.data_hash)
+  end 
+end