rubex 0.0.1 → 0.1

data/examples/rcsv wrapper/rcsv/ext/rcsv/rcsv.rubex

@@ -0,0 +1,124 @@
+lib "rubex/ruby"; end
+lib "rubex/ruby/encoding"; end
+lib "rubex/stdlib"; end
+
+lib "csv.h", link: "csv"
+  struct csv_parser
+  end
+
+  struct FILE
+  end
+
+  int CSV_STRICT_FINI
+  int CSV_APPEND_NULL
+  int CSV_EPARSE
+  int CSV_ENOMEM
+  int CSV_ETOOBIG
+  int CSV_EINVALID
+  int CSV_STRICT
+
+  int csv_init(csv_parser, unsigned char)
+  int csv_fini(csv_parser, void (*cb1)(void *, size_t, void *), void (*cb2)(int, void *), void *)
+  void csv_free(csv_parser *)
+  int csv_error(csv_parser *)
+  size_t csv_parse(csv_parser *p, void *, size_t, void (*cb1)(void *, size_t, void *), void (*cb2)(int, void *), void *)
+end
+
+struct rcsv_metadata
+  # Internal state
+  bool skip_current_row       # Used by only_rows and except_rows filters to skip parsing of the row remainder
+  size_t current_col          # Current column's index
+  size_t current_row          # Current row's index
+
+  object last_entry           # last entry that's going to be appended to result
+  object result               # parsed data
+end
+
+class RcsvParseError < StandardError
+end
+
+class Rcsv
+  cfunc void end_of_field_callback(void* field, size_t field_size, void* data)
+    char* field_str = <char *>field
+    rcsv_metadata* meta_p = <rcsv_metadata*>data
+    rcsv_metadata meta = meta_p[0]
+    char row_conversion = 0
+    object parsed_field
+
+    parsed_field = ENCODED_STR_NEW(field_str, field_size)
+
+    meta_p[0].last_entry.push(parsed_field) # /* last_entry << field */
+    meta_p[0].current_col += 1
+    return
+  end
+
+  cfunc void end_of_line_callback(int last_char, void* data)
+    rcsv_metadata* meta = <rcsv_metadata *> data
+    
+    meta.result.push(meta.last_entry)
+    meta.last_entry = [] if last_char != -1
+    meta.current_col = 0
+    meta.current_row += 1
+  end
+
+  cfunc object ENCODED_STR_NEW(char* string, int length)
+    return rb_str_new(string, length)
+  end
+
+  cfunc void setup_rcsv_metadata_defaults(rcsv_metadata *p_meta)
+    p_meta.skip_current_row = 0
+    p_meta.current_col = 0
+    p_meta.current_row = 0
+    p_meta.result = []
+  end
+
+  def self.parse(file_name, opts)
+    rcsv_metadata meta
+    object csvio, options, option
+    csv_parser cp
+    ensure_container = []
+    unsigned char csv_options = CSV_STRICT_FINI | CSV_APPEND_NULL
+    int csv_string_len
+
+    setup_rcsv_metadata_defaults(&meta)
+    csvio = StringIO.new(file_name)
+
+    if csv_init(&cp, csv_options) == -1
+      raise(RcsvParseError, "Failed to initialize libcsv.")
+    end
+    meta.last_entry = []
+
+    begin
+      while true do
+        csvstr = csvio.read
+
+        break if csvstr.nil? || csvstr.size == 0
+
+        char* csv_string = csvstr
+        csv_string_len = csvstr.size
+
+        if csv_string_len != csv_parse(&cp, csv_string, csv_string_len, &end_of_field_callback, &end_of_line_callback, &meta)
+          int error = csv_error(&cp)
+
+          if error == CSV_EPARSE
+            raise(RcsvParseError, "Error when parsing malformed data.")
+          elsif error == CSV_ENOMEM
+            raise(RcsvParseError, "No memory.")
+          elsif error == CSV_ETOOBIG
+            raise(RcsvParseError, "Field data data is too large.")
+          elsif error == CSV_EINVALID
+            raise(RcsvParseError)
+          else
+            raise(RcsvParseError, "Something went wrong.")
+          end
+        end
+      end
+
+      csv_fini(&cp, &end_of_field_callback, &end_of_line_callback, &meta)
+    ensure
+      csv_free(&cp) if &cp
+    end
+
+    return meta.result
+  end
+end

data/examples/rcsv wrapper/rcsv/lib/rcsv.rb

@@ -0,0 +1,8 @@
+require 'rcsv.so'
+require 'rcsv/version'
+
+class Rcsv
+  def self.p file_name
+    Rcsv.parse(File.read(file_name), {})
+  end
+end

data/examples/rcsv wrapper/rcsv/lib/rcsv/version.rb

@@ -0,0 +1 @@
+Rcsv::VERSION = "0.1"

data/examples/rcsv wrapper/rcsv/rcsv.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+$:.unshift File.expand_path("../lib", __FILE__)
+
+require 'rcsv/version.rb'
+
+Rcsv::DESCRIPTION = <<MSG
+A Crystal-inspired language for writing Ruby extensions
+MSG
+
+Gem::Specification.new do |spec|
+  spec.name          = 'rcsv'
+  spec.version       = Rcsv::VERSION
+  spec.authors       = ['Sameer Deshmukh']
+  spec.email         = ['sameer.deshmukh93@gmail.com']
+  spec.summary       = Rcsv::DESCRIPTION
+  spec.description   = Rcsv::DESCRIPTION
+  spec.license       = 'BSD-2'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency 'rubex', '~> 0.1'
+  spec.add_development_dependency 'rake', '~> 11.2'
+  spec.add_development_dependency 'rspec'
+end

data/examples/rcsv wrapper/rcsv/spec/rcsv.csv

@@ -0,0 +1,5 @@
+Name, age, sex
+Sameer, 24, M
+Ameya, 23, M
+Neeraja, 23, F
+Shounak, 24, M

data/examples/rcsv wrapper/rcsv/spec/rcsv_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe "Rubex wrapper over libcsv" do
+  context "Rcsv" do
+    it ".p" do
+      expect(Rcsv.p("spec/rcsv.csv")).to eq(
+        [
+          ["Name", "age", "sex"], 
+          ["Sameer", "24", "M"], 
+          ["Ameya", "23", "M"], 
+          ["Neeraja", "23", "F"], 
+          ["Shounak", "24", "M"]
+        ]
+      )
+    end
+  end
+end

data/examples/rcsv wrapper/rcsv/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require 'rspec'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'rcsv'

