rubex 0.0.1 → 0.1

data/lib/rubex/ast/node.rb

@@ -1,47 +1,206 @@
 module Rubex
   module AST
     class Node
+      include Rubex::Helpers::Writers
       attr_reader :statements
 
       def initialize statements
-        @statements = statements.is_a?(Array) ? statements : [statements]
-      end
-
-      def add_child child
-        @statements.concat child
+        @statements = statements.flatten
       end
 
       def process_statements target_name, code
-        @scope = Rubex::SymbolTable::Scope::Klass.new 'Object'
-        generate_symbol_table_entries
-        analyse_expressions
+        @scope = Rubex::SymbolTable::Scope::Klass.new 'Object', nil
+        add_top_statements_to_object_scope
+        analyse_statement
+        rescan_declarations @scope
         generate_preamble code
         generate_code code
         generate_init_method target_name, code
       end
 
-      # Pretty print the AST
-      def pp
-        # TODO
+      def == other
+        self.class == other.class
       end
 
-     private
+    private
+
+      # Scan all the statements that do not belong to any particular class
+      #   (meaning that they belong to Object) and add them to the Object class,
+      #   which becomes the class from which all other classes will inherit from.
+      def add_top_statements_to_object_scope
+        temp = []
+        combined_statements = []
+        @statements.each do |stmt|
+          if stmt.is_a?(TopStatement::Klass) || stmt.is_a?(TopStatement::CBindings)
+            if !temp.empty?
+              object_klass = TopStatement::Klass.new('Object', @scope, temp)
+              combined_statements << object_klass
+            end
+
+            combined_statements << stmt
+            temp = []
+          else
+            temp << stmt
+          end
+        end
+
+        if !temp.empty?
+          combined_statements << TopStatement::Klass.new('Object', @scope, temp)
+        end
+
+        @statements = combined_statements
+      end
 
       def generate_preamble code
         code << "#include <ruby.h>\n"
         code << "#include <stdint.h>\n"
-        code << "\n"
+        code << "#include <stdbool.h>\n"
+        @scope.include_files.each do |name|
+          if name[0] == '<' && name[-1] == '>'
+            code << "#include #{name}\n"
+          else
+            code << "#include \"#{name}\"\n"
+          end
+        end
+        write_usability_macros code
+        @statements.grep(Rubex::AST::TopStatement::Klass).each do |klass|
+          declare_types code, klass.scope
+        end
+        write_user_klasses code
+        write_global_variable_declarations code
+        write_function_declarations code
+        write_usability_functions code
+        code.nl
+      end
+
+      def write_global_variable_declarations code
+        @statements.each do |stmt|
+          if stmt.is_a?(TopStatement::Klass)
+            stmt.statements.each do |s|
+              if s.is_a?(TopStatement::MethodDef)
+                s.scope.global_entries.each do |g|
+                  code << "static #{g.type} #{g.c_name};"
+                  code.nl
+                end # .each
+              end # if
+            end # .each
+          end # if
+        end # .each
+      end
+
+      def write_user_klasses code
+        code.nl
+        @scope.ruby_class_entries.each do |klass|
+          code << "VALUE #{klass.c_name};"
+          code.nl
+        end
+      end
+
+      def write_usability_macros code
+        code.nl
+        code.c_macro Rubex::RUBEX_PREFIX + "INT2BOOL(arg) (arg ? Qtrue : Qfalse)"
+        code.nl
+      end
+
+      def write_usability_functions code
+        code.nl
+        write_char_2_ruby_str code
+      end
+
+      def write_char_2_ruby_str code
+        code << "VALUE #{Rubex::C_FUNC_CHAR2RUBYSTR}(char ch);"
+        code.nl
+        code << "VALUE #{Rubex::C_FUNC_CHAR2RUBYSTR}(char ch)"
+        code.block do
+          code << "char s[2];\n"
+          code << "s[0] = ch;\n"
+          code << "s[1] = '\\0';\n"
+          code << "return rb_str_new2(s);\n"
+        end        
       end
 
-      def generate_symbol_table_entries
+      def write_function_declarations code
+        @statements.each do |stmt|
+          if stmt.is_a?(Rubex::AST::TopStatement::Klass)
+            stmt.scope.ruby_method_entries.each do |entry|
+              code.write_ruby_method_header(
+                type: entry.type.type.to_s, c_name: entry.c_name)
+              code.colon
+            end
+
+            stmt.scope.c_method_entries.each do |entry|
+              if !entry.extern?
+                code.write_c_method_header(
+                  type: entry.type.type.to_s, 
+                  c_name: entry.c_name, 
+                  args: Helpers.create_arg_arrays(entry.type.arg_list))
+                code.colon
+              end
+            end
+          end
+        end
+      end
+
+      def analyse_statement
+        create_symtab_entries_for_top_statements
+        @statements.each do |stat|
+          stat.analyse_statement @scope
+        end
+      end
+
+      def create_symtab_entries_for_top_statements
         @statements.each do |stat|
