rucc 0.1.0

data/lib/rucc/parser/switch.rb

@@ -0,0 +1,117 @@
+require "rucc/case"
+
+module Rucc
+  class Parser
+    module Switch
+
+    private
+
+      # @return [Node]
+      def read_switch_stmt
+        expect!('(')
+        expr = Node.conv(read_expr)
+        ensure_inttype!(expr)
+        expect!(')')
+
+        e = @label_gen.next
+        v = []
+        with_switch_context(e) do
+          body = read_stmt
+          var = Node.ast_lvar(expr.ty, @tempname_gen.next, @localenv, @localvars)
+          v.push(Node.ast_binop(expr.ty, '=', var, expr))
+          @cases.each do |c|
+            v.push(make_switch_jump(var, c))
+          end
+          v.push(Node.ast_jump(@defaultcase ? @defaultcase : e))
+          if body
+            v.push(body)
+          end
+          v.push(Node.ast_dest(e))
+        end
+        Node.ast_compound_stmt(v)
+      end
+
+      def with_switch_context(brk, &block)
+        # Set switch context
+        ocases       = @cases
+        odefaultcase = @defaultcase
+        obreak       = @lbreak
+        @cases       = []
+        @defaultcase = nil
+        @lbreak      = brk
+
+        yield
+
+        # Restore switch context
+        @cases       = ocases
+        @defaultcase = odefaultcase
+        @lbreak      = obreak
+      end
+
+      # @param [Node] var
+      # @param [Case] c
+      # @return [Node]
+      def make_switch_jump(var, c)
+        if c.b == c.e
+          cond = Node.ast_binop(Type::INT, OP::EQ, var, Node.ast_inttype(Type::INT, c.b))
+        else
+          # [GNU] case i ... j is compiled to if (i <= cond && cond <= j) goto <label>.
+          x = Node.ast_binop(Type::INT, OP::LE, Node.ast_inttype(Type::INT, c.b), var)
+          y = Node.ast_binop(Type::INT, OP::LE, var, Node.ast_inttype(Type::INT, c.e))
+          cond = Node.ast_binop(Type::INT, OP::LOGAND, x, y)
+        end
+        Node.ast_if(cond, Node.ast_jump(c.label), nil)
+      end
+
+      # @return [Node]
+      def read_case_label(tok)
+        if !@cases
+          Util.errort!(tok, "stray case label")
+        end
+        label = @label_gen.next
+        b = read_intexpr
+        if next_token?(K::ELLIPSIS)
+          e = read_intexpr
+          expect!(':')
+          if b > e
+            Util.errort!(tok, "case region is not in correct order: #{b} ... #{e}")
+          end
+          @cases.push(Case.make_case(b, e, label))
+        else
+          expect!(':')
+          @cases.push(Case.make_case(b, b, label))
+        end
+        check_case_duplicates!
+        read_label_tail(Node.ast_dest(label))
+      end
+
+      # C11 6.8.4.2p3: No two case constant expressions have the same value.
+      def check_case_duplicates!
+        len = @cases.size
+        x = @cases[len - 1]
+        @cases[0..-2].each do |y|
+          if (x.e < y.b) || (y.e < x.b)
+            next
+          end
+          if (x.b == x.e)
+            raise "duplicate case value: #{x.b}"
+            # error("duplicate case value: %d", x->beg)
+          end
+          raise "duplicate case value: #{x.b} ... #{x.e}"
+          # error("duplicate case value: #{x.b} ... #{x.e}")
+        end
+      end
+
+      # @param [Token] tok
+      # @return [Node]
+      def read_default_label(tok)
+        expect!(':');
+        if @defaultcase
+          Util.errort!(tok, "duplicate default")
+        end
+        @defaultcase = @label_gen.next
+        read_label_tail(Node.ast_dest(@defaultcase))
+      end
+    end
+  end
+end

data/lib/rucc/parser/while.rb