data/{spec/fixtures/basic_ruby_method/Makefile → examples/rcsv wrapper/rcsv/tmp/x86_64-linux/rcsv/2.3.3/Makefile }

@@ -11,13 +11,13 @@ NULLCMD = :
 
 #### Start of system configuration section. ####
 
-srcdir = .
-topdir = /home/sameer/.rvm/rubies/ruby-2.3.0/include/ruby-2.3.0
+srcdir = ../../../../ext/rcsv
+topdir = /home/sameer/.rvm/rubies/ruby-2.3.3/include/ruby-2.3.0
 hdrdir = $(topdir)
-arch_hdrdir = /home/sameer/.rvm/rubies/ruby-2.3.0/include/ruby-2.3.0/i686-linux
+arch_hdrdir = /home/sameer/.rvm/rubies/ruby-2.3.3/include/ruby-2.3.0/x86_64-linux
 PATH_SEPARATOR = :
 VPATH = $(srcdir):$(arch_hdrdir)/ruby:$(hdrdir)/ruby
-prefix = $(DESTDIR)/home/sameer/.rvm/rubies/ruby-2.3.0
+prefix = $(DESTDIR)/home/sameer/.rvm/rubies/ruby-2.3.3
 rubysitearchprefix = $(rubylibprefix)/$(sitearch)
 rubyarchprefix = $(rubylibprefix)/$(arch)
 rubylibprefix = $(libdir)/$(RUBY_BASE_NAME)
@@ -54,7 +54,7 @@ oldincludedir = $(DESTDIR)/usr/include
 includedir = $(prefix)/include
 localstatedir = $(prefix)/var
 sharedstatedir = $(prefix)/com
-sysconfdir = $(prefix)/etc
+sysconfdir = $(DESTDIR)/etc
 datadir = $(datarootdir)
 datarootdir = $(prefix)/share
 libexecdir = $(exec_prefix)/libexec
@@ -67,8 +67,8 @@ CC = gcc
 CXX = g++
 LIBRUBY = $(LIBRUBY_SO)
 LIBRUBY_A = lib$(RUBY_SO_NAME)-static.a
-LIBRUBYARG_SHARED = -Wl,-R$(libdir) -L$(libdir) -l$(RUBY_SO_NAME)
-LIBRUBYARG_STATIC = -Wl,-R$(libdir) -L$(libdir) -l$(RUBY_SO_NAME)-static
+LIBRUBYARG_SHARED = -Wl,-rpath,'$${ORIGIN}/../lib' -Wl,-R'$${ORIGIN}/../lib' -l$(RUBY_SO_NAME)
+LIBRUBYARG_STATIC = -Wl,-rpath,'$${ORIGIN}/../lib' -Wl,-R'$${ORIGIN}/../lib' -l$(RUBY_SO_NAME)-static
 empty =
 OUTFLAG = -o $(empty)
 COUTFLAG = -o $(empty)
@@ -78,11 +78,11 @@ cflags   =  $(optflags) $(debugflags) $(warnflags)
 cxxflags =  $(optflags) $(debugflags) $(warnflags)
 optflags = -O3 -fno-fast-math
 debugflags = -ggdb3
-warnflags = -Wall -Wextra -Wno-unused-parameter -Wno-parentheses -Wno-long-long -Wno-missing-field-initializers -Wunused-variable -Wpointer-arith -Wwrite-strings -Wdeclaration-after-statement -Wimplicit-function-declaration -Wdeprecated-declarations -Wno-packed-bitfield-compat
+warnflags = -Wall -Wextra -Wno-unused-parameter -Wno-parentheses -Wno-long-long -Wno-missing-field-initializers -Wunused-variable -Wpointer-arith -Wwrite-strings -Wdeclaration-after-statement -Wimplicit-function-declaration -Wdeprecated-declarations -Wno-packed-bitfield-compat -Wno-maybe-uninitialized
 CCDLFLAGS = -fPIC
 CFLAGS   = $(CCDLFLAGS) $(cflags)  -fPIC $(ARCH_FLAG)
 INCFLAGS = -I. -I$(arch_hdrdir) -I$(hdrdir)/ruby/backward -I$(hdrdir) -I$(srcdir)
-DEFS     = -D_FILE_OFFSET_BITS=64
+DEFS     = 
 CPPFLAGS =   $(DEFS) $(cppflags)
 CXXFLAGS = $(CCDLFLAGS) $(cxxflags) $(ARCH_FLAG)
 ldflags  = -L. -fstack-protector -rdynamic -Wl,-export-dynamic
@@ -101,7 +101,7 @@ RUBY_VERSION_NAME = $(RUBY_BASE_NAME)-$(ruby_version)
 RUBYW_BASE_NAME = rubyw
 RUBY_BASE_NAME = ruby
 
-arch = i686-linux
+arch = x86_64-linux
 sitearch = $(arch)
 ruby_version = 2.3.0
 ruby = $(bindir)/$(RUBY_BASE_NAME)
@@ -112,7 +112,7 @@ RM = rm -f
 RM_RF = $(RUBY) -run -e rm -- -rf
 RMDIRS = rmdir --ignore-fail-on-non-empty -p
 MAKEDIRS = /bin/mkdir -p
-INSTALL = /usr/bin/install -c
+INSTALL = /usr/bin/install
 INSTALL_PROG = $(INSTALL) -m 0755
 INSTALL_DATA = $(INSTALL) -m 644
 COPY = cp
@@ -132,15 +132,15 @@ DISTCLEANDIRS =
 
 extout = 
 extout_prefix = 
-target_prefix = /basic_ruby_method
+target_prefix = /ext/rcsv
 LOCAL_LIBS = 
-LIBS = $(LIBRUBYARG_SHARED)  -lpthread -lgmp -ldl -lcrypt -lm   -lc
-ORIG_SRCS = basic_ruby_method.c
+LIBS = $(LIBRUBYARG_SHARED)  -lcsv -lpthread -lgmp -ldl -lcrypt -lm   -lc
+ORIG_SRCS = rcsv.c
 SRCS = $(ORIG_SRCS) 
-OBJS = basic_ruby_method.o
+OBJS = rcsv.o
 HDRS = 
-TARGET = basic_ruby_method
-TARGET_NAME = basic_ruby_method
+TARGET = rcsv
+TARGET_NAME = rcsv
 TARGET_ENTRY = Init_$(TARGET_NAME)
 DLLIB = $(TARGET).so
 EXTSTATIC = 
@@ -182,7 +182,7 @@ distclean: clean distclean-so distclean-static distclean-rb-default distclean-rb
 realclean: distclean
 install: install-so install-rb
 
