rucc 0.1.0

data/lib/rucc/parser/for.rb

@@ -0,0 +1,71 @@
+module Rucc
+  class Parser
+    module For
+      private
+      # @return [Node]
+      def read_for_stmt
+        expect!('(')
+        beg = @label_gen.next
+        mid = @label_gen.next
+        lst = @label_gen.next
+
+        orig = @localenv
+        @localenv = RMap.new(@localenv)
+        init = read_opt_decl_or_stmt
+        cond = read_expr_opt
+        if cond && Type.is_flotype(cond.ty)
+          cond = Node.ast_conv(Type::BOOL, cond)
+        end
+        expect!(';')
+        step = read_expr_opt
+        expect!(')')
+        body = nil  # declaration for ruby
+        with_jump_labels(mid, lst) { body = read_stmt }
+        @localenv = orig
+
+        v = []
+        if !init.nil?
+          v.push(init)
+        end
+        v.push(Node.ast_dest(beg))
+        if !cond.nil?
+          v.push(Node.ast_if(cond, nil, Node.ast_jump(lst)))
+        end
+        if !body.nil?
+          v.push(body)
+        end
+        v.push(Node.ast_dest(mid))
+        if !step.nil?
+          v.push(step)
+        end
+        v.push(Node.ast_jump(beg))
+        v.push(Node.ast_dest(lst))
+        Node.ast_compound_stmt(v)
+      end
+
+      # @param [String] cont
+      # @param [String] brk
+      def with_jump_labels(cont, brk)
+        # Set jump lablels
+        ocontinue = @lcontinue
+        obreak    = @lbreak
+        @lcontinue = cont
+        @lbreak    = brk
+
+        yield
+
+        # Restore jump lablels
+        @lcontinue = ocontinue
+        @lbreak    = obreak
+      end
+
+      # @return [Node, NilClass]
+      def read_opt_decl_or_stmt
+        return nil if next_token?(';')
+        list = []
+        read_decl_or_stmt(list)
+        Node.ast_compound_stmt(list)
+      end
+    end
+  end
+end

data/lib/rucc/parser/func.rb