@@ -0,0 +1,29 @@
+module Rucc
+  class Parser
+    module While
+
+    private
+
+      # @param [Token] tok
+      # @return [Node]
+      def read_while_stmt
+        expect!('(')
+        cond = read_boolean_expr
+        expect!(')')
+
+        b = @label_gen.next
+        e = @label_gen.next
+
+        body = nil  # declaration for ruby
+        with_jump_labels(b, e) { body = read_stmt }
+
+        v = []
+        v.push(Node.ast_dest(b))
+        v.push(Node.ast_if(cond, body, Node.ast_jump(e)))
+        v.push(Node.ast_jump(b))
+        v.push(Node.ast_dest(e))
+        Node.ast_compound_stmt(v)
+      end
+    end
+  end
+end

data/lib/rucc/pos.rb

@@ -0,0 +1,11 @@
+module Rucc
+  class Pos
+    # @param [Integer] line
+    # @param [Integer] column
+    def initialize(line, column)
+      @line = line
+      @column = column
+    end
+    attr_reader :line, :column
+  end
+end

data/lib/rucc/rmap.rb

@@ -0,0 +1,22 @@
+module Rucc
+  # RMap -- Map with recursive search
+  class RMap
+    # @param [RMap, NilClass] parent
+    def initialize(parent = nil)
+      @parent = parent
+      @hash = {}
+    end
+
+    def [](k)
+      v = @hash[k]
+      if v.nil? && !@parent.nil?
+        v = @parent[k]
+      end
+      v
+    end
+
+    def []=(k, v)
+      @hash[k] = v
+    end
+  end
+end

data/lib/rucc/s.rb

@@ -0,0 +1,9 @@
+module Rucc
+  module S
+    TYPEDEF  = "S::TYPEDEF"
+    EXTERN   = "S::EXTERN"
+    STATIC   = "S::STATIC"
+    AUTO     = "S::AUTO"
+    REGISTER = "S::REGISTER"
+  end
+end

data/lib/rucc/static_label_gen.rb

@@ -0,0 +1,15 @@
+module Rucc
+  class StaticLabelGen
+    def initialize
+      @id = 0  # [Integer]
+    end
+
+    # @param [String]
+    # @return [String]
+    def next(name)
+      static_label = ".S#{@id}.#{name}"
+      @id += 1
+      static_label
+    end
+  end
+end

data/lib/rucc/t.rb

@@ -0,0 +1,18 @@
+module Rucc
+  module T
+    IDENT   = "T::IDENT".freeze
+    KEYWORD = "T::KEYWORD".freeze
+    NUMBER  = "T::NUMBER".freeze
+    CHAR    = "T::CHAR".freeze
+    STRING  = "T::STRING".freeze
+    EOF     = "T::EOF".freeze
+    INVALID = "T::INVALID".freeze
+
+    # Only in preprocessor
+    NEWLINE     = "T::NEWLINE".freeze
+    SPACE       = "T::SPACE".freeze
+    MACRO_PARAM = "T::MACRO_PARAM".freeze
+
+    CPP_TOKENS = [NEWLINE, SPACE, MACRO_PARAM].freeze
+  end
+end

data/lib/rucc/tempname_gen.rb

@@ -0,0 +1,14 @@
+module Rucc
+  class TempnameGen
+    def initialize
+      @id = 0  # [Integer]
+    end
+
+    # @return [String]
+    def next
+      tempname = ".T#{@id}"
+      @id += 1
+      tempname
+    end
+  end
+end

data/lib/rucc/token.rb

