rubex 0.0.1 → 0.1

data/lib/rubex/code_writer.rb

@@ -4,64 +4,141 @@ module Rubex
 
     def initialize target_name
       @code = "/* C extension for #{target_name}.\n"\
-                 "This file in generated by Rubex. Do not change!\n"\
-               "*/\n"
+                 "This file in generated by Rubex::Compiler. Do not change!\n"\
+                 "File generation time: #{Time.now}."\
+               "*/\n\n"
       @indent = 0
     end
 
-    def write_func_declaration return_type, c_name, args=""
-      write_func_prototype return_type, c_name, args
+    # type - Return type of the method.
+    # c_name - C Name.
+    # args - Array of Arrays containing data type and variable name.
+    def write_func_declaration type:, c_name:, args: [], static: true
+      write_func_prototype type, c_name, args, static: static
       @code << ";"
       new_line
     end
 
-    def write_func_definition_header return_type, c_name, args=""
-      write_func_prototype return_type, c_name, args
-      @code << "\n"
-      @code << "{\n"
+    def colon
+      @code << ";"
+      new_line
+    end
+
+    def c_macro macro
+      @code << "#define #{macro}"
+      new_line
+    end
+
+    def write_c_method_header type: , c_name: , args: [], static: true
+      write_func_prototype type, c_name, args, static: static
+    end
+
+    def write_ruby_method_header type: , c_name:
+      args = [["int", "argc"], ["VALUE*", "argv"], 
+        ["VALUE", "#{Rubex::ARG_PREFIX + "self"}"]]
+      write_func_prototype type, c_name, args
+    end
+
+    def write_location location
+      new_line
+      self << "/* Rubex file location: #{location} */"
+      new_line
+    end
+
+    def declare_variable type:, c_name:
+      @code << " "*@indent + "#{type} #{c_name};"
+      new_line
+    end
+
+    def declare_func_ptr var:
+      type = var.type
+      func = type.base_type
+      @code << " "*@indent
+      @code << "#{func.type.to_s} (#{type.ptr_level}#{func.c_name}) "
+      @code << "(" + func.arg_list.map { |e| e.type.to_s }.join(',') + ")"
+      @code << ";"
+      nl
     end
 
-    def declare_variable var
-      @code << "#{var.type.to_s} #{var.c_name};\n"
+    def declare_carray type:, c_name:, dimension:, value: nil
+      stmt = "#{type} #{c_name}[#{dimension}]"
+      stmt << " = {" + value.join(',') + "}" if value
+      stmt << ";"
+      self << stmt
+      nl
     end
-    
-    def << s
-      @code << s
+
+    def init_variable lhs: , rhs:
+      stat = " "*@indent + "#{lhs} = #{rhs};"
+      @code << stat
+      new_line
+    end
+
+    def << str
+      str.each_line do |s|
+        @code << " "*@indent
+        @code << s
+      end
     end
 
     def new_line
       @code << "\n"
     end
+    alias :nl :new_line
 
     def indent
-      @indent += 1
+      @indent += 2
     end
 
     def dedent
       raise "Cannot dedent, already 0." if @indent == 0
-      @indent -= 1
+      @indent -= 2
     end
 
-    def define_instance_method_under scope, name, c_name
-      @code << "rb_define_method(" + scope.c_name + " ,\"" + name + "\", " + 
-        c_name + ", -1);\n"
+    def write_instance_method klass: , method_name: , method_c_name:
+      @code << " "*@indent + "rb_define_method(" + klass + " ,\"" +
+        method_name + "\", " + method_c_name + ", -1);"
+      new_line
+    end
+
+    def write_singleton_method klass:, method_name:, method_c_name:
+      @code << " "*@indent + "rb_define_singleton_method(" + klass + " ,\"" +
+        method_name + "\", " + method_c_name + ", -1);"
+      new_line
     end
 
     def to_s
       @code
     end
 
+    def lbrace
+      @code << (" "*@indent + "{")
+    end
+
+    def rbrace
+      @code << (" "*@indent + "}")
+    end
+
+    def block str="", &block
+      new_line
+      lbrace
+      indent
+      new_line
+      block.call
+      dedent
+      rbrace
+      @code << str
+      new_line
+      new_line
+    end
+
   private
 
-    def write_func_prototype return_type, c_name, args
-      @code << "#{return_type} #{c_name} "
+    def write_func_prototype return_type, c_name, args, static: true
+      @code << "#{static ? "static " : ""}#{return_type} #{c_name} "
       @code << "("