-          stat.generate_symbol_table_entries @scope
+          if stat.is_a? Rubex::AST::TopStatement::Klass
+            name = stat.name
+            # The top level scope in Ruby is Object. The Object class's immediate
+            # ancestor is also Object. Hence, it is important to set the class
+            # scope and ancestor scope of Object as Object, and make sure that
+            # the same scope object is used for 'Object' class every single time
+            # throughout the compilation process.
+            if name != 'Object'
+              ancestor_entry = @scope.find(stat.ancestor)
+              if !ancestor_entry && Rubex::DEFAULT_CLASS_MAPPINGS[stat.ancestor]
+                ancestor_c_name = Rubex::DEFAULT_CLASS_MAPPINGS[stat.ancestor]
+                ancestor_scope = object_or_stdlib_klass_scope stat.ancestor
+                @scope.add_ruby_class(name: stat.ancestor, c_name: ancestor_c_name,
+                  scope: @scope, ancestor: nil, extern: true)
+              else
+                ancestor_scope = ancestor_entry&.type&.scope || @scope
+              end
+              klass_scope = Rubex::SymbolTable::Scope::Klass.new(
+                name, ancestor_scope)
+            else
+              ancestor_scope = @scope
+              klass_scope = @scope
+            end
+            c_name = c_name_for_class name
+
+            @scope.add_ruby_class(name: name, c_name: c_name, scope: klass_scope,
+              ancestor: ancestor_scope, extern: false)
+          end
+        end
+      end
+
+      def object_or_stdlib_klass_scope name
+        name != 'Object' ? Rubex::SymbolTable::Scope::Klass.new(name, nil) : 
+          @scope
+      end
+
+      def c_name_for_class name
+        c_name =
+        if Rubex::DEFAULT_CLASS_MAPPINGS.has_key? name
+          Rubex::DEFAULT_CLASS_MAPPINGS[name]
+        else
+          Rubex::RUBY_CLASS_PREFIX + name
         end
+
+        c_name
       end
 
-      def analyse_expressions
+      def rescan_declarations scope
         @statements.each do |stat|
-          stat.analyse_expressions @scope
+          stat.respond_to?(:rescan_declarations) and
+            stat.rescan_declarations(@scope)
         end
       end
 
@@ -54,18 +213,57 @@ module Rubex
       def generate_init_method target_name, code
         name = "Init_#{target_name}"
         code.new_line
-        code.write_func_declaration "void", name, "void"
-        code.write_func_definition_header "void", name, "void"
+        code.write_func_declaration type: "void", c_name: name, args: [], static: false
+        code.write_c_method_header type: "void", c_name: name, args: [], static: false
+        code.block do
+          @statements.each do |top_stmt|
+            if top_stmt.is_a?(TopStatement::Klass) && top_stmt.name != 'Object'
+              entry = @scope.find top_stmt.name
+              code.declare_variable type: "VALUE", c_name: entry.c_name
+            end
+          end
+          code.nl
 
-        @statements.each do |stat|
-          if stat.is_a? Rubex::AST::RubyMethodDef
-            code.define_instance_method_under @scope, stat.name, stat.c_name
+          @statements.each do |top_stmt|
+            # define a class
+            if top_stmt.is_a?(TopStatement::Klass) && top_stmt.name != 'Object'
+              entry = top_stmt.entry
+              ancestor_entry = @scope.find top_stmt.ancestor.name
+              c_name = ancestor_entry ? ancestor_entry.c_name : 'rb_cObject'
+              rhs = "rb_define_class(\"#{entry.name}\", #{c_name})"
+              code.init_variable lhs: entry.c_name, rhs: rhs
+            end
+
+            # specify allocation method in case of attached class
+            if top_stmt.is_a?(TopStatement::AttachedKlass)
+              entry = top_stmt.entry
+              scope = top_stmt.scope
+              alloc = ""
+              alloc << "rb_define_alloc_func(#{entry.c_name}, "
+              alloc << "#{scope.find(TopStatement::AttachedKlass::ALLOC_FUNC_NAME).c_name});\n"
+
+              code << alloc
+            end
           end
-        end
+          code.nl
 
-        code << "\n"
-        code << "}\n"
+          @statements.each do |top_stmt|
+            if top_stmt.is_a? TopStatement::Klass
+              entry = @scope.find top_stmt.name
+              klass_scope = entry.type.scope
+              klass_scope.ruby_method_entries.each do |meth|
+                if meth.singleton?
+                  code.write_singleton_method klass: entry.c_name,
+                    method_name: meth.name, method_c_name: meth.c_name
+                else
+                  code.write_instance_method klass: entry.c_name, 
+                    method_name: meth.name, method_c_name: meth.c_name
+                end
+              end
+            end
+          end
+        end
       end
-    end
-  end
-end
+    end # class Node
+  end # module AST
+end # module Rubex

data/lib/rubex/ast/statement.rb

@@ -1,54 +1,1181 @@
+include Rubex::DataType
+
 module Rubex
   module AST
-    class Statement
-      class Return
-        attr_reader :expression, :return_type
+    module Statement
+      class Base
+        include Rubex::Helpers::NodeTypeMethods
 
-        def initialize expression
-          @expression = expression
+        # File name and line number of statement in "file_name:lineno" format.
+        attr_reader :location
+
+        def initialize location
+          @location = location
+        end
+
+        def statement?; true; end
+
+        def == other
+          self.class == other.class
+        end
+
+        def generate_code code, local_scope
+          code.write_location @location
+        end
+      end # class Base
+
+      class CBaseType < Base
+        attr_reader :type, :name, :value
+
+        def initialize type, name, value=nil
+          @type, @name, @value = type, name, value
         end
 
-        def analyse_expression local_scope
-          case @expression
-          when Rubex::AST::Expression::Addition
-            left  = @expression.left
-            right = @expression.right
+        def == other
+          self.class == other.class &&
+          self.type == other.class  &&
+          self.name == other.name   &&
+          self.value == other.value
+        end
+
+        def analyse_statement local_scope
+          @type = Rubex::Helpers.determine_dtype @type
+        end
+      end # class CBaseType
+
+      class VarDecl < Base
+        # The name with which this particular variable can be identified with
+        #   in the symbol table.
+        attr_reader :name
+        attr_reader :type, :value
+
+        def initialize type, name, value, location
+          super(location)
+          @name, @value = name, value
+          @type = type
+        end
+
+        def analyse_statement local_scope, extern: false
+          # TODO: Have type checks for knowing if correct literal assignment
+          # is taking place. For example, a char should not be assigned a float.
+          @type = Helpers.determine_dtype @type, ""
+          c_name = extern ? @name : Rubex::VAR_PREFIX + @name
+          if @value
+            @value.analyse_for_target_type(@type, local_scope)
+            @value.allocate_temp local_scope, @value.type
+            @value = Helpers.to_lhs_type(self, @value)
+            @value.release_temp local_scope
           end
 