@@ -0,0 +1,114 @@
+require "rucc/enc"
+require "rucc/k"
+require "rucc/op"
+require "rucc/t"
+
+module Rucc
+  class Token
+    # @param [T] kind
+    # @param [FileIO] file
+    # @param [Integer] count
+    # @param [Set] hideset
+    # @param [String, Keyword, Op] id
+    # @param [String] sval
+    # @param [Integer] c
+    # @param [ENC] enc
+    # @param [Boolean] is_vararg
+    # @param [Integer] position
+    def initialize(kind,
+                   file: nil,
+                   count: nil,             # Token number in a file, counting from 0
+                   line: nil, column: nil, # Token location in a file
+                   hideset: nil,           # used by the preprocessor for macro expansion
+                   space: false,           # true if the token has a leading space
+                   bol: nil,               # true if the token is at the beginning of a line
+                   id: nil,                           # KEYWORD
+                   sval: nil,      c: nil, enc: nil,  # STRING or CHAR
+                   is_vararg: nil, position: nil      # MACRO_PARAM
+                  )
+      @kind = kind
+      @file = file
+      @count = count
+      @line = line; @column = column
+      @hideset = hideset
+      @space = space
+      @bol = bol
+
+      # value
+      @id = id                                      # KEYWORD
+      @sval = sval;           @c = c; @enc = enc;   # STRING or CHAR
+      @is_vararg = is_vararg; @position = position  # MACRO_PARAM
+
+      # Flag representing completion of macro expansion
+      @expanded = false
+    end
+    attr_reader :kind, :id, :sval, :c, :enc, :space, :hideset, :file, :count, :line, :column, :bol, :is_vararg, :position, :expanded
+    attr_writer :kind, :id, :sval,     :enc, :space, :hideset,                :line, :column, :bol,                        :expanded
+
+    # @return [String]
+    def to_s
+      case kind
+      when T::IDENT
+        return sval
+      when T::KEYWORD
+        case self
+        when Operator, Keyword
+          return str
+        else
+          return "#{id}"
+        end
+      when T::CHAR
+        return "#{encoding_prefix(enc)}'#{Util.quote_char(c)}'"
+      when T::NUMBER
+        return sval
+      when T::STRING
+        return "#{encoding_prefix(enc)}\"#{Util.quote_cstring(sval)}\""
+      when T::EOF
+        return "(eof)"
+      when T::INVALID
+        return "#{c}"
+      when T::NEWLINE
+        return "(newline)"
+      when T::SPACE
+        return "(space)"
+      when T::MACRO_PARAM
+        return "(macro-param)"
+      else
+        raise "internal error: unknown token kind: #{kind}"
+      end
+    end
+
+  private
+
+    # @param [ENC]
+    def encoding_prefix(enc)
+      case enc
+      when ENC::CHAR16 then return "u"
+      when ENC::CHAR32 then return "U"
+      when ENC::UTF8   then return "u8"
+      when ENC::WCHAR  then return "L"
+      else                  return ""
+      end
+    end
+
+    class << self
+      # @param [Token] tok
+      # @param [String] id
+      # @return [Boolean]
+      def is_keyword?(tok, id)
+        tok.kind == T::KEYWORD && tok.id == id
+      end
+
+      # @param [Token] tok
+      # @param [String] s
+      # @return [Boolean]
+      def is_ident?(tok, s)
+        tok.kind == T::IDENT && tok.sval == s
+      end
+    end
+  end
+
+  Token::SPACE_TOKEN   = Token.new(T::SPACE)
+  Token::NEWLINE_TOKEN = Token.new(T::NEWLINE)
+  Token::EOF_TOKEN     = Token.new(T::EOF)
+end

data/lib/rucc/token_gen.rb