@@ -0,0 +1,274 @@
+module Rucc
+  class Parser
+    module Func
+
+    private
+
+      # @param [Type] basety
+      # @param(return) [Array] params
+      # @return [Type]
+      def read_declarator_func(basety, params)
+        if basety.kind == Kind::FUNC
+          raise "function returning a function"
+        end
+        if basety.kind == Kind::ARRAY
+          raise "function returning an array"
+        end
+        read_func_param_list(params, basety)
+      end
+
+      # @param [Array, NilClass] paramvars
+      # @param [Type] rettype
+      # @return [Type]
+      def read_func_param_list(paramvars, rettype)
+        # C11 6.7.6.3p10: A parameter list with just "void" specifies that
+        # the function has no parameters.
+        tok = get
+        if Token.is_keyword?(tok, K::VOID) && next_token?(')')
+          return Type.make_func_type(rettype, [], false, false)
+        end
+
+        # C11 6.7.6.3p14: K&R-style un-prototyped declaration or
+        # function definition having no parameters.
+        # We return a type representing K&R-style declaration here.
+        # If this is actually part of a declartion, the type will be fixed later.
+        if Token.is_keyword?(tok, ')')
+          return Type.make_func_type(rettype, [], true, true)
+        end
+        @lexer.unget_token(tok)
+
+        tok2 = peek
+        if next_token?(K::ELLIPSIS)
+          Util.errort!(tok2, "at least one parameter is required before \"...\"")
+        end
+
+        if is_type?(peek)
+          paramtypes = []
+          ellipsis = read_declarator_params(paramtypes, paramvars)
+          return Type.make_func_type(rettype, paramtypes, ellipsis, false)
+        end
+
+        if paramvars.nil?
+          Util.errort!(tok, "invalid function definition")
+        end
+
+        read_declarator_params_oldstyle(paramvars)
+        paramtypes = []
+        (0..(paramvars.size - 1)).each do
+          paramtypes.push Type::INT
+        end
+        Type.make_func_type(rettype, paramtypes, false, true)
+      end
+
+      # @param [Array] types
+      # @param [Array] vars
+      # @return [Boolean] ellipsis
+      def read_declarator_params(types, vars)
+        typeonly = vars.nil?
+        ellipsis = false
+        while true
+          tok = peek
+          if next_token?(K::ELLIPSIS)
+            if types.size == 0
+              Util.errort!(tok, "at least one parameter is required before \"...\"")
+            end
+            expect!(')')
+            ellipsis = true
+            return ellipsis
+          end
+
+          name = ""
+          ty = read_func_param(name, typeonly)
+          ensure_not_void!(ty)
+          types.push(ty)
+          if !typeonly
+            vars.push(Node.ast_lvar(ty, name, @localenv, @localvars))
+          end
+
+          tok = get
+          if Token.is_keyword?(tok, ')')
+            return ellipsis
+          end
+          if !Token.is_keyword?(tok, ',')
+            Util.errort!(tok, "comma expected, but got #{tok}")
+          end
+        end
+        raise "must not reach here"
+      end
+
+      # @param [<String>] name
+      # @param [Boolean] optional
+      # @return [Type]
+      def read_func_param(name, optional)
+        basety = Type::INT
+        if is_type?(peek)
+          basety, _ = read_decl_spec
+        elsif optional
+          Util.errort!(peek, "type expected, but got #{peek}")
+        end
+        ty = read_declarator(name, basety, nil, optional ? DECL::PARAM_TYPEONLY : DECL::PARAM)
+        # C11 6.7.6.3p7: Array of T is adjusted to pointer to T
+        # in a function parameter list.
+        if ty.kind == Kind::ARRAY
+          return Type.make_ptr_type(ty.ptr)
+        end
+        # C11 6.7.6.3p8: Function is adjusted to pointer to function
+        # in a function parameter list.
+        if ty.kind == Kind::FUNC
+          return Type.make_ptr_type(ty)
+        end
+        ty
+      end
+
+      # Reads a K&R-style un-prototyped function parameter list.
+      #
+      # @param [<Node>] vars
+      def read_declarator_params_oldstyle(vars)
+        while true
+          tok = get
+          if tok.kind != T::IDENT
+            Util.errort!(tok, "identifier expected, but got #{tok}")
+          end
+          vars.push(Node.ast_lvar(Type::INT, tok.sval, @localenv, @localvars))
+          if next_token?(')')
+            return
+          end
+          if !next_token?(',')
+            Util.errort!(tok, "comma expected, but got #{get}")
+          end
+        end
+      end
+
+      #
+      # Function definition
+      #
+
+      # @return [Node]
+      def read_funcdef
+        basetype, sclass = read_decl_spec_opt
+        r = nil
+
+        with_func_context do
+          name = ""    # Used as return value
+          params = []  # Used as return value
+          functype = read_declarator(name, basetype, params, DECL::BODY)
+          if functype.oldstyle
+            if (params.size == 0)
+              functype.hasva = false
+            end
+            read_oldstyle_param_type(params)
+            functype.params = param_types(params)
+          end
+          functype.isstatic = (sclass == S::STATIC)
+          Node.ast_gvar(functype, name, @globalenv)
+          expect!('{')
+          r = read_func_body(functype, name, params)
+          backfill_labels!
+        end
+
+        r
+      end
+
+      def with_func_context(&block)
+        @localenv = RMap.new(@globalenv)
+        @gotos = []
+        @labels = RMap.new
+
+        yield
+
+        @localenv = nil
+        @gotos = nil
+        @labels = nil
+      end
+
+      # @param(return) [<Node>] params
+      def read_oldstyle_param_type(params)
+        vars = read_oldstyle_param_args
+        update_oldstyle_param_type(params, vars)
+      end
+
+      def read_oldstyle_param_args
+        orig = @localenv
+        @localenv = nil
+        r = []
+        while true
+          if Token.is_keyword?(peek, '{')
+            break
+          end
+          if !is_type?(peek)
+            Util.errort!(peek, "K&R-style declarator expected, but got #{peek}")
+          end
+          read_decl(r, false)
+        end
+        @localenv = orig
+        r
+      end
+
+      # @param(return) [Array] params
+      # @param [Node] vars
+      def update_oldstyle_param_type(params, vars)
+        vars.each do |decl|
+          Util.assert!{ decl.kind == AST::DECL }
+          var = decl.declvar
+          Util.assert!{ var.kind == AST::LVAR }
+          params.each do |param|
+            Util.assert!{ param.kind == AST::LVAR }
+            if (param.varname != var.varname)
+              next
+            end
+            param.ty = var.ty
+            return  # found
+          end
+          raise "missing parameter: #{var.varname}"
+        end
+      end
+
+      def backfill_labels!
+        @gotos.each do |src|
+          label = src.label
+          dest = @labels[label]
+          if dest.nil?
+            raise "stray #{src.kind == AST::GOTO ? "goto" : "unary &&"}: #{label}"
+          end
+
+          if dest.newlabel
+            src.newlabel = dest.newlabel
+          else
+            src.newlabel = dest.newlabel = @label_gen.next
+          end
+        end
+      end
+
+      # @param [Type] functype
+      # @param [String] fname
+      # @param [Array] params
+      # @return [Node]
+      def read_func_body(functype, fname, params)
+        r = nil
+
+        with_func_body_context(functype) do
+          funcname = Node.ast_string(ENC::NONE, fname)
+          @localenv["__func__"] = funcname
+          @localenv["__FUNCTION__"] = funcname
+          body = read_compound_stmt
+          r = Node.ast_func(functype, fname, params, body, @localvars)
+        end
+
+        r
+      end
+
+      # @param [Type] functype
+      def with_func_body_context(functype, &block)
+        @localenv = RMap.new(@localenv)
+        @localvars = []
+        @current_func_type = functype
+
+        yield
+
+        @localenv = nil
+        @localvars = nil
+        @current_func_type = nil
+      end
+    end
+  end
+end