-          left_type = local_scope[left].type
-          right_type = local_scope[right].type
+          local_scope.declare_var name: @name, c_name: c_name, type: @type,
+            value: @value, extern: extern
+        end
 
-          @return_type = result_type_for left_type, right_type
-          # TODO: Raise error if return_type is not compatible with the return
-          # type of the function.
+        def rescan_declarations scope
+          if @type.is_a? String
+            @type = Rubex::CUSTOM_TYPES[@type]
+            scope[@name].type = @type
+          end
         end
 
         def generate_code code, local_scope
-          code << "return "
-          case @expression
-          when Rubex::AST::Expression::Addition
-            left  = @expression.left
-            right = @expression.right
-            code << @return_type.to_ruby_function
-            code << "("
-            code << local_scope[left].c_name
-            code << " + "
-            code << local_scope[right].c_name
-            code << ")"
-            code << ";\n"
+          if @value
+            @value.generate_evaluation_code code, local_scope
+            lhs = local_scope.find(@name).c_name
+            code << "#{lhs} = #{@value.c_code(local_scope)};"
+            code.nl
+            @value.generate_disposal_code code
           end
         end
+      end # class VarDecl
+
+      class CPtrDecl < Base
+        attr_reader :entry, :type
+
+        # type - Specifies the type of the pointer. Is a string in case of a
+        # normal pointer denoting the data type and pointer level (like `int`
+        # for a pointerto an integer). Can be a Hash in case of func pointer
+        # declaration.
+        # name [String] - name of the variable.
+        def initialize type, name, value, ptr_level, location
+          super(location)
+          @name, @type, @value, @ptr_level  = name, type, value, ptr_level
+        end
+
+        def analyse_statement local_scope, extern: false
+          c_name = extern ? @name : Rubex::POINTER_PREFIX + @name
+          
+          if @type.is_a?(Hash) # function ptr
+            ident = @type[:ident]
+            ident[:arg_list].analyse_statement(local_scope, inside_func_ptr: true)
+            @type = DataType::CFunction.new(
+              @name,
+              c_name,
+              ident[:arg_list],
+              Helpers.determine_dtype(@type[:dtype], ident[:return_ptr_level]),
+              nil
+            )
+          end
+          @type = Helpers.determine_dtype @type, @ptr_level
+          if @value
+            @value.analyse_for_target_type(@type, local_scope)
+            @value = Helpers.to_lhs_type(self, @value)
+          end
 
-       private
+          @entry = local_scope.declare_var name: @name, c_name: c_name,
+            type: @type, value: @value, extern: extern
+        end
 
-        def result_type_for left_type, right_type
-          dtype = Rubex::DataType
+        # FIXME: This feels jugaadu. Try to scan all declarations before you
+        # scan individual statements.
+        def rescan_declarations local_scope
+          base_type = @entry.type.base_type
+          if base_type.is_a? String
+            type = Helpers.determine_dtype base_type, @ptr_level
+            local_scope[@name].type = type
+          end
+        end
 
-          if left_type.is_a?(dtype::CInt32) && right_type.is_a?(dtype::CInt32)
-            return dtype::CInt32.new
+        def generate_code code, local_scope
+          if @value
+            @value.generate_evaluation_code code, local_scope
+            code << "#{local_scope.find(@name).c_name} = #{@value.c_code(local_scope)};"
+            code.nl
+            @value.generate_disposal_code code
           end
         end
       end