@@ -0,0 +1,68 @@
+require "rucc/token"
+
+module Rucc
+  class TokenGen
+    # @param [FileIOList] files
+    def initialize(files)
+      @files = files
+      @pos = nil
+    end
+    attr_reader :pos
+    attr_writer :pos
+
+    # @param [T] kind
+    # @param [Hash] value
+    # @return [Token]
+    def make_token(kind, value = {})
+      f = @files.current
+      Util.assert!{ !pos.nil? }
+      params = {
+        file: f,
+        count: f.ntok,
+        hideset: Set.new,
+        line: pos.line,
+        column: pos.column,
+      }
+      f.incr_ntok!
+      Token.new(kind, value.merge(params))
+    end
+
+    # @param [String] s
+    # @return [Token]
+    def make_number(s)
+      make_token(T::NUMBER, sval: s)
+    end
+
+    # @param [String] p
+    # @return [Token]
+    def make_ident(p)
+      make_token(T::IDENT, sval: p)
+    end
+
+    # @param [Integer] c
+    # @param [ENC] enc
+    # @return [Token]
+    def make_char(c, enc)
+      make_token(T::CHAR, c: c, enc: enc)
+    end
+
+    # @param [String] s
+    # @param [ENC] enc
+    # @return [Token]
+    def make_strtok(s, enc)
+      make_token(T::STRING, sval: s, enc: enc)
+    end
+
+    # @param [Char] id
+    # @return [Token]
+    def make_keyword(id)
+      make_token(T::KEYWORD, id: id)
+    end
+
+    # @param [Integer] c
+    # @return [Token]
+    def make_invalid(c)
+      make_token(T::INVALID, c: c)
+    end
+  end
+end

data/lib/rucc/type.rb