data/lib/rucc/parser/func_call.rb

@@ -0,0 +1,54 @@
+module Rucc
+  class Parser
+    module FuncCall
+
+    private
+
+      # @param [Node] fp
+      def read_funcall(fp)
+        if (fp.kind == AST::ADDR) && (fp.operand.kind == AST::FUNCDESG)
+          desg = fp.operand
+          args = read_func_args(desg.ty.params)
+          return Node.ast_funcall(desg.ty, desg.fname, args)
+        end
+        args = read_func_args(fp.ty.ptr.params)
+        Node.ast_funcptr_call(fp, args)
+      end
+
+      # @param [Array] params
+      # @return [Array]
+      def read_func_args(params)
+        args = []
+        i = 0
+        while true
+          break if next_token?(')')
+          arg = Node.conv(read_assignment_expr)
+          if i < params.size
+            paramtype = params[i]
+            i += 1
+          else
+            paramtype =
+              if Type.is_flotype(arg.ty)
+                Type::DOUBLE
+              elsif Type.is_inttype(arg.ty)
+                Type::INT
+              else
+                arg.ty
+              end
+          end
+          Type.ensure_assignable!(paramtype, arg.ty)
+          if paramtype.kind != arg.ty.kind
+            arg = Node.ast_conv(paramtype, arg)
+          end
+          args.push(arg)
+          tok = get
+          break if Token.is_keyword?(tok, ')')
+          if !Token.is_keyword?(tok, ',')
+            Util.errort(tok, "unexpected token: '#{tok}'")
+          end
+        end
+        args
+      end
+    end
+  end
+end

data/lib/rucc/parser/goto.rb

@@ -0,0 +1,29 @@
+module Rucc
+  class Parser
+    module Goto
+
+    private
+
+      # @return [Node]
+      def read_goto_stmt
+        if next_token?('*')
+          # [GNU] computed goto. "goto *p" jumps to the address pointed by p.
+          tok = peek
+          expr = read_cast_expr
+          if expr.ty.kind != Kind::PTR
+            Util.errort!(tok, "pointer expected for computed goto, but got #{expr}")
+          end
+          return Node.ast_computed_goto(expr)
+        end
+        tok = get
+        if !tok || (tok.kind != T::IDENT)
+          Util.errort!(tok, "identifier expected, but got #{tok}")
+        end
+        expect!(';')
+        r = Node.ast_goto(tok.sval)
+        @gotos.push(r)
+        r
+      end
+    end
+  end
+end

data/lib/rucc/parser/if.rb

@@ -0,0 +1,23 @@
+module Rucc
+  class Parser
+    module If
+    private
+      def read_if_stmt
+        expect!('(')
+        cond = read_boolean_expr
+        expect!(')')
+        thn = read_stmt
+        if !next_token?(K::ELSE)
+          return Node.ast_if(cond, thn, nil)
+        end
+        els = read_stmt
+        Node.ast_if(cond, thn, els)
+      end
+
+      def read_boolean_expr
+        cond = read_expr
+        Type.is_flotype(cond.ty) ? Node.ast_conv(Type::BOOL, cond) : cond
+      end
+    end
+  end
+end