-install-so: $(DLLIB) $(TIMESTAMP_DIR)/.RUBYARCHDIR.-.basic_ruby_method.time
+install-so: $(DLLIB) $(TIMESTAMP_DIR)/.RUBYARCHDIR.-.ext.-.rcsv.time
 	$(INSTALL_PROG) $(DLLIB) $(RUBYARCHDIR)
 clean-static::
 	-$(Q)$(RM) $(STATIC_LIB)
@@ -192,7 +192,7 @@ pre-install-rb: Makefile
 pre-install-rb-default: Makefile
 pre-install-rb-default:
 	@$(NULLCMD)
-$(TIMESTAMP_DIR)/.RUBYARCHDIR.-.basic_ruby_method.time:
+$(TIMESTAMP_DIR)/.RUBYARCHDIR.-.ext.-.rcsv.time:
 	$(Q) $(MAKEDIRS) $(@D) $(RUBYARCHDIR)
 	$(Q) $(TOUCH) $@
 
@@ -251,7 +251,7 @@ site-install-rb: install-rb
 	$(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -S $<
 
 $(DLLIB): $(OBJS) Makefile
-	$(ECHO) linking shared-object basic_ruby_method/$(DLLIB)
+	$(ECHO) linking shared-object ext/rcsv/$(DLLIB)
 	-$(Q)$(RM) $(@)
 	$(Q) $(LDSHARED) -o $@ $(OBJS) $(LIBPATH) $(DLDFLAGS) $(LOCAL_LIBS) $(LIBS)
 

data/lib/rubex.rb

@@ -1,56 +1,12 @@
+require 'forwardable'
+
+require 'rubex/error'
+require 'rubex/helpers'
 require 'rubex/code_writer'
 require 'rubex/data_type'
 require 'rubex/constants'
 require 'rubex/ast'
 require 'rubex/symbol_table'
 require 'rubex/parser.racc.rb'
-
-module Rubex
-  class << self
-    def compile path, test=false
-      tree = ast path
-      target_name = extract_target_name path
-      code = generate_code tree, target_name
-      ext = extconf target_name
-      
-      return [code, ext] if test
-      write_files target_name, code, ext
-    end
-
-    def ast path
-      parser = Rubex::Parser.new
-      parser.parse(path)
-      parser.do_parse
-    end
-
-    def extconf target_name, dir=nil
-      extconf = ""
-      extconf << "require 'mkmf'\n"
-      extconf << "create_makefile('#{target_name}/#{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
-      Dir.mkdir(target_name)
-      code_file = File.new "#{target_name}/#{target_name}.c", "w+"
-      code_file.puts code.to_s
-      code_file.close
-
-      extconf_file = File.new "#{target_name}/extconf.rb", "w+"
-      extconf_file.puts ext
-      extconf_file.close
-    end
-  end
-end
+require 'rubex/compiler_config'
+require 'rubex/compiler'

data/lib/rubex/ast.rb

@@ -1,6 +1,4 @@
 require 'rubex/ast/node'
-require 'rubex/ast/ruby_method_def'
-require 'rubex/ast/c_base_type'
-require 'rubex/ast/argument_list'
 require 'rubex/ast/statement'
 require 'rubex/ast/expression'
+require 'rubex/ast/top_statement'

data/lib/rubex/ast/expression.rb

@@ -1,13 +1,1262 @@
 module Rubex
   module AST
-    class Expression
-      class Addition
-        attr_reader :left, :right
+    module Expression
+      class Base
+        attr_accessor :typecast
 
-        def initialize left, right
-          @left, @right = left, right
+        # In case an expr has to be of a certain type, like a string literal
+        #   assigned to a char*, this method will analyse the literal in context
+        #   to the target dtype.
+        def analyse_for_target_type target_type, local_scope
+          analyse_statement local_scope
         end
+
+        # If the typecast exists, the typecast is made the overall type of
+        # the expression.
+        def analyse_statement local_scope
+          if @typecast
+            @typecast.analyse_statement(local_scope) 
+            @type = @typecast.type
+          end
+        end
+
+        def expression?; true; end
+
+        def c_code local_scope
+          @typecast ? @typecast.c_code(local_scope) : ""
+        end
+
+        def possible_typecast code, local_scope
+          @typecast ? @typecast.c_code(local_scope) : ""
+        end
+
+        def to_ruby_object
+          ToRubyObject.new self
+        end
+
+        def from_ruby_object from_node
+          FromRubyObject.new self, from_node
+        end
+
+        def release_temp local_scope
+          local_scope.release_temp(@c_code) if @has_temp
+        end
+
+        def allocate_temp local_scope, type
+          if @has_temp
+            @c_code = local_scope.allocate_temp(type)
+          end
+        end
+
+        def allocate_temps local_scope
+          if @subexprs
+            @subexprs.each { |expr| expr.allocate_temp(local_scope, expr.type) }
+          end
+        end
+
+        def release_temps local_scope
+          if @subexprs
+            @subexprs.each { |expr| expr.release_temp(local_scope) }
+          end
+        end
+
+        def generate_evaluation_code code, local_scope
+          
+        end
+
+        def generate_disposal_code code
+
+        end
+
+        def generate_assignment_code rhs, code, local_scope
+          
+        end
+      end
+
+      class Typecast < Base
+        attr_reader :type
+
+        def initialize dtype, ptr_level
+          @dtype, @ptr_level = dtype, ptr_level
+        end
+
+        def analyse_statement local_scope
+          @type = Rubex::Helpers.determine_dtype @dtype, @ptr_level
+        end
+
+        def c_code local_scope
+          "(#{@type.to_s})"
+        end
+      end # class Typecast
+
+      class SizeOf < Base
+        attr_reader :type
+
+        def initialize type, ptr_level
+          @size_of_type = Helpers.determine_dtype type, ptr_level
+        end
+
+        def analyse_statement local_scope
+          @type = DataType::ULInt.new
+          super
+        end
+
+        def c_code local_scope
+          "sizeof(#{@size_of_type})"
+        end
+      end # class SizeOf
+
+      class Binary < Base
+        include Rubex::Helpers::NodeTypeMethods
+
+        attr_reader :operator
+        attr_accessor :left, :right
+        # Final return type of expression
+        attr_accessor :type, :subexprs
+
+        def initialize left, operator, right
+          @left, @operator, @right = left, operator, right
+          @@analyse_visited = []
+          @subexprs = []
+        end
+
+        def analyse_statement local_scope
+          analyse_left_and_right_nodes local_scope, self
+          analyse_return_type local_scope, self
+          super
+        end
+
+        def allocate_temps local_scope
+          @subexprs.each do |expr|
+            if expr.is_a?(Binary)
+              expr.allocate_temps local_scope
+            else
+              expr.allocate_temp local_scope, expr.type
+            end
+          end
+        end
+
+        def generate_evaluation_code code, local_scope
+          @left.generate_evaluation_code code, local_scope
+          @right.generate_evaluation_code code, local_scope
+        end
+
+        def generate_disposal_code code
+          @left.generate_disposal_code code
+          @right.generate_disposal_code code
+        end
+
+        def c_code local_scope
+          code = super
+          code << "( "
+          left_code = @left.c_code(local_scope)
+          right_code = @right.c_code(local_scope)
+          if type_of(@left).object? || type_of(@right).object?
+            left_ruby_code = @left.type.to_ruby_object(left_code)
+            right_ruby_code = @right.type.to_ruby_object(right_code)
+
+            if ["&&", "||"].include?(@operator)
+              code << Rubex::C_MACRO_INT2BOOL + 
+                "(RTEST(#{left_ruby_code}) #{@operator} RTEST(#{right_ruby_code}))"
+            else
+              code << "rb_funcall(#{left_ruby_code}, rb_intern(\"#{@operator}\") "
+              code << ", 1, #{right_ruby_code})"
+            end
+          else
+            code << "#{left_code} #{@operator} #{right_code}"
+          end
+          code << " )"
+
+          code
+        end
+
+        def == other
+          self.class == other.class && @type  == other.type &&
+          @left == other.left  && @right == other.right &&
+          @operator == other.operator
+        end
+
+      private
+
+        def type_of expr
+          t = expr.type
+          return (t.c_function? ? t.type : t)
+        end
+
+        def analyse_left_and_right_nodes local_scope, tree
+          if tree.respond_to?(:left)
+            analyse_left_and_right_nodes local_scope, tree.left
+
+            if !@@analyse_visited.include?(tree.left.object_id)
+              if tree.right.type
+                tree.left.analyse_for_target_type(tree.right.type, local_scope)
+              else
+                tree.left.analyse_statement(local_scope)
+              end
+              @subexprs << tree.left
+              @@analyse_visited << tree.left.object_id
+            end
+            
+            if !@@analyse_visited.include?(tree.right.object_id)
+              if tree.left.type
+                tree.right.analyse_for_target_type(tree.left.type, local_scope)
+              else
+                tree.right.analyse_statement(local_scope)
+              end
+              @subexprs << tree.right
+              @@analyse_visited << tree.right.object_id
+            end
+
+            @@analyse_visited << tree.object_id
+
+            analyse_left_and_right_nodes local_scope, tree.right
+          end
+        end
+
+        def analyse_return_type local_scope, tree
+          if tree.respond_to? :left
+            analyse_return_type local_scope, tree.left
+            analyse_return_type local_scope, tree.right
+
+            if ['==', '<', '>', '<=', '>=', '||', '&&', '!='].include? tree.operator
+              if type_of(tree.left).object? || type_of(tree.right).object?
+                tree.type = Rubex::DataType::Boolean.new
+              else
+                tree.type = Rubex::DataType::CBoolean.new
+              end
+            else
+              if tree.left.type.bool? || tree.right.type.bool?
+                raise Rubex::TypeMismatchError, "Operation #{tree.operator} cannot"\
+                  "be performed between #{tree.left} and #{tree.right}"
+              end
+              tree.type = Rubex::Helpers.result_type_for(
+                     type_of(tree.left), type_of(tree.right))
+            end
+          end
+        end
+      end # class Binary
+
+      class UnaryBase < Base
+        def initialize expr
+          @expr = expr
+        end
+
+        def analyse_statement local_scope
+          @expr.analyse_statement local_scope
+          @type = @expr.type
+          @expr.allocate_temps local_scope
+          @expr.allocate_temp local_scope, @type
+          @expr.release_temps local_scope
+          @expr.release_temp local_scope
+          @expr = @expr.to_ruby_object if @type.object?
+        end
+
+        def generate_evaluation_code code, local_scope
+          @expr.generate_evaluation_code code, local_scope         
+        end
+      end
+
+      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
+
+      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
+
+      class Ampersand < UnaryBase
+        attr_reader :type
+
+        def analyse_statement local_scope
+          @expr.analyse_statement local_scope
+          @type = DataType::CPtr.new @expr.type
+        end
+
+        def c_code local_scope
+          "&#{@expr.c_code(local_scope)}"
+        end
+      end
+
+      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
+
+      class Unary < Base
+        attr_reader :operator, :expr, :type
+
+        OP_CLASS_MAP = {
+          '&' => Ampersand,
+          '-' => UnarySub,
+          '!' => UnaryNot,
+          '~' => UnaryBitNot
+        }
+
+        def initialize operator, expr
+          @operator, @expr = operator, expr
+        end
+
+        def analyse_statement local_scope
+          @expr = OP_CLASS_MAP[@operator].new(@expr)
+          @expr.analyse_statement 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 # class Unary
+
+      class ElementRef < Base
+        attr_reader :entry, :pos, :type, :name, :object_ptr
+
+        def initialize name, pos
+          @name, @pos = name, pos
+          @subexprs = []
+        end
+
+        # FIXME: This method needs to be implemented for all exprs that are
+        #   possible LHS candidates.
+        # def analyse_declaration rhs, local_scope
+        #   analyse_statement local_scope
+        #   @has_temp = false
+        # end
+
+        def analyse_statement local_scope, struct_scope=nil
+          if struct_scope.nil?
+            @entry = local_scope.find @name
+          else
+            @entry = struct_scope[@name]
+          end
+          
+          @object_ptr = true if @entry.type.cptr? && @entry.type.type.object?
+          @type = @entry.type.object? ? @entry.type : @entry.type.type
+
+          if @type.object? && !@object_ptr
+            @has_temp = true
+            @pos.analyse_statement local_scope
+            if !(@type.ruby_array?)
+              @pos = @pos.to_ruby_object
+            end
+            @subexprs << @pos
+          else
+            @pos.analyse_statement local_scope
+          end
+          super(local_scope)
+        end
+
+        # This method will be called when [] ruby method or C array element
+        #   reference is called.
+        # TODO: refactor this by creating separate classes for ruby object, object
+        # ptr, c type.
+        def generate_evaluation_code code, local_scope
+          if @type.object? && !@object_ptr
+            if @type.ruby_array?
+              code << "#{@c_code} = RARRAY_AREF(#{@entry.c_name}, #{@pos.c_code(local_scope)});"
+            elsif @type.ruby_hash?
+              @pos.generate_evaluation_code code, local_scope
+              code << "#{@c_code} = rb_hash_aref(#{@entry.c_name}, #{@pos.c_code(local_scope)});"
+            else
+              @pos.generate_evaluation_code code, local_scope
+              code << "#{@c_code} = rb_funcall(#{@entry.c_name}, rb_intern(\"[]\"), 1, "
+              code << "#{@pos.c_code(local_scope)});"
+            end
+            code.nl
+            @pos.generate_disposal_code code
+          else
+            @pos.generate_evaluation_code code, local_scope
+            @c_code = "#{@entry.c_name}[#{@pos.c_code(local_scope)}]"
+          end
+        end
+
+        def generate_disposal_code code
+          if @type.object? && !@object_ptr
+            code << "#{@c_code} = 0;"
+            code.nl
+          end
+        end
+
+        # This method will be called when []= ruby method or C array assignment
+        #   takes place.
+        def generate_assignment_code rhs, code, local_scope
+          if @type.object? && !@object_ptr
+            @pos.generate_evaluation_code code, local_scope
+            if @type.ruby_hash?
+              code << "rb_hash_aset(#{@entry.c_name}, #{@pos.c_code(local_scope)}, #{rhs.c_code(local_scope)});"
+            else
+              code << "rb_funcall(#{@entry.c_name}, rb_intern(\"[]=\"), 2, "
+              code << "#{@pos.c_code(local_scope)}, #{rhs.c_code(local_scope)});"
+            end
+            @pos.generate_disposal_code code
+          else
+            code << "#{@entry.c_name}[#{@pos.c_code(local_scope)}] = "
+            code << "#{rhs.c_code(local_scope)};"
+          end
+          code.nl
+        end
+
+        # FIXME: This is jugaad. Change.
+        def generate_element_ref_code expr, code, local_scope
+          if !@object_ptr
+            @pos.generate_evaluation_code code, local_scope
+            str = "#{@c_code} = rb_funcall(#{expr.c_code(local_scope)}."
+            str << "#{@entry.c_name}, rb_intern(\"[]\"), 1, "
+            str << "#{@pos.c_code(local_scope)});"
+            code << str
+            code.nl
+            @pos.generate_disposal_code code
+          else
+            generate_evaluation_code code, local_scope
+          end
+        end
+
+        def c_code local_scope
+          code = super
+          code << @c_code
+          code
+        end
+      end # class ElementRef
+
+      class Self < Base
+        def c_code local_scope
+          local_scope.self_name
+        end
+
+        def type
+          Rubex::DataType::RubyObject.new
+        end
+      end # class Self
+
+      class RubyConstant < Base
+        include Rubex::AST::Expression
+        attr_reader :name, :entry, :type
+
+        def initialize name
+          @name = name
+        end
+
+        def analyse_statement local_scope
+          @type = Rubex::DataType::RubyConstant.new @name
+          c_name = Rubex::DEFAULT_CLASS_MAPPINGS[@name]
+          @entry = Rubex::SymbolTable::Entry.new name, c_name, @type, nil
+        end
+
+        def c_code local_scope
+          if @entry.c_name # built-in constant.
+            @entry.c_name
+          else
+            "rb_const_get(CLASS_OF(#{local_scope.self_name}), rb_intern(\"#{@entry.name}\"))"
+          end
+        end
+      end # class RubyConstant
+
+      # Singular name node with no sub expressions.
+      class Name < Base
+        attr_reader :name, :entry, :type
+
+        def initialize name
+          @name = name
+        end
+
+        # Used when the node is a LHS of an assign statement.
+        def analyse_declaration rhs, local_scope
+          @entry = local_scope.find @name
+          unless @entry
+            local_scope.add_ruby_obj(name: @name,
+              c_name: Rubex::VAR_PREFIX + @name, value: @rhs)
+            @entry = local_scope[@name]
+          end
+          @type = @entry.type
+        end
+
+        def analyse_for_target_type target_type, local_scope
+          @entry = local_scope.find @name
+          
+          if @entry && @entry.type.c_function? && target_type.c_function_ptr?
+            @type = @entry.type
+          else
+            analyse_statement local_scope
+          end
+        end
+
+        # Analyse a Name node. This can either be a variable name or a method call
+        #   without parenthesis. Code in this method that creates a CommandCall
+        #   node primarily exists because in Ruby methods without arguments can 
+        #   be called without parentheses. These names can potentially be Ruby
+        #   methods that are not visible to Rubex, but are present in the Ruby
+        #   run time.
+        def analyse_statement local_scope
+          @entry = local_scope.find @name
+          # FIXME: Figure out a way to perform compile time checking of expressions
+          #   to see if the said Ruby methods are actually present in the Ruby
+          #   runtime. Maybe read symbols in the Ruby interpreter and load them
+          #   as a pre-compilation step?
+
+          # If entry is not present, assume its a Ruby method call to some method
+          #   outside of the current Rubex scope or a Ruby constant.
+          if !@entry
+            # Check if first letter is a capital to check for Ruby constant.
+            if @name[0].match /[A-Z]/
+              @name = Expression::RubyConstant.new @name
+              @name.analyse_statement local_scope
+              @entry = @name.entry
+            else # extern Ruby method
+              @entry = local_scope.add_ruby_method(
+                name: @name,
+                c_name: @name,
+                extern: true,
+                scope: nil,
+                arg_list: [])
+            end
+          end
+          # If the entry is a RubyMethod, it should be interpreted as a command
+          # call. So, make the @name a CommandCall Node.
+          if @entry.type.ruby_method? #|| @entry.type.c_function?
+            @name = Rubex::AST::Expression::CommandCall.new(
+              Expression::Self.new, @name, [])
+            @name.analyse_statement local_scope
+          end
+
+          if @entry.type.alias_type? || @entry.type.ruby_method? || 
+              @entry.type.c_function?
+            @type = @entry.type.type
+          else
+            @type = @entry.type
+          end
+          super
+        end
+
+        def generate_evaluation_code code, local_scope
+          if @name.respond_to? :generate_evaluation_code
+            @name.generate_evaluation_code code, local_scope
+          end
+        end
+
+        def generate_disposal_code code
+          if @name.respond_to? :generate_disposal_code
+            @name.generate_disposal_code code
+          end
+        end
+
+        def generate_assignment_code rhs, code, local_scope
+          code << "#{self.c_code(local_scope)} = #{rhs.c_code(local_scope)};"
+          code.nl
+          rhs.generate_disposal_code code
+        end
+
+        def c_code local_scope
+          code = super
+          if @name.is_a?(Rubex::AST::Expression::Base)
+            code << @name.c_code(local_scope)
+          else
+            code << @entry.c_name
+          end
+
+          code
+        end
+      end # class Name
+
+      class MethodCall < Base
+        attr_reader :method_name, :type
+
+        def initialize method_name, invoker, arg_list
+          @method_name, @invoker, @arg_list = method_name, invoker, arg_list
+        end
+
+        # Analyse a method call. If the method that is being called is defined
+        #   in a class in a Rubex file, it can easily be interpreted as a Ruby
+        #   method. However, in case it is not, a new symtab entry will be created
+        #   which will mark the method as 'extern' so that future calls to that
+        #   same method can be simply pulled from the symtab.
+        # local_scope is the local method scope.
+        def analyse_statement local_scope
+          entry = local_scope.find(@method_name)
+          if !entry
+            entry = local_scope.add_ruby_method(
+              name: @method_name, 
+              c_name: @method_name, 
+              extern: true,
+              arg_list: @arg_list,
+              scope: nil)
+          end
+
+          if method_not_within_scope? local_scope
+            raise Rubex::NoMethodError, "Cannot call #{@name} from this method."
+          end
+
+          # FIXME: Print a warning during compilation if a symbol is being
+          #   interpreted as a Ruby method call due it not being found in the
+          #   symbol table.
+
+          # A symtab entry for a predeclared extern C func.
+          if entry && entry.type.base_type.c_function?
+            @type = entry.type.base_type
+            # All C functions have compulsory last arg as self. This does not
+            #   apply to extern functions as they are usually not made for accepting
+            #   a VALUE last arg.
+            @arg_list << Expression::Self.new if !entry.extern?
+            type_check_arg_types entry
+          else
+            @type = Rubex::DataType::RubyObject.new
+          end
+
+          if entry.type.ruby_method? && !entry.extern? && @arg_list.size > 0 
+            @arg_list_var = entry.c_name + Rubex::ACTUAL_ARGS_SUFFIX
+
+            args_size = entry.type.arg_list&.size || 0
+            local_scope.add_carray(name: @arg_list_var, c_name: @arg_list_var,
+              dimension: Literal::Int.new("#{args_size}"), 
+              type: Rubex::DataType::RubyObject.new)
+          end
+          super
+        end
+
+        def generate_evaluation_code code, local_scope
+        end
+
+        def generate_disposal_code code
+        end
+
+        def c_code local_scope
+          code = super
+          entry = local_scope.find(@method_name)
+          if entry.type.ruby_method?
+            code << code_for_ruby_method_call(local_scope)
+          else
+            code << code_for_c_method_call(local_scope, entry)
+          end
+
+          code
+        end
+
+      private
+
+        def type_check_arg_types entry
+          @arg_list.map!.with_index do |arg, idx|
+            Helpers.to_lhs_type(entry.type.base_type.arg_list[idx], arg)
+          end
+        end
+
+        # Checks if method being called is of the same type of the caller. For
+        # example, only instance methods can call instance methods and only 
+        # class methods can call class methods. C functions are accessible from
+        # both instance methods and class methods.
+        #
+        # Since there is no way to determine whether methods outside the scope
+        # of the compiled Rubex file are singletons or not, Rubex will assume
+        # that they belong to the correct scope and will compile a call to those
+        # methods anyway. Error, if any, will be caught only at runtime.
+        def method_not_within_scope? local_scope
+          entry = local_scope.find @method_name
+          caller_entry = local_scope.find local_scope.name
+          if ( caller_entry.singleton? &&  entry.singleton?) || 
+             (!caller_entry.singleton? && !entry.singleton?) ||
+             entry.c_function?
+            false
+          else
+            true
+          end
+        end
+
+        def code_for_c_method_call local_scope, entry
+          str = "#{entry.c_name}("
+          str << @arg_list.map { |a| a.c_code(local_scope) }.join(",")
+          str << ")"
+          str
+        end
+
+        def code_for_ruby_method_call local_scope
+          entry = local_scope.find @method_name
+          str = ""
+          if entry.extern?
+            str << "rb_funcall(#{@invoker.c_code(local_scope)}, "
+            str << "rb_intern(\"#{@method_name}\"), "
+            str << "#{@arg_list.size}"
+            @arg_list.each do |arg|
+              str << " ,#{arg.type.to_ruby_object(arg.c_code(local_scope))}"
+            end
+            str << ", NULL" if @arg_list.empty?
+            str << ")"
+          else
+            str << populate_method_args_into_value_array(local_scope)
+            str << actual_ruby_method_call(local_scope, entry)
+          end
+          str
+        end
+
+        def actual_ruby_method_call local_scope, entry
+          str = "#{entry.c_name}(#{@arg_list.size}, #{@arg_list_var || "NULL"},"
+          str << "#{local_scope.self_name})"
+        end
+
+        def populate_method_args_into_value_array local_scope
+          str = ""
+          @arg_list.each_with_index do |arg, idx|
+            str = "#{@arg_list_var}[#{idx}] = "
+            str << "#{arg.type.to_ruby_object(arg.c_code(local_scope))}"
+            str << ";\n"
+          end
+
+          str
+        end
+      end # class MethodCall
+
+      class CommandCall < Base
+        attr_reader :expr, :command, :arg_list, :type
+
+        def initialize expr, command, arg_list
+          @expr, @command, @arg_list = expr, command, arg_list
+          @subexprs = []
+        end
+
+        # Analyse the command call. If the @command is found in the symbol table,
+        #   it is either a struct member or a method call. If not found, it is
+        #   assumed to be a Ruby method call and passed on the MethodCall node
+        #   where it is interpreted likewise. The upside is that Rubex can call
+        #   arbitrary Ruby methods that are defined in external Ruby scripts and
+        #   not visible to Rubex at compile time. The downside is that errors with
+        #   such methods will be visible to the programmer only during runtime.
+        def analyse_statement local_scope
+          @arg_list.each do |arg|
+            arg.analyse_statement local_scope
+            @subexprs << arg
+          end
+          # Case for implicit 'self' when a method in the class itself is being called.
+          if @expr.nil?
+            entry = local_scope.find(@command)
+            @expr = Expression::Self.new if entry && !entry.extern?
+          else
+            @expr.analyse_statement(local_scope)
+            @expr.allocate_temps local_scope
+            @expr.allocate_temp local_scope, @expr.type
+          end
+          analyse_command_type local_scope
+          super
+        end
+
+        # FIXME: refactor this method (or class). Too many ifs. Too much jagaad.
+        def generate_evaluation_code code, local_scope
+          @c_code = ""
+          @arg_list.each do |arg|
+            arg.generate_evaluation_code code, local_scope
+          end
+          @expr.generate_evaluation_code(code, local_scope) if @expr
+
+          if @expr && @type.object? && @command.is_a?(Rubex::AST::Expression::ElementRef) && 
+            !@command.object_ptr
+            @command.generate_element_ref_code @expr, code, local_scope
+            @c_code << "#{@command.c_code(local_scope)}"
+          else
+            @command.generate_evaluation_code code, local_scope
+            # Interpreted as a method call
+            if @command.is_a? Rubex::AST::Expression::MethodCall
+              @c_code << @command.c_code(local_scope)
+            else # interpreted as referencing the contents of a struct
+              op = @expr.type.cptr? ? "->" : "."
+
+              @c_code << "#{@expr.c_code(local_scope)}#{op}#{@command.c_code(local_scope)}"
+            end
+          end
+        end
+
+        def generate_disposal_code code
+          @expr.generate_disposal_code(code) if @expr
+          # @command.generate_disposal_code code
+          @arg_list.each do |arg|
+            arg.generate_disposal_code code
+          end
+        end
+
+        def generate_assignment_code rhs, code, local_scope
+          generate_evaluation_code code, local_scope
+          code << "#{self.c_code(local_scope)} = #{rhs.c_code(local_scope)};"
+          code.nl
+        end
+
+        def c_code local_scope
+          code = super
+          code << @c_code
+          code
+        end
+
+      private
+
+        def analyse_command_type local_scope
+          if @expr && ((@expr.type.cptr? && @expr.type.type.struct_or_union?) || 
+              (@expr.type.struct_or_union?))
+            scope = @expr.type.base_type.scope
+            if @command.is_a? String
+              @command = Expression::Name.new @command
+              @command.analyse_statement scope
+            end
+
+            if !scope.has_entry?(@command.name)
+              raise "Entry #{@command.name} does not exist in #{@expr}."
+            end
+
+            if @command.is_a? Rubex::AST::Expression::ElementRef
+              @command.analyse_statement local_scope, scope
+            end
+          else
+            @command = Expression::MethodCall.new @command, @expr, @arg_list
+            @command.analyse_statement local_scope
+          end
+          @type = @command.type
+          @command.allocate_temps local_scope
+          @command.allocate_temp local_scope, @type
+          @command.release_temps local_scope
+          @command.release_temp local_scope
+        end
+      end # class CommandCall
+
+
+      class ArgDeclaration < Base
+        attr_reader :entry, :type
+
+        # data_hash - a Hash containing data about the variable.
+        def initialize data_hash
+          @data_hash = data_hash
+        end
+
+        def analyse_statement local_scope, inside_func_ptr: false, extern: false
+          # FIXME: Support array of function pointers and array in arguments.
+          var       = @data_hash[:variables][0]
+          dtype     = @data_hash[:dtype]
+          ident     = var[:ident]
+          ptr_level = var[:ptr_level]
+          value     = var[:value]
+
+          if ident.is_a?(Hash) # function pointer
+            cfunc_return_type = Helpers.determine_dtype(dtype,
+              ident[:return_ptr_level])
+            arg_list = ident[:arg_list].analyse_statement(local_scope,
+              inside_func_ptr: true)
+            ptr_level = "*" if ptr_level.empty?
+
+            if inside_func_ptr
+              name, c_name = nil, nil
+            else
+              name   = ident[:name]
+              c_name = Rubex::ARG_PREFIX + name
+            end
+
+            @type   = Helpers.determine_dtype(
+              DataType::CFunction.new(name, c_name, arg_list, cfunc_return_type, nil),
+              ptr_level)
+          else
+            if !inside_func_ptr
+              name, c_name = ident, Rubex::ARG_PREFIX + ident 
+            end
+            @type = Helpers.determine_dtype(dtype, ptr_level)
+          end
+
+          value.analyse_statement(local_scope) if value
+
+          if !extern && !inside_func_ptr
+            @entry = local_scope.add_arg(name: name, c_name: c_name, type: @type,
+              value: value)
+          end
+        end # def analyse_statement
+      end # class ArgDeclaration
+
+      class CoerceObject < Base
+        attr_reader :expr
+
+        extend Forwardable
+
+        def_delegators :@expr, :generate_evaluation_code, :generate_disposal_code,
+          :generate_assignment_code, :allocate_temp, :allocate_temps,
+          :release_temp, :release_temps, :type
       end
-    end
-  end
-end
+
+      # Internal class to typecast from a C type to another C type.
+      class TypecastTo < CoerceObject
+        def initialize dtype
+          
+        end
+        # TODO
+      end
+
+      # 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))}"
+        end
+      end
+
+      # internal node for converting from ruby object.
+      class FromRubyObject < CoerceObject
+        # expr - Expression to convert
+        # from_node - LHS expression. Of type Rubex::AST::Expression
+        def initialize expr, from_node
+          @expr = expr
+          @type = @expr.type
+          @from_node = from_node
+        end
+
+        def c_code local_scope
+          "#{@from_node.type.from_ruby_object(@expr.c_code(local_scope))}"
+        end
+      end
+
+      class BlockGiven < Base
+        attr_reader :type
+
+        def analyse_statement local_scope
+          @type = DataType::CBoolean.new
+        end
+
+        def c_code local_scope
+          "rb_block_given_p()"
+        end
+      end
+
+      # Internal node that denotes empty expression for a statement for example
+      #   the `return` for a C function with return type `void`.
+      class Empty < Base
+        attr_reader :type
+
+        def analyse_statement local_scope
+          @type = DataType::Void.new
+        end
+      end
+
+      module Literal
+        class Base < Rubex::AST::Expression::Base
+          attr_reader :name, :type
+
+          def initialize name
+            @name = name
+          end
+
+          def c_code local_scope
+            code = super
+            code << @name
+          end
+
+          def c_name
+            @name
+          end
+
+          def literal?; true; end
+
+          def == other
+            self.class == other.class && @name == other.name
+          end
+        end # class Base
+
+        class ArrayLit < Literal::Base
+          include Enumerable
+
+          attr_accessor :c_array
+
+          def each &block
+            @array_list.each(&block)
+          end
+
+          def initialize array_list
+            @array_list = array_list
+            @subexprs = []
+          end
+
+          def analyse_statement local_scope
+            @has_temp = true
+            @type = DataType::RubyObject.new
+            @array_list.map! do |e|    
+              e.analyse_statement local_scope
+              e = e.to_ruby_object
+              @subexprs << e
+              e
+            end
+          end
+
+          def generate_evaluation_code code, local_scope
+            code << "#{@c_code} = rb_ary_new2(#{@array_list.size});"
+            code.nl
+            @array_list.each do |e|
+              code << "rb_ary_push(#{@c_code}, #{e.c_code(local_scope)});"
+              code.nl
+            end
+          end
+
+          def generate_disposal_code code
+            code << "#{@c_code} = 0;"
+            code.nl
+          end
+
+          def c_code local_scope
+            @c_code
+          end
+        end # class ArrayLit
+
+        class HashLit < Literal::Base
+          def initialize key_val_pairs
+            @key_val_pairs = key_val_pairs
+          end
+
+          def analyse_statement local_scope
+            @has_temp = true
+            @type = Rubex::DataType::RubyObject.new
+            @key_val_pairs.map! do |k, v|
+              k.analyse_for_target_type(@type, local_scope)
+              v.analyse_for_target_type(@type, local_scope)
+              [k.to_ruby_object, v.to_ruby_object]
+            end
+          end
+
+          def generate_evaluation_code code, local_scope
+            code << "#{@c_code} = rb_hash_new();"
+            code.nl
+            @key_val_pairs.each do |k, v|
+              k.generate_evaluation_code(code, local_scope)
+              v.generate_evaluation_code(code, local_scope)
+
+              code << "rb_hash_aset(#{@c_code}, #{k.c_code(local_scope)}, "
+              code << "#{v.c_code(local_scope)});"
+              code.nl
+
+              k.generate_disposal_code code
+              v.generate_disposal_code code
+              code.nl
+            end            
+          end
+
+          def allocate_temps local_scope
+            @key_val_pairs.each do |k,v|
+              k.allocate_temp local_scope, k.type
+              v.allocate_temp local_scope, v.type
+            end
+          end
+
+          def release_temps local_scope
+            @key_val_pairs.each do |k,v|
+              k.release_temp local_scope
+              v.release_temp local_scope
+            end
+          end
+
+          def generate_disposal_code code
+            code << "#{@c_code} = 0;"
+            code.nl
+          end
+
+          def c_code local_scope
+            @c_code
+          end
+        end
+
+        class RubySymbol < Literal::Base
+          def initialize name
+            super(name[1..-1])
+            @type = Rubex::DataType::RubySymbol.new
+          end
+
+          def generate_evaluation_code code, local_scope
+            @c_code = "ID2SYM(rb_intern(\"#{@name}\"))"
+          end
+
+          def c_code local_scope
+            @c_code
+          end
+        end
+
+        class Double < Literal::Base
+          def initialize name
+            super
+            @type = Rubex::DataType::F64.new
+          end
+        end
+
+        class Int < Literal::Base
+          def initialize name
+            super
+            @type = Rubex::DataType::Int.new
+          end
+        end
+
+        class StringLit < Literal::Base
+          def initialize name
+            super           
+          end
+
+          def analyse_for_target_type target_type, local_scope
+            if target_type.char_ptr?
+              @type = Rubex::DataType::CStr.new
+            elsif target_type.object?
+              @type = Rubex::DataType::RubyString.new
+              analyse_statement local_scope
+            else
+              raise Rubex::TypeError, "Cannot assign #{target_type} to string."
+            end
+          end
+
+          def analyse_statement local_scope
+            @type = Rubex::DataType::RubyString.new unless @type
+            @has_temp = 1
+          end
+
+          def generate_evaluation_code code, local_scope
+            if @type.cstr?
+              @c_code = "\"#{@name}\""
+            else
+              code << "#{@c_code} = rb_str_new2(\"#{@name}\");"
+              code.nl
+            end
+          end
+
+          def generate_disposal_code code
+            if @type.object?
+              code << "#{@c_code} = 0;"
+              code.nl
+            end
+          end
+
+          def c_code local_scope
+            @c_code
+          end
+        end # class StringLit
+
+        class Char < Literal::Base
+          def initialize name
+            super
+          end
+
+          def analyse_for_target_type target_type, local_scope
+            if target_type.char?
+              @type = Rubex::DataType::Char.new
+            elsif target_type.object?
+              @type = Rubex::DataType::RubyString.new
+              analyse_statement local_scope
+            else
+              raise Rubex::TypeError, "Cannot assign #{target_type} to string."
+            end
+          end
+
+          def analyse_statement local_scope
+            @type = Rubex::DataType::RubyString.new unless @type
+          end
+
+          def generate_evaluation_code code, local_scope
+            if @type.char?
+              @c_code = @name
+            else
+              @c_code = "rb_str_new2(\"#{@name[1]}\")"
+            end
+          end
+
+          def c_code local_scope
+            @c_code
+          end
+        end # class Char
+
+        class True < Literal::Base
+          def initialize name
+            super
+          end
+
+          def analyse_for_target_type target_type, local_scope
+            if target_type.object?
+              @type = Rubex::DataType::TrueType.new
+            else
+              @type = Rubex::DataType::CBoolean.new
+            end
+          end
+
+          def analyse_statement local_scope
+            @type = Rubex::DataType::TrueType.new
+          end
+
+          def c_code local_scope
+            if @type.object?
+              @name
+            else
+              "1"
+            end
+          end
+        end # class True
+
+        class False < Literal::Base
+          def initialize name
+            super
+          end
+
+          def analyse_for_target_type target_type, local_scope
+            if target_type.object?
+              @type = Rubex::DataType::FalseType.new
+            else
+              @type = Rubex::DataType::CBoolean.new
+            end
+          end
+
+          def analyse_statement local_scope
+            @type = Rubex::DataType::FalseType.new
+          end
+
+          def c_code local_scope
+            if @type.object?
+              @name
+            else
+              "0"
+            end
+          end
+        end # class False
+
+        class Nil < Literal::Base
+          def initialize name
+            super
+            @type = Rubex::DataType::NilType.new
+          end
+        end # class Nil
+
+        class CNull < Literal::Base
+          def initialize name
+            # Rubex treats NULL's dtype as void*
+            super
+            @type = Rubex::DataType::CPtr.new(Rubex::DataType::Void.new)
+          end
+        end # class CNull
+      end # module Literal
+    end # module Expression
+  end # module AST
+end # module Rubex