-    end
-  end
-end
+
+      class CArrayDecl < Base
+        attr_reader :type, :array_list, :name, :dimension
+
+        def initialize type, array_ref, array_list, location
+          super(location)
+          @name, @array_list = array_ref.name, array_list
+          @dimension = array_ref.pos
+          @type = Rubex::TYPE_MAPPINGS[type].new
+        end
+
+        def analyse_statement local_scope, extern: false
+          @dimension.analyse_statement local_scope
+          create_symbol_table_entry local_scope
+          return if @array_list.nil?
+          analyse_array_list local_scope
+          verify_array_list_types local_scope
+        end
+
+        def generate_code code, local_scope
+
+        end
+
+        def rescan_declarations local_scope
+
+        end
+
+      private
+
+        def analyse_array_list local_scope
+          @array_list.each do |expr|
+            expr.analyse_statement(local_scope)
+          end
+        end
+
+        def verify_array_list_types local_scope
+          @array_list.all? do |expr|
+            return true if @type >= expr.type
+            raise "Specified type #{@type} but list contains #{expr.type}."
+          end
+        end
+
+        def create_symbol_table_entry local_scope
+          local_scope.add_carray(name: @name, c_name: Rubex::ARRAY_PREFIX + @name,
+            dimension: @dimension, type: @type, value: @array_list)
+        end
+      end # class CArrayDecl
+
+      class CStructOrUnionDef < Base
+        attr_reader :name, :declarations, :type, :kind, :entry, :scope
+
+        def initialize kind, name, declarations, location
+          super(location)
+          @declarations = declarations
+          if /struct/.match kind
+            @kind = :struct
+          elsif /union/.match kind
+            @kind = :union
+          end
+          @name = name
+        end
+
+        def analyse_statement outer_scope, extern: false
+          @scope = Rubex::SymbolTable::Scope::StructOrUnion.new(
+            @name, outer_scope)
+          if extern
+            c_name = @kind.to_s + " " + @name
+          else
+            c_name = Rubex::TYPE_PREFIX + @scope.klass_name + "_" + @name
+          end
+          @type = Rubex::DataType::CStructOrUnion.new(@kind, @name, c_name, 
+            @scope)
+
+          @declarations.each do |decl|
+            decl.analyse_statement @scope, extern: extern
+          end
+          Rubex::CUSTOM_TYPES[@name] = @type
+          @entry = outer_scope.declare_sue(name: @name, c_name: c_name,
+            type: @type, extern: extern)
+        end
+
+        def generate_code code, local_scope=nil
+
+        end
+
+        def rescan_declarations local_scope
+          @declarations.each do |decl|
+            decl.respond_to?(:rescan_declarations) and
+            decl.rescan_declarations(@scope)
+          end
+        end
+      end
+
+      class ForwardDecl < Base
+        attr_reader :kind, :name, :type, :c_name
+
+        def initialize kind, name, location
+          super(location)
+          @name = name
+          if /struct/.match kind
+            @kind = :struct
+          elsif /union/.match kind
+            @kind = :union
+          end
+          Rubex::CUSTOM_TYPES[@name] = @name
+        end
+
+        def analyse_statement local_scope, extern: false
+          @c_name = Rubex::TYPE_PREFIX + local_scope.klass_name + "_" + @name
+          @type = Rubex::DataType::TypeDef.new("#{@kind} #{@name}", @c_name, type)
+          local_scope.declare_type type: @type, extern: extern
+        end
+
+        def rescan_declarations local_scope
+          @type = Rubex::DataType::TypeDef.new("#{@kind} #{@name}", @c_name,
+            Rubex::CUSTOM_TYPES[@name])
+        end
+
+        def generate_code code, local_scope
+
+        end
+      end # class ForwardDecl
+
+      class Print < Base
+        # An Array containing expressions that are passed to the print statement.
+        #   Can either contain a single string containing interpolated exprs or
+        #   a set of comma separated exprs. For example, the print statement can
+        #   either be of like:
+        #     print "Hello #{a} world!"
+        #   OR
+        #     print "Hello", a, " world!"
+        attr_reader :expressions
+
+        def initialize expressions, location
+          super(location)
+          @expressions = expressions
+        end
+
+        def analyse_statement local_scope
+          @expressions.each do |expr|
+            expr.analyse_statement local_scope
+            expr.allocate_temps local_scope
+            expr.allocate_temp local_scope, expr.type
+            expr.release_temps local_scope
+            expr.release_temp local_scope
+          end
+        end
+
+        def generate_code code, local_scope
+          super
+          @expressions.each do |expr|
+            expr.generate_evaluation_code code, local_scope
+
+            str = "printf("
+            str << "\"#{expr.type.p_formatter}\""
+            str << ", #{inspected_expr(expr, local_scope)}"
+            str << ");"
+            code << str
+            code.nl
+
+            expr.generate_disposal_code code
+          end
+          
+          code.nl
+        end
+
+      private
+
+        def inspected_expr expr, local_scope
+          obj = expr.c_code(local_scope)
+          if expr.type.object?
+            "RSTRING_PTR(rb_funcall(#{obj}, rb_intern(\"inspect\"), 0, NULL))"
+          else
+            obj
+          end  
+        end
+      end # class Print
+
+      class Return < Base
+        attr_reader :expression, :type
+
+        def initialize expression, location
+          super(location)
+          @expression = expression
+        end
+
+        def analyse_statement local_scope
+          unless @expression
+            if local_scope.type.ruby_method?
+              @expression = Rubex::AST::Expression::Literal::Nil.new 'Qnil'
+            elsif local_scope.type.c_function?
+              @expression = Rubex::AST::Expression::Empty.new
+            end # FIXME: print a warning for type mismatch if none of above 
+          end
+
+          @expression.analyse_statement local_scope
+          @expression.allocate_temps local_scope
+          @expression.allocate_temp local_scope, @expression.type
+          @expression.release_temps local_scope
+          @expression.release_temp local_scope
+          t = @expression.type
+
+          @type =
+          if t.c_function? || t.alias_type?
+            t.type
+          else
+            t
+          end
+          @expression = @expression.to_ruby_object if local_scope.type.type.object?
+
+          # TODO: Raise error if type as inferred from the
+          # is not compatible with the return statement type.
+        end
+
+        def generate_code code, local_scope
+          super
+          @expression.generate_evaluation_code code, local_scope
+          code << "return #{@expression.c_code(local_scope)};"
+          code.nl
+        end
+      end # class Return
+
+      class Assign < Base
+        attr_reader :lhs, :rhs
+
+        def initialize lhs, rhs, location
+          super(location)
+          @lhs, @rhs = lhs, rhs
+        end
+
+        def analyse_statement local_scope
+          if @lhs.is_a?(Rubex::AST::Expression::Name)
+            @lhs.analyse_declaration @rhs, local_scope
+          else
+            @lhs.analyse_statement(local_scope)
+          end
+          @lhs.allocate_temps local_scope
+          @lhs.allocate_temp local_scope, @lhs.type
+
+          @rhs.analyse_for_target_type(@lhs.type, local_scope)
+          @rhs = Helpers.to_lhs_type(@lhs, @rhs)
+
+          @rhs.allocate_temps local_scope
+          @rhs.allocate_temp local_scope, @rhs.type
+
+          @lhs.release_temps local_scope
+          @lhs.release_temp local_scope
+          @rhs.release_temps local_scope
+          @rhs.release_temp local_scope
+        end
+
+        def generate_code code, local_scope
+          super
+          @rhs.generate_evaluation_code code, local_scope
+          @lhs.generate_assignment_code @rhs, code, local_scope
+          @rhs.generate_disposal_code code
+        end
+      end # class Assign
+
+      class IfBlock < Base
+        module Helper
+          def analyse_statement local_scope
+            @statements.each do |stat|
+              stat.analyse_statement local_scope
+            end
+
+            @if_tail.analyse_statement(local_scope) if @if_tail
+          end
+
+          def generate_code_for_statement stat, code, local_scope, node
+            if stat != "else"
+              condition = node.expr.c_code(local_scope)
+              expr_condition = node.expr.type.object? ? "RTEST(#{condition})" : condition
+              code << "#{stat} (#{expr_condition}) "
+            else
+              code << "#{stat}"
+            end
+
+            code.block do
+              node.statements.each do |stat|
+                stat.generate_code code, local_scope
+                code.nl
+              end
+            end
+
+            if stat != "else"
+              node.if_tail.generate_code(code, local_scope) if node.if_tail
+            end
+          end
+        end # module Helper
+
+        attr_reader :expr, :statements, :if_tail
+        include Rubex::AST::Statement::IfBlock::Helper
+
+        def initialize expr, statements, if_tail, location
+          super(location)
+          @expr, @statements, @if_tail = expr, statements, if_tail
+        end
+
+        def analyse_statement local_scope
+          @tail_exprs = if_tail_exprs
+          @tail_exprs.each do |tail|
+            tail.analyse_statement local_scope
+            tail.allocate_temps local_scope
+            tail.allocate_temp local_scope, tail.type
+          end
+          @tail_exprs.each do |tail|
+            tail.release_temps local_scope
+            tail.release_temp local_scope
+          end
+          super
+        end
+
+        def if_tail_exprs
+          tail_exprs = []
+          temp = self
+          while temp.respond_to?(:if_tail) && 
+            !temp.is_a?(Rubex::AST::Statement::IfBlock::Else)
+            tail_exprs << temp.expr
+            temp = temp.if_tail
+          end
+
+          tail_exprs
+        end
+
+        def generate_code code, local_scope
+          @tail_exprs.each do |tail|
+            tail.generate_evaluation_code(code, local_scope)
+          end
+          generate_code_for_statement "if", code, local_scope, self
+
+          tail = @if_tail
+          while tail
+            if tail.is_a?(Elsif)
+              generate_code_for_statement "else if", code, local_scope, tail
+            elsif tail.is_a?(Else)
+              generate_code_for_statement "else", code, local_scope, tail
+            end
+            tail = tail.if_tail
+          end
+
+          @tail_exprs.each do |tail|
+            tail.generate_disposal_code code
+          end
+        end
+
+        class Elsif < Base
+          attr_reader :expr, :statements, :if_tail
+          include Rubex::AST::Statement::IfBlock::Helper
+
+          def initialize expr, statements, if_tail, location
+            super(location)
+            @expr, @statements, @if_tail = expr, statements, if_tail
+          end
+
+          def generate_code code, local_scope
+          end
+        end # class Elsif
+
+        class Else < Base
+          attr_reader :statements
+          include Rubex::AST::Statement::IfBlock::Helper
+
+          def initialize statements, location
+            super(location)
+            @statements = statements
+          end
+
+          def analyse_statement local_scope
+            @statements.each do |stat|
+              stat.analyse_statement local_scope
+            end
+          end
+
+          def generate_code code, local_scope
+          end
+
+          def if_tail; nil; end
+        end # class Else
+      end # class IfBlock
+
+      class For < Base
+        attr_reader :left_expr, :left_op, :middle, :right_op, :right_expr,
+                    :statements, :order
+
+        def initialize left_expr, left_op, middle, right_op, right_expr,
+          statements, location
+          super(location)
+          @left_expr, @left_op, @middle, @right_op, @right_expr =
+            left_expr, left_op, middle, right_op, right_expr
+          @statements, @order = statements, order
+        end
+
+        def analyse_statement local_scope
+          @left_expr.analyse_statement local_scope
+          @right_expr.analyse_statement local_scope
+
+          [ @left_expr, @right_expr ].each do |e|
+            e.allocate_temps local_scope
+            e.allocate_temp local_scope, e.type
+          end
+          [ @left_expr, @right_expr ].each do |e|
+            e.release_temps local_scope
+            e.release_temp local_scope
+          end
+
+          @middle = local_scope[@middle] # middle will not be an expr.
+          @statements.each do |stat|
+            stat.analyse_statement local_scope
+          end
+        end
+
+        def generate_code code, local_scope
+          code << for_loop_header(code, local_scope)
+          code.block do
+            @statements.each do |stat|
+              stat.generate_code code, local_scope
+            end
+          end
+          @left_expr.generate_disposal_code code
+          @right_expr.generate_disposal_code code
+        end
+
+        private
+
+        def for_loop_header code, local_scope
+          @left_expr.generate_evaluation_code code, local_scope
+          @right_expr.generate_evaluation_code code, local_scope
+          for_stmt = ""
+          for_stmt << "for (#{@middle.c_name} = #{@left_expr.c_code(local_scope)}"
+
+          if @left_op == '<'
+            for_stmt << " + 1"
+          elsif @left_op == '>'
+            for_stmt << " - 1"
+          end
+
+          for_stmt << "; #{@middle.c_name} #{@right_op} #{@right_expr.c_code(local_scope)}; "
+          for_stmt << "#{@middle.c_name}"
+
+          if ['>', '>='].include? @right_op
+            for_stmt << "--"
+          elsif ['<', '<='].include? @right_op
+            for_stmt << "++"
+          end
+
+          for_stmt << ")"
+
+          for_stmt
+        end
+      end # class For
+
+      class While < Base
+        attr_reader :expr, :statements
+
+        def initialize expr, statements, location
+          super(location)
+          @expr, @statements = expr, statements
+        end
+
+        def analyse_statement local_scope
+          @expr.analyse_statement local_scope
+          @expr.allocate_temp local_scope, @expr.type
+          @expr.release_temp local_scope
+          @statements.each do |stat|
+            stat.analyse_statement local_scope
+          end
+        end
+
+        def generate_code code, local_scope
+          @expr.generate_evaluation_code code, local_scope
+          stmt = "while (#{@expr.c_code(local_scope)})"
+          code << stmt
+          code.block do
+            @statements.each do |stat|
+              stat.generate_code code, local_scope
+            end
+          end
+          @expr.generate_disposal_code code
+        end
+      end # class While
+
+      class Alias < Base
+        attr_reader :new_name, :type, :old_name
+
+        def initialize new_name, old_name, location
+          super(location)
+          @new_name, @old_name = new_name, old_name
+          Rubex::CUSTOM_TYPES[@new_name] = @new_name
+        end
+
+        def analyse_statement local_scope, extern: false
+          original  = @old_name[:dtype].gsub("struct ", "").gsub("union ", "")
+          var       = @old_name[:variables][0]
+          ident     = var[:ident]
+          ptr_level = var[:ptr_level]
+
+          base_type =
+          if ident.is_a?(Hash) # function pointer
+            cfunc_return_type = Helpers.determine_dtype(original,
+              ident[:return_ptr_level])
+            arg_list = ident[:arg_list].analyse_statement(local_scope,
+              inside_func_ptr: true)
+            ptr_level = "*" if ptr_level.empty?
+
+            Helpers.determine_dtype(
+              DataType::CFunction.new(nil, nil, arg_list, cfunc_return_type, nil),
+              ptr_level)
+          else
+            Helpers.determine_dtype(original, ptr_level)
+          end
+
+          @type = Rubex::DataType::TypeDef.new(base_type, @new_name, base_type)
+          Rubex::CUSTOM_TYPES[@new_name] = @type
+          local_scope.declare_type(type: @type, extern: extern) if original != @new_name
+        end
+
+        def generate_code code, local_scope
+
+        end
+      end # class Alias
+
+      class Expression < Base
+        attr_reader :expr
+        attr_accessor :typecast
+
+        def initialize expr, location
+          super(location)
+          @expr = expr
+        end
+
+        def analyse_statement local_scope
+          @expr.analyse_statement local_scope
+          @expr.allocate_temps local_scope
+          @expr.allocate_temp local_scope, @expr.type
+        end
+
+        def generate_code code, local_scope
+          super
+          @expr.generate_evaluation_code code, local_scope
+          code << @expr.c_code(local_scope) + ";"
+          code.nl
+          @expr.generate_disposal_code code
+        end
+      end # class Expression
+
+      class CFunctionDecl < Base
+        attr_reader :entry
+
+        def initialize type, return_ptr_level, name, arg_list
+          @type, @return_ptr_level, @name, @arg_list = type, return_ptr_level, 
+            name, arg_list
+        end
+
+        def analyse_statement local_scope, extern: false
+          @arg_list.analyse_statement(local_scope, extern: extern) if @arg_list
+          c_name = extern ? @name : (Rubex::C_FUNC_PREFIX + @name)
+          # type   = Rubex::DataType::CFunction.new(@name, c_name, @arg_list, 
+          #   Helpers.determine_dtype(@type, @return_ptr_level), nil)
+          @entry = local_scope.add_c_method(
+            name: @name,
+            c_name: c_name,
+            return_type: Helpers.determine_dtype(@type, @return_ptr_level),
+            arg_list: @arg_list,
+            scope: nil,
+            extern: extern)
+        end
+
+        def generate_code code, local_scope
+          super
+          code << "/* C function #{@name} declared.*/" if @entry.extern?
+        end
+      end # class CFunctionDecl
+
+      # This node is used for both formal and actual arguments of functions/methods.
+      class ArgumentList < Base
+        include Enumerable
+
+        # args - [ArgDeclaration]
+        attr_reader :args
+
+        def each &block
+          @args.each(&block)
+        end
+
+        def map! &block
+          @args.map!(&block)
+        end
+
+        def pop
+          @args.pop
+        end
+
+        def initialize args
+          @args = args
+        end
+
+        # func_ptr - switch that determines if this ArgList is part of the
+        # argument list of an argument that is a function pointer.
+        # For eg - 
+        #   cfunc int foo(int (*bar)(int, float)).
+        #                            ^^^ This is an arg list inside a function.
+        def analyse_statement local_scope, inside_func_ptr: false, extern: false
+          @args.each do |arg|
+            arg.analyse_statement(local_scope, inside_func_ptr: inside_func_ptr,
+              extern: extern)
+          end
+        end
+
+        def push arg
+          @args << arg
+        end
+
+        def << arg
+          push arg
+        end
+
+        def == other
+          self.class == other.class && @args == other.args
+        end
+
+        def size
+          @args.size
+        end
+
+        def empty?
+          @args.empty?
+        end
+
+        def [] idx
+          @args[idx]
+        end
+      end # class ArgumentList
+
+      class ActualArgList < ArgumentList
+        def analyse_statement local_scope
+          @args.each do |arg|
+            arg.analyse_statement local_scope
+          end
+        end
+
+        def allocate_temps local_scope
+          @args.each { |a| a.allocate_temp(local_scope, a.type) }
+        end
+
+        def release_temps local_scope
+          @args.each { |a| a.release_temp(local_scope) }
+        end
+
+        def generate_evaluation_code code, local_scope
+          @args.each do |a|
+            a.generate_evaluation_code code, local_scope
+          end
+        end
+
+        def generate_disposal_code code
+          @args.each do |a|
+            a.generate_disposal_code code
+          end
+        end
+      end # class ActualArgList
+
+      class Raise < Base
+        def initialize args
+          @args = args
+        end
+
+        def analyse_statement local_scope
+          @args.analyse_statement local_scope
+          @args.allocate_temps local_scope
+          @args.release_temps local_scope
+          unless @args.empty? || @args[0].is_a?(AST::Expression::Name) ||
+            @args[0].is_a?(AST::Expression::Literal::StringLit)
+            raise Rubex::TypeMismatchError, "Wrong argument list #{@args.inspect} for raise."
+          end
+        end
+
+        def generate_code code, local_scope
+          @args.generate_evaluation_code code, local_scope
+          str = ""
+          str << "rb_raise("
+
+          if @args[0].is_a?(AST::Expression::Name)
+            str << @args[0].c_code(local_scope) + ','
+            args = @args[1..-1]
+          else
+            str << Rubex::DEFAULT_CLASS_MAPPINGS["RuntimeError"] + ','
+            args = @args
+          end
+
+          unless args.empty?
+            str << "\"#{prepare_format_string(args)}\" ,"
+            str << args.map { |arg| "#{inspected_expr(arg, local_scope)}" }.join(',')
+          else
+            str << "\"\""
+          end
+          str << ");"
+          code << str
+          code.nl
+          @args.generate_disposal_code code
+        end
+
+      private
+
+        def prepare_format_string args
+          format_string = ""
+          args.each do |expr|
+            format_string << expr.type.p_formatter
+          end
+
+          format_string
+        end
+
+        def inspected_expr expr, local_scope
+          obj = expr.c_code(local_scope)
+          if expr.type.object?
+            "RSTRING_PTR(rb_funcall(#{obj}, rb_intern(\"inspect\"), 0, NULL))"
+          else
+            obj
+          end  
+        end
+      end # class Raise
+
+      class Break < Base
+        def analyse_statement local_scope
+          # TODO: figure whether this is a Ruby break or C break. For now
+          #   assuming C break.
+        end
+
+        def generate_code code, local_scope
+          code.write_location @location
+          code << "break;"
+          code.nl
+        end
+      end # class Break
+
+      class Yield < Base
+        def initialize args
+          @args = args
+        end
+
+        def analyse_statement local_scope
+          @args = @args.map do |arg|
+            arg.analyse_statement local_scope
+            arg.allocate_temps local_scope
+            arg.allocate_temp local_scope, arg.type
+            arg.to_ruby_object
+          end
+
+          @args.each do |arg|
+            arg.release_temps local_scope
+            arg.release_temp local_scope
+          end
+        end
+
+        def generate_code code, local_scope
+          @args.each do |a|
+            a.generate_evaluation_code code, local_scope
+          end
+
+          if @args.size > 0
+            code << "rb_yield_values(#{@args.size}, "
+            code << "#{@args.map { |a| a.c_code(local_scope) }.join(',')}"
+            code << ");"
+          else
+            code << "rb_yield(Qnil);"
+          end
+          code.nl
+
+          @args.each do |a|
+            a.generate_disposal_code code
+          end
+        end
+      end # class Yield
+
+      module BeginBlock
+        class Base < Statement::Base
+          attr_reader :statements
+
+          def initialize statements, location
+            @statements = statements
+            super(location)
+          end
+        end # class Base
+
+        class Begin < Base
+          def initialize statements, tails, location
+            @tails = tails
+            super(statements, location)
+          end
+
+          def analyse_statement local_scope
+            local_scope.found_begin_block
+            declare_error_state_variable local_scope
+            declare_error_klass_variable local_scope
+            declare_unhandled_error_variable local_scope
+            @block_scope = Rubex::SymbolTable::Scope::BeginBlock.new(
+              block_name(local_scope), local_scope)
+            create_c_function_to_house_statements local_scope.outer_scope
+            analyse_tails local_scope
+          end
+
+          def generate_code code, local_scope
+            code.nl
+            code << "/* begin-rescue-else-ensure-end block begins: */"
+            code.nl
+            super
+            cb_c_name = local_scope.find(@begin_func.name).c_name
+            state_var = local_scope.find(@state_var_name).c_name
+            code << "#{state_var} = 0;\n"
+            code << "rb_protect(#{cb_c_name}, Qnil, &#{state_var});"
+            code.nl
+            generate_rescue_else_ensure code, local_scope
+          end
+
+        private
+
+          def generate_rescue_else_ensure code, local_scope
+            err_state_var = local_scope.find(@error_var_name).c_name
+            set_error_state_variable err_state_var, code, local_scope
+            set_unhandled_error_variable code, local_scope
+            generate_rescue_blocks err_state_var, code, local_scope
+            generate_else_block code, local_scope
+            generate_ensure_block code, local_scope
+            generate_rb_jump_tag err_state_var, code, local_scope
+            code << "rb_set_errinfo(Qnil);\n"
+          end
+
+          def declare_unhandled_error_variable local_scope
+            @unhandled_err_var_name = "begin_block_" + local_scope.begin_block_counter.to_s + "_unhandled_error"
+            local_scope.declare_var(
+              name: @unhandled_err_var_name,
+              c_name: Rubex::VAR_PREFIX + @unhandled_err_var_name,
+              type: DataType::Int.new
+            )            
+          end
+
+          def set_unhandled_error_variable code, local_scope
+            n = local_scope.find(@unhandled_err_var_name).c_name
+            code << "#{n} = 0;"
+            code.nl
+          end
+
+          def generate_rb_jump_tag err_state_var, code, local_scope
+            state_var = local_scope.find(@state_var_name).c_name
+            code << "if (#{local_scope.find(@unhandled_err_var_name).c_name})"
+            code.block do
+              code << "rb_jump_tag(#{state_var});"
+              code.nl
+            end
+          end
+
+          def generate_ensure_block code, local_scope
+            ensure_block = @tails.select { |e| e.is_a?(Ensure) }[0]
+            ensure_block.generate_code(code, local_scope) unless ensure_block.nil?
+          end
+
+          # We use a goto statement to jump to the ensure block so that when a
+          # condition arises where no error is raised, the ensure statement will
+          # be executed, after which rb_jump_tag() will be called.
+          def generate_else_block code, local_scope
+            else_block = @tails.select { |t| t.is_a?(Else) }[0]
+            
+            code << "else"
+            code.block do
+                state_var = local_scope.find(@state_var_name).c_name
+                code << "/* If exception not among those captured in raise */"
+                code.nl
+
+                code << "if (#{state_var})"
+                code.block do
+                  code << "#{local_scope.find(@unhandled_err_var_name).c_name} = 1;"
+                  code.nl
+                end
+
+              if else_block
+                code << "else"
+                code.block do
+                  else_block.generate_code code, local_scope
+                end 
+              end
+            end
+          end
+
+          def set_error_state_variable err_state_var, code, local_scope
+            code << "#{err_state_var} = rb_errinfo();"
+            code.nl
+          end
+
+          def generate_rescue_blocks err_state_var, code, local_scope
+            if @tails[0].is_a?(Rescue)
+              generate_first_rescue_block err_state_var, code, local_scope
+              
+              @tails[1..-1].grep(Rescue).each do |resc|
+                else_if_cond = rescue_condition err_state_var, resc, code, local_scope
+                code << "else if (#{else_if_cond})"
+                code.block do
+                  resc.generate_code code, local_scope
+                end
+              end
+            else # no rescue blocks present
+              code << "if (0) {}\n"
+            end   
+          end
+
+          def generate_first_rescue_block err_state_var, code, local_scope
+            code << "if (#{rescue_condition(err_state_var, @tails[0], code, local_scope)})"
+            code.block do
+              @tails[0].generate_code code, local_scope
+            end
+          end
+
+          def rescue_condition err_state_var, resc, code, local_scope
+            resc.error_klass.generate_evaluation_code code, local_scope
+            cond = "RTEST(rb_funcall(#{err_state_var}, rb_intern(\"kind_of?\")"
+            cond << ", 1, #{resc.error_klass.c_code(local_scope)}))"
+
+            cond
+          end
+
+          def declare_error_state_variable local_scope
+            @state_var_name = "begin_block_" + local_scope.begin_block_counter.to_s + "_state"
+            local_scope.declare_var(
+              name: @state_var_name,
+              c_name: Rubex::VAR_PREFIX + @state_var_name,
+              type: DataType::Int.new
+            )
+          end
+
+          def declare_error_klass_variable local_scope
+            @error_var_name = "begin_block_" + local_scope.begin_block_counter.to_s + "_exec"
+            local_scope.declare_var(
+              name: @error_var_name,
+              c_name: Rubex::VAR_PREFIX + @error_var_name,
+              type: DataType::RubyObject.new
+            )
+          end
+
+          def block_name local_scope
+            "begin_block_" + local_scope.klass_name + "_" + local_scope.name + "_" +
+              local_scope.begin_block_counter.to_s
+          end
+
+          def create_c_function_to_house_statements scope
+            func_name = @block_scope.name
+            arg_list = Statement::ArgumentList.new([
+                AST::Expression::ArgDeclaration.new(
+                  { dtype:'object', variables: [{ident: 'dummy'}]})
+              ])
+            @begin_func = TopStatement::CFunctionDef.new(
+              'object', '', func_name, arg_list, @statements) 
+            arg_list.analyse_statement @block_scope
+            add_to_symbol_table @begin_func.name, arg_list, scope
+            @begin_func.analyse_statement @block_scope
+            @block_scope.upgrade_symbols_to_global
+            scope.add_begin_block_callback @begin_func
+          end
+
+          def add_to_symbol_table func_name, arg_list, scope
+            c_name = Rubex::C_FUNC_PREFIX + func_name
+            scope.add_c_method(
+              name: func_name, 
+              c_name: c_name, 
+              extern: false,
+              return_type: DataType::RubyObject.new,
+              arg_list: arg_list,
+              scope: @block_scope
+            )
+          end
+
+          def analyse_tails local_scope
+            @tails.each do |tail|
+              tail.analyse_statement local_scope
+            end
+          end
+        end # class Begin
+
+        class Else < Base
+          def analyse_statement local_scope
+            @statements.each do |stmt|
+              stmt.analyse_statement local_scope
+            end
+          end
+
+          def generate_code code, local_scope
+            @statements.each do |stmt|
+              stmt.generate_code code, local_scope
+            end
+          end
+        end # class Else
+
+        class Rescue < Base
+          attr_reader :error_klass
+
+          def initialize error_klass, error_obj, statements, location
+            super(statements, location)
+            @error_klass, @error_obj = error_klass, error_obj
+          end
+
+          def analyse_statement local_scope
+            @error_klass.analyse_statement local_scope
+            if !@error_klass.name.type.ruby_constant?
+              raise "Must pass an error class to raise. Location #{@location}."
+            end
+
+            @statements.each do |stmt|
+              stmt.analyse_statement local_scope
+            end
+          end
+
+          def generate_code code, local_scope
+            @statements.each do |stmt|
+              stmt.generate_code code, local_scope
+            end
+          end
+        end # class Rescue
+
+        class Ensure < Base
+          def analyse_statement local_scope
+            @statements.each do |stmt|
+              stmt.analyse_statement local_scope
+            end
+          end
+
+          def generate_code code, local_scope
+            @statements.each do |stmt|
+              stmt.generate_code code, local_scope
+            end
+          end
+        end # class Ensure
+      end # module BeginBlock
+    end # module Statement
+  end # module AST
+end # module Rubex