@@ -0,0 +1,304 @@
+require "rucc/kind"
+require "rucc/type/check"
+require "rucc/type/conv"
+
+module Rucc
+  class Type
+    extend Check
+    extend Conv
+
+    # @param [Kind] kind the kind of type
+    # @param [Integer] size
+    # @param [Integer] align
+    # @param [Boolean] usig true if unsigned
+    # @param [Integer] len array length
+    def initialize(kind,
+                   size: nil, align: nil, usig: nil, isstatic: nil,
+                   ptr: nil,                                             # Pointer or Array
+                   len: nil,                                             # Array
+                   fields: nil, offset: nil,                             # Struct
+                   is_struct: nil,                                       # true if Struct, false if Union
+                   bitoff: nil, bitsize: nil,                            # Bitfield
+                   rettype: nil, params: nil, hasva: nil, oldstyle: nil  # Function
+                  )
+      @kind = kind
+      @size = size; @align = align; @usig = usig; @isstatic = isstatic
+      @ptr = ptr                                                                  # Pointer or Array
+      @len = len                                                                  # Array
+      @fields = fields; @offset = offset                                          # Struct
+      @is_struct = is_struct                                                      # true if Struct, false if Union
+      @bitoff = bitoff; @bitsize = bitsize                                        # Bitfield
+      @rettype = rettype; @params = params; @hasva = hasva; @oldstyle = oldstyle  # Function
+    end
+    attr_reader :kind,
+                :size, :align, :usig, :isstatic,
+                :ptr,                                 # Pointer or Array
+                :len,                                 # Array
+                :fields, :offset,                     # Struct
+                :is_struct,                           # true if Struct, false if Union
+                :bitoff, :bitsize,                    # Bitfield
+                :rettype, :params, :hasva, :oldstyle  # Function
+    attr_writer :isstatic, :params, :hasva,
+                :size, :align, :usig,
+                :ptr,                                 # Pointer or Array
+                :len,                                 # Array
+                :fields, :offset,                     # Struct
+                :bitoff, :bitsize                     # Bitfield
+
+    # @return [String]
+    def to_s
+      to_s_impl({})
+    end
+
+    # @param [Hash] dict
+    # @return [String]
+    def to_s_impl(dict)
+      # TODO(south37) Consider nil case
+      # if (!ty)
+      #     return "(nil)";
+      case kind
+      when Kind::VOID    then return "void"
+      when Kind::BOOL    then return "_Bool"
+      when Kind::CHAR    then return decorate_int("char")
+      when Kind::SHORT   then return decorate_int("short")
+      when Kind::INT     then return decorate_int("int")
+      when Kind::LONG    then return decorate_int("long")
+      when Kind::LLONG   then return decorate_int("llong")
+      when Kind::FLOAT   then return "float"
+      when Kind::DOUBLE  then return "double"
+      when Kind::LDOUBLE then return "long double"
+      when Kind::PTR
+        return "*#{ptr.to_s_impl(dict)}"
+      when Kind::ARRAY
+        return "[#{len}]#{ptr.to_s_impl(dict)}"
+      when Kind::STRUCT
+        k = is_struct ? "struct" : "union"
+        if !dict[self.object_id].nil?
+          return "(#{k})"
+        end
+        dict[self.object_id] = true
+        if fields
+          s = "(#{k}"
+          fields.each do |_, fieldtype|
+            s << " (#{fieldtype.to_s_impl(dict)})"
+          end
+          s << ")"
+          return s
+        end
+        raise "Must not reach here"  # TODO(south37) Confirm occurance
+      when Kind::FUNC
+        s = "("
+        if params
+          s << params.map { |param| param.to_s_impl(dict) }.join(",")
+        end
+        s << ")=>#{rettype.to_s_impl(dict)}"
+        return s
+      else
+        return "(Unknown ty: #{kind})"
+      end
+    end
+
+    # @param [String] name
+    # @return [String]
+    def decorate_int(name)
+      u = usig ? "u" : ""
+      if bitsize && bitsize > 0
+        return "#{u}#{name}:#{bitoff}:#{bitoff + bitsize}"
+      end
+      "#{u}#{name}"
+    end
+
+    # @param [Type] tmpl
+    def replace_by!(tmpl)
+      tmpl.instance_variables.each do |ivar|
+        self.instance_variable_set(ivar, tmpl.instance_variable_get(ivar))
+      end
+    end
+
+    class << self
+      # @param [Type] ty
+      # @return [Type]
+      def make_ptr_type(ty)
+        Type.new(Kind::PTR,
+                 ptr:   ty,
+                 size:  8,
+                 align: 8)
+      end
+
+      # @param [Type] ty
+      # @param [Integer] len
+      # @return [Type]
+      def make_array_type(ty, len)
+        if len < 0
+          size = -1
+        else
+          size = ty.size * len
+        end
+        Type.new(Kind::ARRAY,
+                 ptr:   ty,
+                 size:  size,
+                 len:   len,
+                 align: ty.align)
+      end
+
+      # @param [Type] rettype
+      # @param [Array] paramtypes
+      # @param [Boolean] has_varargs
+      # @param [Boolean] oldstyle
+      # @return [Type]
+      def make_func_type(rettype, paramtypes, has_varargs, oldstyle)
+        Type.new(Kind::FUNC,
+                 rettype:  rettype,
+                 params:   paramtypes,
+                 hasva:    has_varargs,
+                 oldstyle: oldstyle)
+      end
+
+      # @param [Kind] kind
+      # @param [Boolean] usig
+      # @return [Type]
+      def make_numtype(kind, usig)
+        size = align =
+          case kind
+          when Kind::VOID    then 0
+          when Kind::BOOL    then 1
+          when Kind::CHAR    then 1
+          when Kind::SHORT   then 2
+          when Kind::INT     then 4
+          when Kind::LONG    then 8
+          when Kind::LLONG   then 8
+          when Kind::FLOAT   then 4
+          when Kind::DOUBLE  then 8
+          when Kind::LDOUBLE then 8
+          else
+            raise "internal error"
+          end
+        Type.new(kind, size: size, align: align, usig: usig)
+      end
+
+      # @return [Type]
+      def make_stub_type
+        Type.new(Kind::STUB, size: 0)
+      end
+
+      # @param [Boolean] is_struct
+      # @return [Type]
+      def make_rectype(is_struct)
+        Type.new(Kind::STRUCT, is_struct: is_struct)
+      end
+
+      # @param [ENC]
+      # @return [Type]
+      def char_type(enc)
+        case enc
+        when ENC::NONE, ENC::WCHAR
+          return Type::INT
+        when ENC::CHAR16
+          return Type::USHORT
+        when ENC::CHAR32
+          return Type::UINT
+        else
+          raise "internal error"
+        end
+      end
+
+      # @param [Type] t
+      # @param [Type] u
+      # @return [Boolean]
+      def same_arith_type(t, u)
+        t.kind == u.kind && t.usig == u.usig
+      end
+
+      # @param [Type] totype
+      # @param [Type] fromtype
+      def ensure_assignable!(totype, fromtype)
+        if (Type.is_arithtype(totype) || (totype.kind == Kind::PTR)) &&
+            (Type.is_arithtype(fromtype) || (fromtype.kind == Kind::PTR))
+          return
+        end
+        if is_same_struct?(totype, fromtype)
+          return
+        end
+        raise "incompatible kind: <#{totype}> <#{fromtype}>"
+      end
+
+      # @param [Type] a
+      # @param [Type] b
+      # @return [Boolean]
+      def is_same_struct?(a, b)
+        if a.kind != b.kind
+          return false
+        end
+
+        case a.kind
+        when Kind::ARRAY
+          return a.len == b.len && is_same_struct?(a.ptr, b.ptr)
+        when Kind::PTR
+          return is_same_struct?(a.ptr, b.ptr)
+        when Kind::STRUCT
+          if a.is_struct != b.is_struct
+            return false
+          end
+          ka = a.fields.values
+          kb = b.fields.values
+          if ka.size != kb.size
+            return false
+          end
+          ka.zip(kb).each do |(x, y)|
+            if !is_same_struct?(x, y)
+              return false
+            end
+          end
+          return true
+        else
+          return true
+        end
+      end
+
+      # @param [Type] a
+      # @param [Type] b
+      # @return [Boolean]
+      def type_compatible?(a, b)
+        if a.kind == Kind::STRUCT
+          return is_same_struct?(a, b)
+        end
+        if a.kind != b.kind
+          return false
+        end
+        if a.ptr && b.ptr
+          return type_compatible?(a.ptr, b.ptr)
+        end
+        if is_arithtype(a) && is_arithtype(b)
+          return same_arith_type(a, b)
+        end
+        true
+      end
+
+      # @param [Type, NilClass] ty
+      # @return [Type, NilClass]
+      def copy_incomplete_type(ty)
+        return nil if ty.nil?
+        (ty.len == -1) ? ty.dup : ty
+      end
+    end
+
+    # Objects representing basic types. All variables will be of one of these
+    # types or a derived type from one of them.
+    VOID    = Type.new(Kind::VOID,    size: 0, align: 0, usig: false)
+    BOOL    = Type.new(Kind::BOOL,    size: 1, align: 1, usig: true)
+    CHAR    = Type.new(Kind::CHAR,    size: 1, align: 1, usig: false)
+    SHORT   = Type.new(Kind::SHORT,   size: 2, align: 2, usig: false)
+    INT     = Type.new(Kind::INT,     size: 4, align: 4, usig: false)
+    LONG    = Type.new(Kind::LONG,    size: 8, align: 8, usig: false)
+    LLONG   = Type.new(Kind::LLONG,   size: 8, align: 8, usig: false)
+    UCHAR   = Type.new(Kind::CHAR,    size: 1, align: 1, usig: true)
+    USHORT  = Type.new(Kind::SHORT,   size: 2, align: 2, usig: true)
+    UINT    = Type.new(Kind::INT,     size: 4, align: 4, usig: true)
+    ULONG   = Type.new(Kind::LONG,    size: 8, align: 8, usig: true)
+    ULLONG  = Type.new(Kind::LLONG,   size: 8, align: 8, usig: true)
+    FLOAT   = Type.new(Kind::FLOAT,   size: 4, align: 4, usig: false)
+    DOUBLE  = Type.new(Kind::DOUBLE,  size: 8, align: 8, usig: false)
+    LDOUBLE = Type.new(Kind::LDOUBLE, size: 8, align: 8, usig: false)
+    ENUM    = Type.new(Kind::ENUM,    size: 4, align: 4, usig: false)
+  end
+end