-      if args.empty?
-        @code << "int argc, VALUE* argv, VALUE #{Rubex::ARG_PREFIX}self"
-      else
-        @code << args
-      end
-      @code << ")"      
+      @code << args.map { |type_arg| type_arg.join(" ") }.join(",")
+      @code << ")"
     end
   end
 end

data/lib/rubex/compiler.rb

@@ -0,0 +1,72 @@
+module Rubex
+  class Compiler
+    CONFIG = Rubex::CompilerConfig.new
+
+    class << self
+      def compile path, test: false, directory: nil
+        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
+        
+        return [tree, code, ext] if test
+        write_files target_name, code, ext, directory: directory
+      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
+      end
+
+      def extconf target_name, directory: nil
+        path = directory ? directory : "#{Dir.pwd}/#{target_name}"
+        extconf = ""
+        extconf << "require 'mkmf'\n"
+        extconf << "$libs += \" #{CONFIG.link_flags}\"\n"
+        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 
+          tree.is_a? Rubex::AST::Node
+        tree.process_statements target_name, code
+        code
+      end
+
+      def extract_target_name path
+        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
+        
+        code_file = File.new "#{path}/#{target_name}.c", "w+"
+        code_file.puts code.to_s
+        code_file.close
+
+        extconf_file = File.new "#{path}/extconf.rb", "w+"
+        extconf_file.puts ext
+        extconf_file.close
+      end
+    end
+  end
+end

data/lib/rubex/compiler_config.rb

@@ -0,0 +1,19 @@
+module Rubex
+  class CompilerConfig
+    def initialize
+      @links = []  
+    end
+
+    def add_link link_str
+      @links << link_str
+    end
+
+    def link_flags
+      @links.map { |l| l.dup.prepend('-l') }.join(' ')
+    end
+
+    def flush
+      @links = []
+    end
+  end
+end

data/lib/rubex/constants.rb

@@ -1,17 +1,154 @@
 module Rubex
   RUBEX_PREFIX = "__rubex_"
-
-  FUNC_PREFIX = RUBEX_PREFIX + "f_"
+  GLOBAL_PREFIX = "global_"
+  
+  TEMP_PREFIX = RUBEX_PREFIX + "temp_"
+  RUBY_FUNC_PREFIX = RUBEX_PREFIX + "rb_f_"
+  C_FUNC_PREFIX = RUBEX_PREFIX + "c_f_"
   VAR_PREFIX  = RUBEX_PREFIX + "v_"
-  CLASS_PREFIX = RUBEX_PREFIX + "c_"
+  RUBY_CLASS_PREFIX = RUBEX_PREFIX + "rb_cls_"
+  ATTACH_CLASS_PREFIX = RUBEX_PREFIX + "attach_rb_cls"
   ARG_PREFIX = RUBEX_PREFIX + "arg_"
