rucc 0.1.0

data/lib/rucc/lexer/preprocessor/cond_incl.rb

@@ -0,0 +1,27 @@
+module Rucc
+  class Lexer
+    class Preprocessor
+      module CondInclCtx
+        THEN = "CondInclCtx::THEN"
+        ELIF = "CondInclCtx::ELIF"
+        ELSE = "CondInclCtx::ELSE"
+      end
+
+      class CondIncl
+        # @param [CondInclCtx]
+        # @param [String, NilClass] include_guard
+        # @param [FileIO, NilClass] file
+        # @param [Boolean] wastrue
+        def initialize(ctx, wastrue:)
+          @ctx = ctx
+          @wastrue = wastrue
+
+          @include_guard = nil
+          @file = nil
+        end
+        attr_reader :ctx, :wastrue, :include_guard, :file
+        attr_writer :ctx, :wastrue, :include_guard, :file
+      end
+    end
+  end
+end

data/lib/rucc/lexer/preprocessor/constructor.rb

@@ -0,0 +1,54 @@
+module Rucc
+  class Lexer
+    class Preprocessor
+      module Constructor
+        # @param [String] name
+        # @param [Token] value
+        def define_obj_macro(name, value)
+          @macros[name] = make_obj_macro([value])
+        end
+
+        # @param [<Token>] body
+        # @return [Macro]
+        def make_obj_macro(body)
+          Macro.new(M::OBJ, body: body)
+        end
+
+        # @param [<Token>] body
+        # @param [Integer] nargs
+        # @param [Boolean] is_varg
+        def make_func_macro(body, nargs, is_varg)
+          Macro.new(M::FUNC, body: body, nargs: nargs, is_varg: is_varg)
+        end
+
+        # @param [Proc] fn
+        def make_special_macro(fn)
+          Macro.new(M::SPECIAL, fn: fn)
+        end
+
+        # @param [Boolean] wastrue
+        def make_cond_incl(wastrue)
+          CondIncl.new(CondInclCtx::THEN, wastrue: wastrue)
+        end
+
+        # @param [Integer] position
+        # @param [Boolean] is_vararg
+        def make_macro_token(position, is_vararg)
+          Token.new(T::MACRO_PARAM,
+                    is_vararg: is_vararg,
+                    hideset: nil,
+                    position: position,
+                    space: false,
+                    bol: false,
+                   )
+        end
+
+        # @param [Token] tok
+        # @return [Token]
+        def copy_token(tok)
+          tok.dup
+        end
+      end
+    end
+  end
+end

data/lib/rucc/lexer/preprocessor/pragma.rb

@@ -0,0 +1,31 @@
+module Rucc
+  class Lexer
+    class Preprocessor
+      module Pragma
+
+      private
+
+        # @param [Token] tok
+        def parse_pragma_operand(tok)
+          s = tok.sval
+          case s
+          when "once"
+            path = File.expand_path(tok.file.name)
+            @once[path] = 1
+          when "enable_warning"
+            @enable_warning = true
+          when "disable_warning"
+            @enable_warning = false
+          else
+            Util.errort!(tok, "unknown #pragma: #{s}")
+          end
+        end
+
+        def read_pragma
+          tok = read_ident
+          parse_pragma_operand(tok)
+        end
+      end
+    end
+  end
+end

data/lib/rucc/lexer/preprocessor/special_macro.rb