+  ARRAY_PREFIX = RUBEX_PREFIX + "arr_"
+  POINTER_PREFIX = RUBEX_PREFIX + "ptr_"
+  TYPE_PREFIX   = RUBEX_PREFIX + "t_"
+
+  ACTUAL_ARGS_SUFFIX = "_actual_args"
 
   TYPE_MAPPINGS = {
-    'i32' => Rubex::DataType::CInt32,
-    'object' => Rubex::DataType::RubyObject
+    'char'                   => Rubex::DataType::Char,
+    'bool'                   => Rubex::DataType::CBoolean,
+    'unsigned char'          => Rubex::DataType::UChar,
+    'i8'                     => Rubex::DataType::Int8,
+    'i16'                    => Rubex::DataType::Int16,
+    'i32'                    => Rubex::DataType::Int32,
+    'i64'                    => Rubex::DataType::Int64,
+    'u8'                     => Rubex::DataType::UInt8,
+    'u16'                    => Rubex::DataType::UInt16,
+    'u32'                    => Rubex::DataType::UInt32,
+    'u64'                    => Rubex::DataType::UInt64,
+    'int'                    => Rubex::DataType::Int,
+    'unsigned int'           => Rubex::DataType::UInt,
+    'long int'               => Rubex::DataType::LInt,
+    'long'                   => Rubex::DataType::LInt,
+    'unsigned long int'      => Rubex::DataType::ULInt,
+    'long long int'          => Rubex::DataType::LLInt,
+    'long long'              => Rubex::DataType::LLInt,
+    'unsigned long long int' => Rubex::DataType::ULLInt,
+    'f32'                    => Rubex::DataType::F32,
+    'float'                  => Rubex::DataType::F32,
+    'f64'                    => Rubex::DataType::F64,
+    'double'                 => Rubex::DataType::F64,
+    'object'                 => Rubex::DataType::RubyObject,
+    'void'                   => Rubex::DataType::Void,
+    'size_t'                 => Rubex::DataType::Size_t,
+    'str'                    => Rubex::DataType::RubyString,
+    'arr'                    => Rubex::DataType::RubyArray,
+    'hsh'                    => Rubex::DataType::RubyHash
+  }
+
+  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",
+    "NoMethodError"    => "rb_eNoMethodError",
+    "FloatDomainError" => "rb_eFloatDomainError",
+    "LocalJumpError"   => "rb_eLocalJumpError",
+    "SysStackError"    => "rb_eSysStackError",
+    "RegexpError"      => "rb_eRegexpError",
+    "EncodingError"    => "rb_eEncodingError",
+    "EncCompatError"   => "rb_eEncCompatError",
+    "ScriptError"      => "rb_eScriptError",
+    "NameError"        => "rb_eNameError",
+    "SyntaxError"      => "rb_eSyntaxError",
+    "LoadError"        => "rb_eLoadError",
+    "MathDomainError"  => "rb_eMathDomainError",
+    "STDIN"            => "rb_stdin",
+    "STDOUT"           => "rb_stdout",
+    "STDERR"           => "rb_stderr",
   }
 