@@ -0,0 +1,110 @@
+module Rucc
+  class Lexer
+    class Preprocessor
+      module SpecialMacro
+
+      private
+
+        def define_special_macros!
+          define_special_macro "__DATE__",          :handle_date_macro
+          define_special_macro "__TIME__",          :handle_time_macro
+          define_special_macro "__FILE__",          :handle_file_macro
+          define_special_macro "__LINE__",          :handle_line_macro
+          define_special_macro "_Pragma",           :handle_pragma_macro
+
+          # [GNU] Non-standard macros
+          define_special_macro "__BASE_FILE__",     :handle_base_file_macro
+          define_special_macro "__COUNTER__",       :handle_counter_macro
+          define_special_macro "__INCLUDE_LEVEL__", :handle_include_level_macro
+          define_special_macro "__TIMESTAMP__",     :handle_timestamp_macro
+        end
+
+        # @param [Symbol] fn handler name of special macro
+        def define_special_macro(name, fn)
+          # @param [Token] tok
+          handler = -> (tok) { self.send(fn, tok) }
+          @macros[name] = make_special_macro(handler)
+        end
+
+        ##
+        # Handlers
+        ##
+
+        # @param [Token] tmpl
+        def handle_date_macro(tmpl)
+          s = @now.strftime("%b %e %Y")
+          make_token_pushback(tmpl, T::STRING, s)
+        end
+
+        # @param [Token] tmpl
+        def handle_time_macro(tmpl)
+          s = @now.strftime("%T")
+          make_token_pushback(tmpl, T::STRING, s)
+        end
+
+        # @param [Token] tmpl
+        def handle_timestamp_macro(tmpl)
+          # [GNU] __TIMESTAMP__ is expanded to a string that describes the date
+          # and time of the last modification time of the current source file.
+          s = tmpl.file.mtime.strftime("%a %b %e %T %Y")
+          make_token_pushback(tmpl, T::STRING, s)
+        end
+
+        # @param [Token] tmpl
+        def handle_file_macro(tmpl)
+          make_token_pushback(tmpl, T::STRING, tmpl.file.name)
+        end
+
+        # @param [Token] tmpl
+        def handle_line_macro(tmpl)
+          make_token_pushback(tmpl, T::NUMBER, sprintf("%d", tmpl.file.line))
+        end
+
+        # @param [Token] tmpl
+        def handle_pragma_macro(tmpl)
+          expect!('(')
+          operand = read_token
+          if operand.kind != T::STRING
+            Util.errort!(operand, "_Pragma takes a string literal, but got #{operand}")
+          end
+          expect!(')')
+          parse_pragma_operand(operand)
+          make_token_pushback(tmpl, T::NUMBER, "1")
+        end
+
+        # @param [Token] tmpl
+        def handle_base_file_macro(tmpl)
+          make_token_pushback(tmpl, T::STRING, @impl.infile.name)
+        end
+
+        # @param [Token] tmpl
+        def handle_counter_macro(tmpl)
+          @counter ||= 0
+          i = @counter
+          make_token_pushback(tmpl, T::NUMBER, "%d" % i)
+          @counter += 1
+        end
+
+        # @param [Token] tmpl
+        def handle_include_level_macro(tmpl)
+          make_token_pushback(tmpl, T::NUMBER, "%d" % (@impl.stream_depth - 1))
+        end
+
+        ##
+        # Helper
+        ##
+
+        # @param [Token] tmpl
+        # @param [T] kind
+        # @param [String] sval
+        def make_token_pushback(tmpl, kind, sval)
+          tok = tmpl.dup
+          tok.kind = kind
+          tok.sval = sval
+          tok.enc = ENC::NONE
+          unget_token(tok)
+        end
+      end
+    end
+  end
+end

data/lib/rucc/libc.rb

@@ -0,0 +1,47 @@
+module Rucc
+  # Emulate libc
+  module Libc
+    class << self
+      # same with isspace in libc
+      # @param [Char] c
+      def isspace(c)
+        "\x20\x0c\x0a\x0d\x09\x0b".freeze.include?(c)
+      end
+
+      # same with isdigit in libc
+      # @param [Char] c
+      def isdigit(c)
+        "0123456789".freeze.include?(c)
+      end
+
+      # same with isdigit in libc
+      # @param [Char] c
+      def isxdigit(c)
+        "0123456789abcdefABCDEF".freeze.include?(c)
+      end
+
+      # same with isalpha in libc
+      # @param [Char] c
+      def isalpha(c)
+        "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ".freeze.include?(c)
+      end
+
+      # same with isalnum in libc
+      # @param [Char] c
+      def isalnum(c)
+        "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ".freeze.include?(c)
+      end
+
+      # TODO(south37) Impl same logic with ispunct in libc
+      # @param [Char] c
+      def ispunct(c)
+        '!"#$%&\'()*+,-./:;<=>?@[\]^_`{|}~'.include?(c)
+      end
+
+      # TODO(south37) Impl same logic with isprint in libc
+      def isprint(c)
+        isalnum(c) || ispunct(c) || isspace(c)
+      end
+    end
+  end
+end