-  CLASS_MAPPINGS = {
-    'Object' => 'rb_cObject'
+  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'
+  GET_STRUCT_FUNC_NAME = 'get_struct'
+
+  # Maps regexes to the type of the variable for conversion from literal
+  # to the correct type of Ruby object.
+  LITERAL_MAPPINGS = {
+    /'.\'/       => Rubex::DataType::Char,
+    /-?\d+/      => Rubex::DataType::Int,
+    /-?\d+\.\d+/ => Rubex::DataType::F64
   }
-end
+end

data/lib/rubex/data_type.rb

@@ -1,15 +1,678 @@
 module Rubex
   module DataType
+    # Citations
+    #   Printf arguments:
+    #     http://www.thinkage.ca/english/gcos/expl/c/lib/printf.html
+    module Helpers
+      include ::Comparable
+      [
+        :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?
+        if self.cptr? && self.base_type.char?
+          true
+        else
+          false
+        end
+      end
+
+      def c_function_ptr?
+        if self.cptr? && self.base_type.c_function?
+          true
+        else
+          false
+        end
+      end
+    end
+
+    module IntHelpers
+      include Helpers
+      def to_ruby_object(arg); "INT2NUM(#{arg})"; end
+    end
+
+    module UIntHelpers
+      include Helpers
+      def to_ruby_object(arg); "UINT2NUM(#{arg})"; end
+    end
+
+    module FloatHelpers
+      include Helpers
+    end
+
+    class Void
+      include Helpers
+
+      def void?; true; end
+
+      def to_s; "void"; end
+    end
+
     class RubyObject
+      include Helpers
       def to_s; "VALUE"; end
+
+      def object?; true; end
+
+      def p_formatter; "%s"; end
+    end
+
+    class RubySymbol < RubyObject
+      def ruby_symbol?; true; end
+    end
+
+    class RubyString < RubyObject
+      def ruby_string?; true; end
+    end
+
+    class RubyArray < RubyObject
+      def ruby_array?; true; end
+    end
+
+    class RubyHash < RubyObject
+      def ruby_hash?; true; end
+    end
+
+    class Char
+      include Helpers
+      def to_s; "char";  end
+
+      def to_ruby_object(arg, literal=false)
+        "#{Rubex::C_FUNC_CHAR2RUBYSTR}(#{arg})"
+      end
+
+      def from_ruby_object(arg); "(char)NUM2INT(#{arg})"; end
+
+      def p_formatter; "%c"; end
+
+      def char?; true; end
+
+      def <=> other
+        if other.char?
+          return 0
+        else
+          return 1
+        end
+      end
+    end
+
+    class UChar
+      include Helpers
+
+      def to_s; "unsigned char"; end
+
+      def from_ruby_object(arg); "(unsigned char)NUM2INT(#{arg})"; end
+
+      def p_formatter; "%d"; end
+
+      def uchar?; true; end
+
+      def <=> other
+        if other.char? || other.uchar?
+          return 0
+        else
+          return 1
+        end
+      end
+    end
+
+    class Int8
+      include IntHelpers
+
+      def to_s; "int8_t"; end
+
+      def from_ruby_object(arg); "(int8_t)NUM2INT(#{arg})"; end
+
+      def int8?; true; end
+
+      def p_formatter; "%d"; end
+
+      def <=> other
+        if other.char?
+          return 1
+        elsif other.int8?
+          return 0
+        else
+          return -1
+        end
+      end
+    end
+
+    class Int16
+      include IntHelpers
+      def to_s; "int16_t"; end
+
+      def from_ruby_object(arg); "(int16_t)NUM2INT(#{arg})"; end
+
+      def int16?; true; end
+
+      def p_formatter; "%d"; end
+
+      def <=> other
+        if other.char? || other.int8?
+          return 1
+        elsif other.int16?
+          return 0
+        else
+          return -1
+        end
+      end
     end
 
-    class CInt32
+    class Int32
+      include IntHelpers
       def to_s; "int32_t"; end
 
-      def to_ruby_function; "INT2NUM"; end
+      def from_ruby_object(arg); "(int32_t)NUM2INT(#{arg})"; end
+
+      def int32?; true; end
+
+      def p_formatter; "%d"; end
+
+      def <=> other
+        if other.char? || other.int8? || other.int16?
+          return 1
+        elsif other.int32? || other.int?
+          return 0
+        else
+          return -1
+        end
+      end
+    end
+
+    class Int64
+      include IntHelpers
+      def to_s; "int64_t"; end
+
+      def to_ruby_object(arg); "LONG2NUM(#{arg})"; end
+
+      def from_ruby_object(arg); "(int64_t)NUM2LONG(#{arg})"; end
+
+      def p_formatter; "%ld"; end
+
+      def int64?; true; end
+
+      def <=> other
+        if other.char? || other.int8? || other.int16? || other.int32? ||
+          other.int?
+          return 1
+        elsif other.int64?
+          return 0
+        else
+          return -1
+        end
+      end
+    end
+
+    class UInt8
+      include UIntHelpers
+      def to_s; "uint8_t"; end
+
+      def from_ruby_object(arg); "(uint8_t)NUM2UINT(#{arg})"; end
+
+      def uint8?; true; end
+
+      def p_formatter; "%u"; end
+    end
+
+    class UInt16
+      include UIntHelpers
+      def to_s; "uint16_t"; end
+
+      def from_ruby_object(arg); "(uint16_t)NUM2UINT(#{arg})"; end
+
+      def uint16?; true; end
+
+      def p_formatter; "%u"; end
+    end
+
+    class UInt32
+      include UIntHelpers
+      def to_s; "uint32_t"; end
+
+      def from_ruby_object(arg); "(int32_t)NUM2UINT(#{arg})"; end
+
+      def uint32?; true; end
+
+      def p_formatter; "%u"; end
+    end
+
+    class UInt64
+      include UIntHelpers
+      def to_s; "uint64_t"; end
+
+      def to_ruby_object(arg); "ULONG2NUM(#{arg})"; end
+
+      def from_ruby_object(arg); "(int64_t)NUM2UINT(#{arg})"; end
+
+      def uint64?; true; end
+
+      def p_formatter; "%lu"; end
+    end
+
+    class Int
+      include IntHelpers
+      def to_s; "int"; end
+
+      def from_ruby_object(arg); "NUM2INT(#{arg})"; end
+
+      def int?; true; end
+
+      def p_formatter; "%d"; end
+
+      def <=> other
+        if other.char? || other.int8? || other.int16?
+          return 1
+        elsif other.int? || other.int32?
+          return 0
+        else # other is int64 or greater
+          return -1
+        end
+      end
+    end
+
+    class CBoolean < Int
+      def cbool?; true; end
+
+      def to_ruby_object arg
+        Rubex::C_MACRO_INT2BOOL + "(" + arg + ")"
+      end
+    end
+ 
+    class UInt
+      include UIntHelpers
+      def to_s; "unsigned int"; end
+
+      def from_ruby_object(arg); "(unsigned int)NUM2UINT(#{arg})"; end
+
+      def uint?; true; end
+
+      def p_formatter; "%u"; end
+
+      def <=> other
+        if other.char? || other.int8? || other.int16? || other.uint8? || other.uint16?
+          return 1
+        elsif other.uint? || other.int? || other.int32? || other.uint32?
+          return 0
+        else
+          return -1
+        end
+      end
+    end
+
+    class LInt
+      include IntHelpers
+      def to_s; "long int"; end
 
-      def from_ruby_function; "NUM2INT"; end
+      def to_ruby_object(arg); "LONG2NUM(#{arg})"; end
+
+      def from_ruby_object(arg); "NUM2LONG(#{arg})"; end
+
+      def lint?; true; end
+
+      def p_formatter; "%ld"; end
+
+      def <=> other
+        if other.char? || other.int8? || other.int16? || other.int32? ||
+          other .int64? || other.uint8? || other.uint16? || other.uint32? ||
+          other.int?
+          return 1
+        elsif other.lint?
+          return 0
+        else
+          return -1
+        end
+      end
+    end
+
+    class ULInt
+      include UIntHelpers
+      def to_s; "unsigned long int"; end
+
+      def to_ruby_object(arg); "ULONG2NUM(#{arg})"; end
+
+      def from_ruby_object(arg); "NUM2ULONG(#{arg})"; end
+
+      def ulint?; true; end
+
+      def p_formatter; "%lu"; end
+
+      def <=> other
+        if other.char? || other.int8? || other.int16? || other.int32? ||
+          other .int64? || other.uint8? || other.uint16? || other.uint32? ||
+          other.int?
+          return 1
+        elsif other.ulint?
+          return 0
+        else
+          return -1
+        end
+      end
+    end
+
+    class Size_t < ULInt
+      def to_s
+        "size_t"
+      end
+    end
+
+    class LLInt
+      include IntHelpers
+      def to_s; "long long int"; end
+
+      def to_ruby_object(arg); "LL2NUM(#{arg})"; end
+
+      def from_ruby_object(arg); "NUM2LL(#{arg})"; end
+
+      def llint?; true; end
+
+      def p_formatter; "%ll"; end
+    end
+
+    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
+
+    class F32
+      include FloatHelpers
+      def to_s; "float"; end
+
+      def to_ruby_object(arg); "rb_float_new((double)(#{arg}))"; end
+
+      def from_ruby_object(arg); "(float)NUM2DBL(#{arg})"; end
+
+      def float32?; true; end
+
+      def p_formatter; "%f"; end
+
+      def <=> other
+        if other.char?     || other.int8?   || other.int16? || other.int32? ||
+          other.int64?     || other.int?    || other.uint8? || other.uint16?||
+          other.uint32?    || other.uint64?
+          return 1
+        elsif other.float32?
+          return 0
+        else # other is float64
+          return -1
+        end
+      end
+
+    end
+
+    class F64
+      include FloatHelpers
+      def to_s; "double"; end
+
+      def to_ruby_object(arg); "rb_float_new(#{arg})"; end
+
+      def from_ruby_object(arg); "NUM2DBL(#{arg})"; end
+
+      def float64?; true; end
+
+      def p_formatter; "%f"; end
+
+      def <=> other
+        if other.char? || other.int8?   || other.int16? || other.int32? ||
+          other.int64?     || other.int?    || other.uint8? || other.uint16?||
+          other.uint32?    || other.uint64? || other.float32?
+          return 1
+        elsif other.float64?
+          return 0
+        else
+          return -1
+        end
+      end
+    end
+
+    class CArray
+      include Helpers
+      # Dimension of the array
+      attr_reader :dimension
+      # Type of elements stored in array
+      attr_reader :type # FIXME: Make this base_type to make it more explicit.
+
+      def initialize dimension, type
+        @dimension, @type = dimension, type
+      end
+
+      def carray?; true; end
+
+      def <=> other
+        if self.class == other.class
+          @type <=> other.type
+        else
+          @type <=> other
+        end
+      end
+
+      def base_type
+        @type
+      end
+    end
+
+    class CPtr
+      include Helpers
+      # The data type that this pointer is pointing to.
+      attr_reader :type
+
+      def initialize type
+        @type = type
+      end
+
+      def p_formatter
+        "%s" if char_ptr?  
+      end
+
+      def cptr?; true; end
+
+      def to_s
+        base_type = @type.base_type
+        if base_type.c_function?
+          ptr = ptr_level
+
+          str = "#{base_type.type.to_s} (#{ptr} #{base_type.c_name.to_s})"
+          str << "(" + base_type.arg_list.map { |e| e.type.to_s }.join(',') + ")"
+        else
+          t = @type
+          str = "*"
+          if t.cptr?
+            str << "*"
+            t = t.type
+          end
+          str.prepend t.to_s
+          str
+        end
+      end
+
+      def base_type
+        return @type if !@type.is_a?(self.class)
+        return @type.base_type
+      end
+
+      def ptr_level
+        temp = @type
+        ptr = "*"
+        while temp.cptr?
+          ptr << "*"
+          temp = @type.type
+        end
+
+        ptr
+      end
+
+      # from a Ruby function get a pointer to some value.
+      def from_ruby_object arg
+        return "StringValueCStr(#{arg})" if @type.char?
+        arg
+      end
+
+      def to_ruby_object arg
+        return "rb_str_new2(#{arg})" if @type.char?
+        arg
+      end
+
+      def <=> other
+        return -1
+      end
+    end
+
+    class Boolean < RubyObject
+      include Helpers
+
+      def bool?; true; end
+    end
+
+    class TrueType < Boolean;  end
+
+    class FalseType < Boolean;  end
+
+    class NilType < RubyObject
+      def nil_type?; true; end
+    end
+
+    class CStructOrUnion
+      include Helpers
+      attr_reader :kind, :name, :c_name, :scope
+
+      def initialize kind, name, c_name, scope
+        @kind, @name, @c_name, @scope = kind, name, c_name, scope
+      end
+
+      def struct_or_union?; true; end
+
+      def to_s; "#{@c_name}"; end
     end
+
+    # FIXME: Find out a better way to generically find the old type of a typedef
+    #   when the new type is encountered. Should cover cases where the new type
+    #   is aliased with some other name too. In other words, reach the actual
+    #   type in the most generic way possible without too many checks.
+    class TypeDef
+#      include Helpers
+      attr_reader :type, :old_type, :new_type
+
+      def initialize old_type, new_type, type
+        @old_type, @new_type, @type = old_type, new_type, type
+      end
+
+      def alias_type?; true; end
+
+      def to_s
+        @new_type.to_s
+      end
+
+      def base_type
+        @old_type
+      end
+
+      def method_missing meth, *args, &block
+        @old_type.send(meth, *args, &block)
+      end
+    end
+
+    class CStr
+      include Helpers
+
+      def cstr?; true; end
+      
+      def p_formatter; "%s"; end
+
+      def from_ruby_object arg
+        "StringValueCStr(#{arg})"
+      end
+
+      def to_ruby_object arg
+        "rb_str_new_cstr(#{arg})"
+      end
+    end
+
+    class RubyConstant < RubyObject
+      attr_reader :name, :type
+
+      def initialize name
+        @name = name
+        # FIXME: make this flexible so that consts set to primitive types can be
+        #   easily converted to C types.
+        @type = RubyObject.new 
+      end
+
+      def ruby_constant?; true; end
+    end
+
+    class RubyClass < RubyConstant
+      attr_reader :name, :c_name, :scope, :ancestor
+
+      def initialize name, c_name, scope, ancestor
+        @name, @c_name, @scope, @ancestor = name, c_name, scope, ancestor
+      end
+
+      def ruby_class?; true; end
+    end
+
+    class RubyMethod
+      include Helpers
+
+      attr_reader :name, :c_name, :type
+      attr_accessor :scope, :arg_list
+
+      def initialize name, c_name, scope, arg_list
+        @name, @c_name, @scope, @arg_list = name, c_name, scope, arg_list
+        @type = RubyObject.new
+      end
+
+      def ruby_method?; true; end
+    end
+
+    class CFunction
+      include Helpers
+      attr_reader :name, :type, :c_name
+      attr_accessor :scope, :arg_list
+
+      # FIXME: all attributes should be initialized upon class creation to maintain
+      # sanity and consistency.
+      def initialize name, c_name, arg_list, type, scope
+        @name, @c_name, @arg_list, @type, @scope = name, c_name, arg_list, type, scope
+      end
+
+      def c_function?; true; end
+    end
+    # TODO: How to store this in a Ruby class? Use BigDecimal?
+    # class LF64
+    #   def to_s; "long double"; end
+
+    #   def to_ruby_object(arg); "INT2NUM"; end
+
+    #   def from_ruby_object(arg); "(int32_t)NUM2INT"; end
+    # end
   end
-end
+end