data/lib/rucc/m.rb

@@ -0,0 +1,7 @@
+module Rucc
+  module M
+    OBJ     = "Macro::OBJ"
+    FUNC    = "Macro::FUNC"
+    SPECIAL = "Macro::SPECIAL"
+  end
+end

data/lib/rucc/macro.rb

@@ -0,0 +1,24 @@
+require "rucc/m"
+
+module Rucc
+  class Macro
+    # @param [M] kind
+    # @param [<Token>] body
+    # @param [Integer] nargs
+    # @param [Boolean] is_varg
+    # @param [Proc] fn used only for special macro
+    def initialize(kind,
+                   body: nil,
+                   nargs: nil,
+                   is_varg: nil,
+                   fn: nil
+                  )
+      @kind = kind
+      @body = body
+      @nargs = nargs
+      @is_varg = is_varg
+      @fn = fn
+    end
+    attr_reader :kind, :body, :nargs, :is_varg, :fn
+  end
+end

data/lib/rucc/node.rb

@@ -0,0 +1,530 @@
+require "rucc/node/conv"
+require "rucc/utf"
+
+module Rucc
+  module AST
+    LITERAL       = "AST::LITERAL"
+    LVAR          = "AST::LVAR"
+    GVAR          = "AST::GVAR"
+    TYPEDEF       = "AST::TYPEDEF"
+    FUNCALL       = "AST::FUNCALL"
+    FUNCPTR_CALL  = "AST::FUNCPTR_CALL"
+    FUNCDESG      = "AST::FUNCDESG"
+    FUNC          = "AST::FUNC"
+    DECL          = "AST::DECL"
+    INIT          = "AST::INIT"
+    CONV          = "AST::CONV"
+    ADDR          = "AST::ADDR"
+    DEREF         = "AST::DEREF"
+    IF            = "AST::IF"
+    TERNARY       = "AST::TERNARY"
+    DEFAULT       = "AST::DEFAULT"
+    RETURN        = "AST::RETURN"
+    COMPOUND_STMT = "AST::COMPOUND_STMT"
+    STRUCT_REF    = "AST::STRUCT_REF"
+    GOTO          = "AST::GOTO"
+    COMPUTED_GOTO = "AST::COMPUTED_GOTO"
+    LABEL         = "AST::LABEL"
+  end
+
+  # AST node
+  class Node
+    extend Conv
+
+    # @param [AST] kind
+    # @param [Type] ty
+    def initialize(kind,
+                   ty: nil,
+                   ival: nil,                               # Integer
+                   fval: nil, flabel: nil,                  # Float or double
+                   varname: nil,                            # Local/global variable
+                   loff: nil, lvarinit: nil,                # Local variable
+                   glabel: nil,                             # Global variable
+                   left: nil, right: nil,                   # Binary operator
+                   operand: nil,                            # Unary operator
+                   fname: nil,                              # Function call or function declaration
+                   args: nil, ftype: nil,                   # Function call
+                   fptr: nil,                               # Function pointer or function designator
+                   params: nil, localvars: nil, body: nil,  # Function declaration
+                   sval: nil, slabel: nil,                  # String
+                   declvar: nil, declinit: nil,             # Declaration
+                   initval: nil, initoff: nil, totype: nil, # Initializer
+                   cond: nil, thn: nil, els: nil,           # If statement or ternary operator
+                   label: nil, newlabel: nil,               # Goto and label
+                   retval: nil,                             # Return statement
+                   stmts: nil,                              # Compound statement
+                   struct: nil, field: nil, fieldtype: nil  # Struct reference
+                   )
+      @kind = kind
+      @ty = ty
+      @ival = ival                                             # Integer
+      @fval = fval; @flabel = flabel                           # Float or double
+      @varname = varname                                       # Local/global variable
+      @loff = loff; @lvarinit = lvarinit                       # Local variable
+      @glabel = glabel                                         # Global variable
+      @left = left; @right = right                             # Binary operator
+      @operand = operand                                       # Unary operator
+      @fname = fname                                           # Function call or function declaration
+      @args = args; @ftype = ftype                             # Function call
+      @fptr = fptr                                             # Function pointer or function designator
+      @params = params; @localvars = localvars; @body = body   # Function declaration
+      @sval = sval; @slabel = slabel                           # String
+      @declvar = declvar; @declinit = declinit                 # Declaration
+      @initval = initval; @initoff = initoff; @totype = totype # Initializer
+      @cond = cond; @thn = thn; @els = els                     # If statement or ternary operator
+      @label = label; @newlabel = newlabel                     # Goto and label
+      @retval = retval                                         # Return statement
+      @stmts = stmts                                           # Compound statement
+      @struct = struct; @field = field; @fieldtype = fieldtype # Struct reference
+    end
+    attr_reader :kind, :ty,
+                :ival,                       # Integer
+                :fval, :flabel,              # Float or double
+                :varname,                    # Local/global variable
+                :loff, :lvarinit,            # Local variable
+                :glabel,                     # Global variable
+                :left, :right,               # Binary operator
+                :operand,                    # Unary operator
+                :sval, :slabel,              # String
+                :fname,                      # Function
+                :args, :ftype,               # Function call
+                :fptr,                       # Function pointer or function designator
+                :params, :localvars, :body,  # Function Declaration
+                :declvar, :declinit,         # Declaration
+                :initval, :initoff, :totype, # Initializer
+                :cond, :thn, :els,           # If statement or ternary operator
+                :label, :newlabel,           # Goto and label
+                :retval,                     # Return statement
+                :stmts,                      # Compound statement
+                :struct, :field, :fieldtype  # Struct reference
+    attr_writer :ty, :flabel, :loff, :lvarinit, :slabel, :newlabel
+
+    # @return [String]
+    def to_s
+      case kind
+      when AST::LITERAL
+        case ty.kind
+        when Kind::CHAR
+          if    ival == "\n" then return "'\\n'"      # '\n'
+          elsif ival == "\\" then return "'\\\\'"     # '\\'
+          elsif ival == "\0" then return "'\\0'"      # '\0'
+          else                    return "'#{ival.chr}'"  # cf. 'a'
+          end
+        when Kind::INT
+          return ival.to_s
+        when Kind::FLOAT, Kind::DOUBLE, Kind::LDOUBLE
+          return fval.to_s
+        when Kind::LONG, Kind::LLONG
+          return "#{ival}L"
+        when Kind::ARRAY  # Consider string literal
+          return "\"#{Util.quote_cstring(sval)}\""
+        else
+          raise "internal error"
+        end
+      when AST::LABEL
+        return "#{label}:"
+      when AST::LVAR
+        s = "lv=#{varname}"
+        if lvarinit
+          s << "(#{lvarinit})"
+        end
+        return s
+      when  AST::GVAR
+        return "gv=#{varname}"
+      when AST::FUNCALL, AST::FUNCPTR_CALL
+        return "(#{ty})#{kind == AST::FUNCALL ? fname : Node.node_or_nil_to_s(node)}(#{args.map { |arg| Node.node_or_nil_to_s(arg) }.join(",")})"
+      when AST::FUNCDESG
+        return "(funcdesg #{fname})"
+      when AST::FUNC
+        return "(#{ty})#{fname}(#{params.map { |param| "#{param.ty} #{Node.node_or_nil_to_s(param)}" }.join(",")})#{Node.node_or_nil_to_s(body)}"
+      when AST::GOTO
+        return "goto(#{label})"
+      when AST::DECL
+        s = "(decl #{declvar.ty} #{declvar.varname}"
+        if declinit
+          s << " #{declinit.join(" ")}"
+        end
+        s << ")"
+        return s
+      when AST::INIT
+        return "#{initval}@#{initoff}"
+      when AST::CONV
+        return "(conv #{operand}=>#{ty})"
+      when AST::IF
+        s = "(if #{Node.node_or_nil_to_s(cond)} #{Node.node_or_nil_to_s(thn)}"
+        if els
+          s << " #{els}"
+        end
+        s << ")"
+        return s
+      when AST::TERNARY
+        return "(? #{Node.node_or_nil_to_s(cond)} #{Node.node_or_nil_to_s(thn)} #{Node.node_or_nil_to_s(els)})"
+      when AST::RETURN
+        return "(return #{retval})"
+      when AST::COMPOUND_STMT
+        return "{#{stmts.map { |stmt| "#{stmt};" }.join}}"
+      when AST::STRUCT_REF
+        return "#{struct}.#{field}"
+      when AST::ADDR            then return "(addr #{operand})"
+      when AST::DEREF           then return "(deref #{operand})"
+      when OP::SAL              then return "(<< #{left} #{right})"
+      when OP::SAR, OP::SHR     then return "(>> #{left} #{right})"
+      when OP::GE               then return "(>= #{left} #{right})"
+      when OP::LE               then return "(<= #{left} #{right})"
+      when OP::NE               then return "(!= #{left} #{right})"
+      when OP::PRE_INC          then return "(pre++ #{operand})"
+      when OP::PRE_DEC          then return "(pre-- #{operand})"
+      when OP::POST_INC         then return "(post++ #{operand})"
+      when OP::POST_DEC         then return "(post-- #{operand})"
+      when OP::LOGAND           then return "(and #{left} #{right})"
+      when OP::LOGOR            then return "(or #{left} #{right})"
+      when '!'                  then return "(! #{operand})"
+      when '&'                  then return "(& #{left} #{right})"
+      when '|'                  then return "(| #{left} #{right})"
+      when OP::CAST
+        return "((#{operand.ty})=>(#{ty}) #{operand})"
+      when OP::LABEL_ADDR
+        return "&&#{label}"
+      when OP::EQ
+        return "(== #{left} #{right})"
+      else
+        return "(#{kind} #{left} #{right})"
+      end
+
+      raise "Must not reach here!"
+    end
+
+    class << self
+      # @param [Node, NilClass] node
+      def node_or_nil_to_s(node)
+        return '(nil)' if node.nil?
+        node.to_s
+      end
+
+      # @param [Type] ty
+      # @param [Integer] val
+      def ast_inttype(ty, val)
+        Util.assert!{ val.is_a?(Integer) }
+        Node.new(AST::LITERAL, ty: ty, ival: val)
+      end
+
+      # @param [Type] ty
+      # @param [Double] val
+      # @return [Node]
+      def ast_floattype(ty, val)
+        Node.new(AST::LITERAL,
+                 ty: ty,
+                 fval: val)
+      end
+
+      # @param [ENC] enc
+      def ast_string(enc, str)
+        case enc
+        when ENC::NONE, ENC::UTF8
+          ty = Type.make_array_type(Type::CHAR, str.bytes.size + 1)
+          body = str
+        when ENC::CHAR16
+          b = UTF.to_utf16(str)
+          ty = Type.make_array_type(Type::USHORT, (b.bytes.size / Type::USHORT.size) + 1)
+          body = b + "\0"  # NOTE: Add only \0 (\0\0 - \0)
+        when ENC::CHAR32, ENC::WCHAR
+          b = UTF.to_utf32(str)
+          ty = Type.make_array_type(Type::UINT, (b.bytes.size / Type::UINT.size) + 1)
+          body = b + "\0\0\0"  # NOTE: Add only \0\0\0 (\0\0\0\0 - \0)
+        else
+          raise "Invalid encoding"
+        end
+        Node.new(AST::LITERAL,
+                 ty:   ty,
+                 sval: body)
+      end
+
+      # @param [Type] ty
+      # @param [String] fname
+      # @param [Array] params
+      # @param [Node] body
+      # @param [Array] localvars
+      # @return [Node]
+      def ast_func(ty, fname, params, body, localvars)
+        Node.new(AST::FUNC,
+                 ty:        ty,
+                 fname:     fname,
+                 params:    params,
+                 localvars: localvars,
+                 body:      body)
+      end
+
+      # @param [Node] fptr
+      # @param [<Node>] args
+      # @return [Node]
+      def ast_funcptr_call(fptr, args)
+        Util.assert!{ fptr.ty.kind == Kind::PTR }
+        Util.assert!{ fptr.ty.ptr.kind == Kind::FUNC }
+        Node.new(AST::FUNCPTR_CALL,
+                 ty:   fptr.ty.ptr.rettype,
+                 fptr: fptr,
+                 args: args)
+      end
+
+      # @param [Type] ty
+      # @param [String] fname
+      def ast_funcdesg(ty, fname)
+        Node.new(AST::FUNCDESG,
+                 ty: ty,
+                 fname: fname)
+      end
+
+      # @param [Type] ftype
+      # @param [String] fname
+      # @param [Array] args
+      # @return [Node]
+      def ast_funcall(ftype, fname, args)
+        Node.new(AST::FUNCALL,
+                 ty:    ftype.rettype,
+                 fname: fname,
+                 args:  args,
+                 ftype: ftype)
+      end
+
+      # @param [String] kind
+      # @param [Type] ty
+      # @param [Node] operand
+      def ast_uop(kind, ty, operand)
+        Node.new(kind,
+                 ty:      ty,
+                 operand: operand)
+      end
+
+      # @param [Type] ty
+      # @param [String] kind
+      # @param [Node] left
+      # @param [Node] right
+      # @return [Node]
+      def ast_binop(ty, kind, left, right)
+        Node.new(kind,
+                 ty:    ty,
+                 left:  left,
+                 right: right)
+      end
+
+      # @param [String] op
+      # @param [Node] lhs
+      # @param [Node] rhs
+      # @return [Node]
+      def binop(op, lhs, rhs)
+        if (lhs.ty.kind == Kind::PTR) && (rhs.ty.kind == Kind::PTR)
+          if !valid_pointer_binop?(op)
+            raise "internal pointer arith"
+          end
+          # C11 6.5.6.9: Pointer subtractions have type ptrdiff_t.
+          if (op == '-'.freeze)
+            return Node.ast_binop(Type::LONG, op, lhs, rhs)
+          end
+          # C11 6.5.8.6, 6.5.9.3: Pointer comparisons have type int.
+          return Node.ast_binop(Type::INT, op, lhs, rhs);
+        end
+
+        # NOTE: Set pointer node as left
+        if lhs.ty.kind == Kind::PTR
+          return Node.ast_binop(lhs.ty, op, lhs, rhs)
+        end
+        if rhs.ty.kind == Kind::PTR
+          return Node.ast_binop(rhs.ty, op, rhs, lhs)
+        end
+
+        Util.assert!{ Type.is_arithtype(lhs.ty) }
+        Util.assert!{ Type.is_arithtype(rhs.ty) }
+        r = Type.usual_arith_conv(lhs.ty, rhs.ty)
+        Node.ast_binop(r, op, wrap(r, lhs), wrap(r, rhs))
+      end
+
+      # @param [OP] op
+      # @return [Boolean]
+      def valid_pointer_binop?(op)
+        case op
+        when '-', '<', '>', OP::EQ, OP::NE, OP::GE, OP::LE
+          return true
+        else
+          return false
+        end
+      end
+
+      # @param [Type] t
+      # @param [Node] node
+      # @return [Node]
+      def wrap(t, node)
+        if Type.same_arith_type(t, node.ty)
+          return node
+        end
+        Node.ast_uop(AST::CONV, t, node)
+      end
+
+      # @param [Node] cond
+      # @param [Node] thn
+      # @param [Node] els
+      # @return [Node]
+      def ast_if(cond, thn, els)
+        Node.new(AST::IF,
+                 cond: cond,
+                 thn: thn,
+                 els: els)
+      end
+
+      # @param [Type] ty
+      # @param [Node] cond
+      # @param [Node] thn
+      # @param [Node] els
+      # @return [Node]
+      def ast_ternary(ty, cond, thn, els)
+        Node.new(AST::TERNARY,
+                 ty:   ty,
+                 cond: cond,
+                 thn:  thn,
+                 els:  els)
+      end
+
+      # @param [String] label
+      # @return [Node]
+      def ast_label(label)
+        Node.new(AST::LABEL, label: label)
+      end
+
+      # @param [String] label
+      # @return [Node]
+      def ast_dest(label)
+        Node.new(AST::LABEL,
+                 label: label,
+                 newlabel: label)
+      end
+
+      # @param [String] label
+      def ast_label_addr(label)
+        Node.new(OP::LABEL_ADDR,
+                 ty:    Type.make_ptr_type(Type::VOID),
+                 label: label)
+      end
+
+      # @param [String] label
+      # @return [Node]
+      def ast_jump(label)
+        Node.new(AST::GOTO,
+                 label: label,
+                 newlabel: label)
+      end
+
+      # @param [String] label
+      # @return [Node]
+      def ast_goto(label)
+        Node.new(AST::GOTO,
+                 label: label)
+      end
+
+      # @param [Node] expr
+      # @return [Node]
+      def ast_computed_goto(expr)
+        Node.new(AST::COMPUTED_GOTO,
+                 operand: expr)
+      end
+
+      # @param [Node, NilClass] retval
+      def ast_return(retval)
+        Node.new(AST::RETURN,
+                 retval: retval)
+      end
+
+      # @param [Type] totype
+      # @param [Node] val
+      # @return [Node]
+      def ast_conv(totype, val)
+        Node.new(AST::CONV,
+                 ty:      totype,
+                 operand: val)
+      end
+
+      # @param [Node] var
+      # @param [Array] init
+      def ast_decl(var, init)
+        Node.new(AST::DECL,
+                 declvar:  var,
+                 declinit: init)
+      end
+
+      # @param [Node] val
+      # @param [Type] totype
+      # @param [Integer] off
+      # @return [Node]
+      def ast_init(val, totype, off)
+        Node.new(AST::INIT,
+                 initval: val,
+                 initoff: off,
+                 totype:  totype)
+      end
+
+      # @param [Array] stmts
+      # @return [Node]
+      def ast_compound_stmt(stmts)
+        Node.new(AST::COMPOUND_STMT, stmts: stmts)
+      end
+
+      # @param [Type] ty
+      # @param [String] name
+      # @return [Node]
+      def ast_typedef(ty, name, env)
+        r = Node.new(AST::TYPEDEF, ty: ty)
+        env[name] = r
+        r
+      end
+
+      # @param [Type] ty
+      # @param [Node] struct
+      # @param [String] name
+      # @return [Node]
+      def ast_struct_ref(ty, struct, name)
+        Node.new(AST::STRUCT_REF,
+                 ty:     ty,
+                 struct: struct,
+                 field:  name)
+      end
+
+      # @param [Type] ty
+      # @param [String] name
+      # @param [RMap] localenv
+      # @param [Array] localvars
+      # @return [Node]
+      def ast_lvar(ty, name, localenv, localvars)
+        r = Node.new(AST::LVAR, ty: ty, varname: name)
+        if localenv
+          localenv[name] = r
+        end
+        if localvars
+          localvars.push(r)
+        end
+        r
+      end
+
+      # @param [Type] ty
+      # @param [String] name
+      # @param [RMap] globalenv
+      def ast_gvar(ty, name, globalenv)
+        r = Node.new(AST::GVAR, ty: ty, varname: name, glabel: name)
+        globalenv[name] = r
+        r
+      end
+
+      # @param [Type] ty
+      # @param [String] name
+      # @param [RMap] localenv
+      # @param [String] glabel
+      # @return [String]
+      def ast_static_lvar(ty, name, localenv, glabel)
+        r = Node.new(AST::GVAR,
+                     ty: ty,
+                     varname: name,
+                     glabel: glabel)
+        Util.assert!{ localenv }
+        localenv[name] = r
+        r
+      end
+    end
+  end
+end