ctrump/parser/CAnalyzer.hpp

Go to the documentation of this file.

/*
 Copyright (c) 2009, National Institute of Advanced Industrial Science
 and Technology.  All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are
 met:
 
   * Redistributions of source code must retain the above copyright
     notice, this list of conditions and the following disclaimer.
 
   * Redistributions in binary form must reproduce the above copyright
     notice, this list of conditions and the following disclaimer in
     the documentation and/or other materials provided with the
     distribution.
 
   * Neither the name of Fixstars Corporation nor the names of its
     contributors may be used to endorse or promote products derived
     from this software without specific prior written permission.
 
 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT
 OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

#ifndef CFRONT_CANALYZER_HPP
#define CFRONT_CANALYZER_HPP

#include "AstCommon.hpp"
#include <antlr/ASTFactory.hpp>
#include <antlr/RecognitionException.hpp>
#include "GccIntegerAttribute.hpp"
#include "CTokenTypes.hpp"
#include "Environment.hpp"
#include "BasicType.hpp"
#include "PointerType.hpp"
#include "FunctionType.hpp"
#include "ArrayType.hpp"
#include "StructType.hpp"
#include "UnionType.hpp"
#include "EnumType.hpp"
#include "VectorType.hpp"
#include "TypedefType.hpp"
#include "CFrontError.hpp"

#include <cassert>
#include <sstream>
#include <vector>
#include <climits> /* FIXME */


namespace cfront {

class EvalFailedException: public std::exception {
public:
    EvalFailedException(int operatorType)
        : std::exception(), operatorType_(operatorType) {}
    int getOperatorType() const { return operatorType_; }
protected:
    int operatorType_;
};

struct DeclSpec {
    Type* type;
    NameDescription::StorageClassSpecTag ssTag;
    DeclSpec() : type(NULL), ssTag(NameDescription::SS_NONE) {}
};

enum PpuVectorExtTag {
    ALTIVEC_NONE,
    ALTIVEC_VECTOR,
    ALTIVEC_PIXEL,
    ALTIVEC_BOOL
};

enum AssignmentErrorTag {
    ASSIGN_ERR_NO_ERROR,
    ASSIGN_ERR_CONST,
    ASSIGN_ERR_INCOMPATIBLE,
    ASSIGN_ERR_INCOMPATIBLE_POINTER,
    ASSIGN_ERR_POINTER_FROM_INTEGER,
    ASSIGN_ERR_INTEGER_FROM_POINTER,
};

typedef std::vector<Extension*> Attributes;

typedef long long int eint;


class CAnalyzer {
public:
    void initialize()
    {
        supportVectorExt_ = true;
        //        initializeTypes();
        currentEnv_ = new Environment(NULL);
        currentFunctionType_ = NULL;
        nameCount_ = 0;
    }

    void setASTFactory(antlr::ASTFactory* astFactory)
    {
        astFactory_ = astFactory;
    }

    void setSupportVectorExtension(bool b)
    {
        supportVectorExt_ = b;
    }

    bool isSupportedVectorExt()
    {
        return supportVectorExt_;
    }

    bool isTypedefName(const std::string& name)
    {
        NameDescription* nd;
        Environment* env = currentEnv_->lookupOrdinaryName(name, &nd);
        if (env != NULL) {
#ifdef PARSER_DEBUG
            std::cout << "Search typedef name: " << name << " [" <<
                (nd->getStorageClassSpec() == NameDescription::TYPEDEF) 
                      << "]\n";
#endif
            return nd->getStorageClassSpec() == NameDescription::TYPEDEF;
        } else {
            //            if (true) {
            //                return isGccBuiltinName(name);
            //            } else {
                return false;
                //            }
        }
    }

    const Type* getOriginalType(const Type* t, bool withFuncArrPointerConv)
    {
        const Type* retType;
        const TypedefType* tyd = dynamic_cast<const TypedefType*>(t);
        if (tyd != NULL) {
            Type* qualifiedBaseType = tyd->getBaseType()->clone();
            addQualifier(qualifiedBaseType, tyd->getQualFlags());
            retType = getOriginalType(qualifiedBaseType,
                                      withFuncArrPointerConv);
        } else {
            retType = t;
        }
        if (withFuncArrPointerConv) {
            const FunctionType* ft = dynamic_cast<const FunctionType*>(retType);
            if (ft != NULL) {
                return new PointerType(ft, 0);
            }
            const ArrayType* at = dynamic_cast<const ArrayType*>(retType);
            if (at != NULL) {
                const Type* bt = getOriginalType(at->getBaseType(), true);
                return new PointerType(bt, 0);
            }
        }
        return retType;
    }

    std::string getDeclaratorName(const antlr::RefAST declNode) const
    {
        return declNode->toString();
    }

    Environment* getCurrentEnv() const
    {
        return currentEnv_;
    }

    void addEnv()
    {
        currentEnv_ = new Environment(currentEnv_);
    }

    Environment* removeEnv()
    {
        Environment* ret = currentEnv_;
        assert(ret != NULL);
        currentEnv_ = ret->getOuterEnv();
        return ret;
    }

    void setCurrentFunctionType(FunctionType* ft)
    {
        currentFunctionType_ = ft;
    }

    FunctionType* getCurrentFunctionType() const
    {
        return currentFunctionType_;
    }

    Type* buildPointerDeclaratorType(std::list<PointerType*>& pointerTypes,
                                     Type**& lastPointerType,
                                     Type* baseType)
    {
        if (pointerTypes.empty()) {
            return baseType;
        }
        Type* nextType = baseType;
        for (std::list<PointerType*>::reverse_iterator i =
                 pointerTypes.rbegin(); i != pointerTypes.rend(); ++i) {
            PointerType* t = *i;
            t->setBaseType(nextType);
            nextType = t;
        }
        if (lastPointerType != NULL) {
            *lastPointerType = pointerTypes.back();
        }
        return pointerTypes.front();
    }

    Type* buildDeclaratorPostfixType(std::list<Type*>& types, 
                                     Type**& lastType, Type* baseType)
    {
        if (types.empty()) {
            return baseType;
        }
        Type* nextType = baseType;
        for (std::list<Type*>::reverse_iterator i = types.rbegin();
             i != types.rend(); ++i) {
            Type* t = *i;
            ArrayType* at;
            FunctionType* ft;
            if ((at = dynamic_cast<ArrayType*>(t)) != NULL) {
                at->setBaseType(nextType);
            } else if ((ft = dynamic_cast<FunctionType*>(t)) != NULL) {
                ft->setReturnType(nextType);
            }
            nextType = t;
        }
        if (lastType != NULL && *lastType == NULL) {
            *lastType = types.back();
        }
        return types.front();
    }

    Type* buildCompositeDeclaratorType(Type* innerLastType,
                                       Type* innerDeclType, Type* baseType)
    {
        PointerType* pt = dynamic_cast<PointerType*>(innerLastType);
        if (pt != NULL) {
            pt->setBaseType(baseType);
            return innerDeclType;
        }
        FunctionType* ft = dynamic_cast<FunctionType*>(innerLastType);
        if (ft != NULL) {
            ft->setReturnType(baseType);
            return innerDeclType;
        }
        ArrayType* at = dynamic_cast<ArrayType*>(innerLastType);
        if (at != NULL) {
            at->setBaseType(baseType);
            return innerDeclType;
        } else {
            return baseType;
        }
    }

    void addQualifier(Type* t, QualFlags qflags)
    {
#define MERGE_QFS(t, qf) (t)->setQualFlags((t)->getQualFlags() | (qf))
        BasicType* bt = dynamic_cast<BasicType*>(t);
        if (bt != NULL) {
            MERGE_QFS(bt, qflags);
            return;
        }
        PointerType* pt = dynamic_cast<PointerType*>(t);
        if (pt != NULL) {
            MERGE_QFS(pt, qflags);
            return;
        }
        FieldInclusionType* ft = dynamic_cast<FieldInclusionType*>(t);
        if (ft != NULL) {
            MERGE_QFS(ft, qflags);
            return;
        }
        EnumType* et = dynamic_cast<EnumType*>(t);
        if (et != NULL) {
            MERGE_QFS(et, qflags);
            return;
        }
        TypedefType* tt = dynamic_cast<TypedefType*>(t);
        if (tt != NULL) {
            MERGE_QFS(tt, qflags);
            return;
        }
        VectorType* vt = dynamic_cast<VectorType*>(t);
        if (vt != NULL) {
            MERGE_QFS(vt, qflags);
            return;
        }
#undef MERGE_QFS
    }

    bool addNameAndType(const std::string& name, Type* t, 
                        NameDescription::StorageClassSpecTag ssTag,
                        NameDescription::DeclarationLocation dloc,
                        Attributes* attrs)
    {
        if (ssTag == NameDescription::TYPEDEF) {
#ifdef PARSER_DEBUG
            std::cout << "Added typedef name: " << name << std::endl;
#endif
            TypeDefinition* def = new TypeDefinition(t, name);
            t = new TypedefType(def);
        } else {
#ifdef PARSER_DEBUG
            std::cout << "Added ordinary name: " << name << " [" << 
                t->toString() << "]\n";
#endif
        }
#ifdef PARSER_DEBUG
        std::cout << currentEnv_->toString() << std::endl;
#endif
        NameDescription* nd;
        if (currentEnv_->addOrdinaryName(name, t, ssTag, dloc, &nd)) {
            if (attrs != NULL) {
                setVariableAttribute(nd, *attrs);
            }
            return true;
        } else {
            return false;
        }
    }

    void makeBasicType(Type** t, BasicType::PrimitiveTag primTypeTag)
    {
        if (*t != NULL) {
            delete *t;
        }
        *t = new BasicType(primTypeTag);
    }

    bool isGccBuiltinName(const std::string& name) const;

    Extension* parseGccAttribute(const std::string& name, RefNode paramNode,
                                 RefNode locationNode)
    {
        if (name == "aligned") {
            if (paramNode != NULL) {
                try {
                    eint v = evalConstExpr(antlr::RefAST(paramNode->getFirstChild()));
                    return new GccIntegerAttribute("aligned", v);
                } catch (const EvalFailedException& e) {
                }
            }
            WARNING((ctrump_error_code) -1, "syntax error of attribute `aligned'"
                    , logs_, locationNode);
        } else if (name == "packed" || name == "__packed__") {
            return new GccIntegerAttribute("packed", 1);
        } else if (name == "altivec") {
            if (paramNode->getType() == CTokenTypes::NAttributeParamIdentifier) {
                const std::string& vecName =
                    paramNode->getFirstChild()->getText();
                enum PpuVectorExtTag vt = ALTIVEC_NONE;
                if (vecName == "vector__") {
                    vt = ALTIVEC_VECTOR;
                } else if (vecName == "pixel__") {
                    vt = ALTIVEC_PIXEL;
                } else if (vecName == "bool__") {
                    vt = ALTIVEC_BOOL;
                } else {
                    WARNING((ctrump_error_code) -1, "ignored unknown altivec attribute"
                            , logs_, locationNode);
                }
                if (vt != ALTIVEC_NONE) {
                    return new GccIntegerAttribute("altivec", vt);
                }
                WARNING((ctrump_error_code) -1, "ignored unsupported altivec attribute"
                            , logs_, locationNode);
            }
        } else if (name == "spu_vector") {
            return new GccIntegerAttribute("spu_vector", 1);
        } else {
            WARNING((ctrump_error_code) -1, "ignored unknown attribute"
                    , logs_, locationNode);
        }
        return NULL;
    }

    void setVariableAttribute(NameDescription* nd, Attributes& attrs)
    {
        for (Attributes::iterator i = attrs.begin(); i != attrs.end(); ++i) {
            GccIntegerAttribute* gattr = dynamic_cast<GccIntegerAttribute*>(*i);
            if (gattr != NULL) {
                const std::string& name = gattr->getName();
                if (name == "aligned" || name == "packed") {
                    nd->addExtension(gattr);
                } else {
#ifdef PARSER_DEBUG
                    std::cout << "Ignored non-variable attribute `" << name 
                              << "'\n";
#endif
                }
            }
        }
    }

    Type* setTypeAttribute(Type* t, Attributes& attrs, RefNode locationNode)
    {
        Type* rt = t;
        for (Attributes::iterator i = attrs.begin(); i != attrs.end(); ++i) {
            GccIntegerAttribute* gattr = dynamic_cast<GccIntegerAttribute*>(*i);
            if (gattr != NULL) {
                const std::string& name = gattr->getName();
                if (name == "aligned" || name == "packed") {
                    t->addExtension(gattr);
                } else if (name == "altivec" || name == "spu_vector") {
                    BasicType* bt = dynamic_cast<BasicType*>(t);
                    if (bt == NULL) {
                        ERROR(CTRUMP_ERR_ILLEGAL_VECTOR_TYPE, "vector types must be a non-typedefed arithmetic type"
                              , logs_, locationNode);
                    }
                    BasicType::PrimitiveTag pt = bt->getPrimitiveTag();
                    if (name == "altivec") {
                        switch (gattr->getValue()) {
                        case ALTIVEC_VECTOR:
                            rt = new VectorType(pt);
                            break;
                        case ALTIVEC_BOOL:
                        case ALTIVEC_PIXEL:
                        default:
                            /* FIXME */
                            throw InternalError("setTypeAttribute: unsupported ALTIVEC type", &locationNode->getLocation());
                            break;
                        }
                    } else { /* name == "spu_vector" */
                        rt = new VectorType(pt);
                    }
                } else {
#ifdef PARSER_DEBUG
                    std::cout << "Ignored non-typed attribute `" << name 
                              << "'\n";
#endif
                }
            }
        }
        return rt;
    }

    FieldInclusionType*
    checkStructOrUnionDefinition(const std::string& name, bool isStruct,
                                 bool isDefinition, RefNode locationNode)
    {
        FieldInclusionType* ft = NULL;
        NameDescription* nd = NULL;
        Environment* foundEnv = currentEnv_->lookupTagName(name, &nd);
        if (foundEnv == NULL) {
            if (isStruct) {
                StructDefinition* def = new StructDefinition(name);
                ft = new StructType(def);
            } else {
                UnionDefinition* def = new UnionDefinition(name);
                ft = new UnionType(def);
            }
            currentEnv_->addTagName(name, ft, NameDescription::NONE); /* FIXME: dloc */
        } else {
            Type* t = nd->getType();
            if (isStruct) {
                StructType* st = dynamic_cast<StructType*>(t);
                if (st == NULL) {
                    ERROR1(CTRUMP_ERR_WRONG_TAG_NAME, "`%s' defined as wrong kind of tag"
                           , logs_, locationNode);
                }
                ft = st->clone();
            } else {
                UnionType* ut = dynamic_cast<UnionType*>(t);
                if (ut == NULL) {
                    ERROR1(CTRUMP_ERR_WRONG_TAG_NAME, "`%s' defined as wrong kind of tag"
                           , logs_, locationNode);
                }
                ft = ut->clone();
            }
            if (isDefinition && ! ft->getDefinition()->isIncomplete()) {
                ERROR1(CTRUMP_ERR_REDEFINITION_TAG, "redefinition of `%s'"
                       , logs_, locationNode);
            }
        }
        return ft;
    }

    void initializeTypes();

    std::string generateName()
    {
        std::stringstream ss;
        ss << "#" << nameCount_++;
        return ss.str();
    }

    static eint parseNumber(std::string::const_iterator& i, int base)
    {
        /* FIXME */
        char buf[256];
        int idx = 0;
        char c;
        while (isxdigit(c = *i)) { /* FIXME */
            buf[idx] = c;
            ++idx;
            ++i;
        }
        buf[idx] = '\0';
        return std::strtol(buf, NULL, base);
    }

    static eint parseEscape(std::string::const_iterator& i)
    {
        char c = *i;
        eint retVal;
        switch (c) {
        case 'a': retVal = '\007'; break;
        case 'b': retVal = '\b'; break;
        case 'f': retVal = '\f'; break;
        case 'n': retVal = '\n'; break;
        case 'r': retVal = '\r'; break;
        case 't': retVal = '\t'; break;
        case 'v': retVal = '\013'; break;
        case '"': retVal = '\"'; break;
        case '\'': retVal = '\''; break;
        case '\\': retVal = '\\'; break;
        case '?': retVal = '?'; break;
        /* universal character name */
        case 'u':
        case 'U':
            return parseNumber(++i, 16);
        case 'x':
            return parseNumber(++i, 16);
        default:
            if ('0' <= c && c <= '7') {
                return parseNumber(i, 8);
            }
            break;
        }
        ++i;
        return retVal;
    }

    void parseCharConst(RefNode cNode)
    {
        const std::string& litStr = cNode->getText();
        std::string::const_iterator i = litStr.begin();
        eint val = 0;
        if (*i == 'L') ++i;
        ++i; /* skip ' */
        if (*i == '\\') {
            val = parseEscape(++i);
        } else {
            val = *i;
        }
        cNode->getValueRef().signedValue.type = new BasicType(BasicType::SINT);
        cNode->getValueRef().signedValue.ival = val;
    }

    static void parseDoubleQuotedString(std::string::const_iterator& i,
                                        std::stringstream& ss)
    {
        assert(*i == '"');
        ++i;
        char c; /* FIXME */
        while ((c = *i) != '"') {
            if (*i == '\\') {
                ss << (char) parseEscape(++i);
            } else {
                ss << *i;
                ++i;
            }
        }
        ++i;
    }

    void parseStringConstant(RefNode sNode, std::stringstream& ss,
                             bool* isWide /* out */)
    {
        const std::string& litStr = sNode->getText();
        std::string::const_iterator i = litStr.begin();
        size_t len = litStr.size();
        assert(len >= 2);
        if (*i == 'L') {
            *isWide = true;
            ++i;
        }
        parseDoubleQuotedString(i, ss);
    }

    void parseIntegerConstant(RefNode intNode, int base)
    {
        std::string str = intNode->getText();
        char* endptr;
        long long val = strtoll(str.c_str(), &endptr, base);

        bool isUnsigned = false;
        unsigned int numLongPostfix = 0;
        char postfix;
        while ((postfix = *endptr) != '\0') {
            switch (postfix) {
            case 'U':
            case 'u':
                if (numLongPostfix != 0) {
                    /* error: like '123LU' */
                    ERROR1(CTRUMP_ERR_INVALID_CONSTANT, "invalid integer constant `%s'"
                          , logs_, intNode);
                } else {
                    isUnsigned = true;
                }
                break;
            case 'L':
            case 'l':
                numLongPostfix++;
                break;
            default:
                ERROR1(CTRUMP_ERR_INVALID_CONSTANT, "invalid integer constant `%s'"
                      , logs_, intNode);
            }
            ++endptr;
        }
        if (numLongPostfix > 2) {
            ERROR1(CTRUMP_ERR_INVALID_CONSTANT, "invalid integer constant `%s'"
                  , logs_, intNode);
        }

        /* FIXME */
        long long targetIntMax = INT_MAX;
        long long targetUintMax = UINT_MAX;
        long long targetLongMax = LONG_MAX;
        unsigned long long targetUlongMax = ULONG_MAX;
        unsigned long long targetLLongMax = LLONG_MAX;

        int ttype = intNode->getType();
        /* special case: octal int with value 0 is treated as a decimal int. */
        if (ttype == CTokenTypes::OctalIntConst && val == 0) {
            ttype = CTokenTypes::DecimalIntConst;
        }

        BasicType::PrimitiveTag pt = BasicType::NONE;
        if (ttype == CTokenTypes::DecimalIntConst && !isUnsigned) {
            if (numLongPostfix >= 1 || val > targetIntMax) {
                if (numLongPostfix == 2 || val > targetLongMax) {
                    pt = BasicType::SLLONG;
                    intNode->getValueRef().signedValue.ival = val;
                } else {
                    pt = BasicType::SLONG;
                    intNode->getValueRef().signedValue.ival = val;
                }
            } else {
                pt = BasicType::SINT;
                intNode->getValueRef().signedValue.ival = val;
            }
        } else if (ttype == CTokenTypes::OctalIntConst &&
                   ttype == CTokenTypes::HexadecimalIntConst &&
                   !isUnsigned) {
            if (numLongPostfix >= 1 || val > targetUintMax) {
                unsigned long long ullval = strtoull(str.c_str(), NULL, base);
                if (numLongPostfix == 2 || ullval > targetUlongMax) {
                    if (ullval > targetLLongMax) {
                        pt = BasicType::ULLONG;
                        intNode->getValueRef().unsignedValue.ival = val;
                    } else {
                        pt = BasicType::SLLONG;
                        intNode->getValueRef().signedValue.ival = val;
                    }
                } else if (val > targetLongMax) {
                    pt = BasicType::ULONG;
                    intNode->getValueRef().unsignedValue.ival = val;
                } else {
                    pt = BasicType::SLONG;
                    intNode->getValueRef().signedValue.ival = val;
                }
            } else if (val > targetIntMax) {
                pt = BasicType::UINT;
                intNode->getValueRef().unsignedValue.ival = val;
            } else {
                pt = BasicType::SINT;
                intNode->getValueRef().signedValue.ival = val;
            }
        } else {
            /* unsigned octal/decimal/hexadecimal constants */
            if (numLongPostfix >= 1 || val > targetUintMax) {
                unsigned long long ullval = strtoull(str.c_str(), NULL, base);
                if (numLongPostfix == 2 || ullval > targetUlongMax) {
                    pt = BasicType::ULLONG;
                    intNode->getValueRef().unsignedValue.ival = val;
                } else {
                    pt = BasicType::ULONG;
                    intNode->getValueRef().unsignedValue.ival = val;
                }
            } else {
                pt = BasicType::UINT;
                intNode->getValueRef().unsignedValue.ival = val;
            }
        }

        if (pt != BasicType::NONE) {
            intNode->getValueRef().signedValue.type = new BasicType(pt);
        } else {
            throw InternalError("parseIntegerConstant");
        }
    }

    bool isConstantZeroValue(RefNode constExprNode)
    {
        const Type* t = constExprNode->getValueRef().type;
        const BasicType* bt =
            dynamic_cast<const BasicType*>(getOriginalType(t, true));
        if (bt == NULL) {
            return false;
        }
        if (! BasicType::isIntegerTypeTag(bt->getPrimitiveTag())) {
            return false;
        }
        eint v;
        try {
            v = evalConstExpr(antlr::RefAST(constExprNode));
        } catch (const EvalFailedException& e) {
            return false;
        }
        return v == 0;
    }

    RefNode makeImplicitCastNode(RefNode expr,
                                 const Type* castTo, const Type* rand)
    {
#ifdef NO_IMPLICIT_CAST
        (void) castTo;
        (void) rand;
        return expr;
#else
        if (!castTo->isCompatibleType(rand)) {
            //RefNode n = #([NImplicitCast, "ICast"], expr);
            RefNode n = RefValueNode(astFactory_->make((new antlr::ASTArray(2))->add(antlr::RefAST(astFactory_->create(CTokenTypes::NImplicitCast,"ICast")))->add(antlr::RefAST(expr))));  
            n->getValueRef().type = castTo;
            return n;
        } else {
            return expr;
        }
#endif
    }

    const Type* getInitializerListElemType(const Type* listType, int elemIndex,
                                           RefNode locationNode)
    {
        const Type* ot = getOriginalType(listType, false);
        const ArrayType* at = dynamic_cast<const ArrayType*>(ot);
        if (at != NULL) {
            return at->getBaseType();
        }
        const StructType* st = dynamic_cast<const StructType*>(ot);
        if (st != NULL) {
            StructDefinition* sd =
                static_cast<StructDefinition*>(st->getDefinition());
            return sd->getNthFieldType(elemIndex);
        }
        const VectorType* vt = dynamic_cast<const VectorType*>(ot);
        if (vt != NULL) {
            /* treated as an array. */
            return new BasicType(vt->getPrimitiveTag());
        }
        if (elemIndex == 0) { // like: int a = {0};
            return listType;
        }
        /* FIXME : ctrump_error_code */
        WARNING((ctrump_error_code) -1, "excess elements in scalar initializer"
                , logs_, locationNode);
        return listType;
    }

    void checkArrayInitializer(Type* t, int numElems, RefNode locationNode)
    {
        ArrayType* at = dynamic_cast<ArrayType*>(t);
        if (at != NULL) {
            ArrayType::LengthSpec lspec = at->getLengthSpec();
            switch (lspec) {
            case ArrayType::NOT_SPECIFIED:
                at->setLengthValue(numElems);
                break;
            case ArrayType::FIXED:
                {
                    int len = at->getLengthValue();
                    if (numElems > len) {
                        /* warning ? */
                        ERROR(CTRUMP_ERR_EXCESS_INITIALIZER_ELEM, "excess elements in array initializer"
                              , logs_, locationNode);
                    }
                }
                break;
            case ArrayType::VARIABLE:
            case ArrayType::VARIABLE_NOT_SPECIFIED:
                ERROR(CTRUMP_ERR_VLA_WITH_INITIALIZER, "variable-sized object may not be initialized"
                      , logs_, locationNode);
                break;
            case ArrayType::INCOMPLETE:
                /* FIXME */
                break;
            }
        }
    }

    const Type* checkPointerArithmeticAdditive(const Type* pt, const Type* it)
    {
        const PointerType* pt1 = dynamic_cast<const PointerType*>(pt);
        if (pt1 != NULL && it->isIntegerType()) {
            return pt1->getBaseType();
        }
        return NULL;
    }

    const Type* checkPointerSubtraction(const Type* lt, const Type* rt)
    {
        const PointerType* plt = dynamic_cast<const PointerType*>(lt);
        const PointerType* prt = dynamic_cast<const PointerType*>(rt);
        if (plt != NULL && prt != NULL && plt->isCompatibleType(prt)) {
            /* XXX ptrdiff_t */
            return new BasicType(BasicType::SLONG);
        }
        return NULL;
    }

    const Type* checkBinaryArithmetic(const Type* lt, const Type* rt,
                                      RefNode locationNode)
    {
        BasicType::PrimitiveTag pt = typeBinaryExpr(lt, rt);
        if (pt == BasicType::NONE) {
            // error: invalid operands to binary %bin (have `%t1' and `%t2')
            ERROR1(CTRUMP_ERR_INVALID_OPERAND, "invalid operands to binary `%s'"
                   , logs_, locationNode);
            throw UncontinuableError();
        }
        return new BasicType(pt);
    }
    
    /* TODO: if error occurred, return NULL. */
    const Type* typeCastExpr(RefNode ec, RefNode es)
    {
        const Type* tc = getOriginalType(ec->getValueRef().type, true);
        const Type* ts = convertUnaryExprType(es->getValueRef().type);
        ts = getOriginalType(ts, true);
        assert(tc != NULL && ts != NULL);

        if (tc->isVoidType()) {
            return tc;
        }
        if (tc->isIntegerType()) {
            const PointerType* pts = dynamic_cast<const PointerType*>(ts);
            if (pts != NULL) {
                return tc;
            }
        }
        if (tc->isArithmeticType()) {
            if (! ts->isArithmeticType()) {
                ERROR(CTRUMP_ERR_INVALID_CAST, "invalid type casting"
                      , logs_, ec);
                throw UncontinuableError();
            }
            return tc;
        }

        const PointerType* ptc = dynamic_cast<const PointerType*>(tc);
        if (ptc != NULL) {
            if (ts->isIntegerType()) {
                return tc;
            }
            const PointerType* pts = dynamic_cast<const PointerType*>(ts);
            if (pts == NULL) {
                ERROR(CTRUMP_ERR_INVALID_CAST, "invalid type casting"
                      , logs_, ec);
            }
            const Type* pbtc = getOriginalType(ptc->getBaseType(), true);
            if (pbtc->isVoidType()) {
                return tc;
            }
            const Type* pbts = getOriginalType(pts->getBaseType(), true);
            if (pbts->isVoidType()) {
                return tc;
            }
            const VectorType* vbtc = dynamic_cast<const VectorType*>(pbtc);
            if (vbtc != NULL) {
                if (pbts->isArithmeticType()) {
                    return tc;
                }
            }
            return tc; /* FIXME */
        }
        const VectorType* vtc = dynamic_cast<const VectorType*>(tc);
        if (vtc != NULL) {
            const PointerType* pts = dynamic_cast<const PointerType*>(ts);
            if (pts != NULL) {
                /* FIXME */
                return tc;
            }
            const VectorType* vts = dynamic_cast<const VectorType*>(ts);
            if (vts == NULL) {
                ERROR(CTRUMP_ERR_INVALID_CAST, "invalid type casting"
                      , logs_, ec);
            }
            return tc;
        }
        throw InternalError("typeCastExpr", &ec->getLocation());
    }

    AssignmentErrorTag checkAssignment(const Type* lt, RefNode rn)
    {
        const Type* rt = getOriginalType(rn->getValueRef().type, true);
        const EnumType* let = dynamic_cast<const EnumType*>(lt);
        if (let != NULL) {
            if ((let->getQualFlags() & Const) != 0) {
                return ASSIGN_ERR_CONST;
            }
            if (rt->isArithmeticType()) {
                return ASSIGN_ERR_NO_ERROR;
            }
            const PointerType* rpt = dynamic_cast<const PointerType*>(rt);
            if (rpt != NULL) {
                return ASSIGN_ERR_INTEGER_FROM_POINTER;
            }
            return ASSIGN_ERR_INCOMPATIBLE;
        }
        const BasicType* lbt = dynamic_cast<const BasicType*>(lt);
        if (lbt != NULL) {
            if ((lbt->getQualFlags() & Const) != 0) {
                return ASSIGN_ERR_CONST;
            }
            if (rt->isArithmeticType()) {
                return ASSIGN_ERR_NO_ERROR;
            }
            const PointerType* rpt = dynamic_cast<const PointerType*>(rt);
            if (rpt != NULL) {
                if (lbt->getPrimitiveTag() == BasicType::BOOL) {
                    return ASSIGN_ERR_NO_ERROR;
                } else {
                    return ASSIGN_ERR_INTEGER_FROM_POINTER;
                }
            }
            return ASSIGN_ERR_INCOMPATIBLE;
        }
        const FieldInclusionType* lfit =
            dynamic_cast<const FieldInclusionType*>(lt);
        if (lfit != NULL) {
            if ((lfit->getQualFlags() & Const) != 0) {
                return ASSIGN_ERR_CONST;
            }
            if (!lfit->isCompatibleType(rt)) {
                /* error: incompatible types in assignment */
            }
            return ASSIGN_ERR_NO_ERROR;
        }
        const PointerType* lpt = dynamic_cast<const PointerType*>(lt);
        if (lpt != NULL) {
            if (isConstantZeroValue(rn)) {
                return ASSIGN_ERR_NO_ERROR;
            }
            const Type* lpbt = getOriginalType(lpt->getBaseType(), true);
            const PointerType* rpt = dynamic_cast<const PointerType*>(rt);
            if (rpt != NULL) {
                if (lpbt->isVoidType()) {
                    return ASSIGN_ERR_NO_ERROR;
                }
                const Type* rpbt = getOriginalType(rpt->getBaseType(), true);
                if (rpbt->isVoidType()) {
                    return ASSIGN_ERR_NO_ERROR;
                }
                if (lpbt->isCompatibleType(rpbt)) {
                    return ASSIGN_ERR_NO_ERROR;
                }
                return ASSIGN_ERR_INCOMPATIBLE_POINTER;
            }
            if (rt->isIntegerType()) {
                return ASSIGN_ERR_POINTER_FROM_INTEGER;
            }
            return ASSIGN_ERR_INCOMPATIBLE;
        }
        const VectorType* lvt = dynamic_cast<const VectorType*>(lt);
        if (lvt != NULL) {
            const VectorType* rvt = dynamic_cast<const VectorType*>(rt);
            if (rvt != NULL) {
                return ASSIGN_ERR_NO_ERROR;
            }
            return ASSIGN_ERR_INCOMPATIBLE;
        }
        return ASSIGN_ERR_INCOMPATIBLE;
    }

    RefNode typeAssignmentExpr(RefNode en)
    {
        RefNode e1 = RefNode(en->getFirstChild());
        RefNode e2 = RefNode(e1->getNextSibling());
        RefNode ne1 = typeExpr(e1);
        e2 = typeExpr(e2);

        const Type* t1 = getOriginalType(ne1->getValueRef().type, true);
        const Type* t2 = getOriginalType(e2->getValueRef().type, true);
        AssignmentErrorTag err = checkAssignment(t1, e2);
        switch (err) {
        case ASSIGN_ERR_CONST:
            ERROR1(CTRUMP_ERR_VIOLATE_CONSTNESS, "assignment of read-only variable/location `%s'"
                   , logs_, en);
            throw UncontinuableError();
            break;
        case ASSIGN_ERR_INCOMPATIBLE:
            ERROR(CTRUMP_ERR_INCOMPATIBLE_ASSIGN, "incompatible types in assignment"
                  , logs_, en);
            throw UncontinuableError();
            break;
        case ASSIGN_ERR_INCOMPATIBLE_POINTER:
            /* FIXME : ctrump_error_code */
            WARNING((ctrump_error_code) -1, "assignment from incompatible pointer type"
                    , logs_, en);
            break;
        case ASSIGN_ERR_POINTER_FROM_INTEGER:
            /* FIXME : ctrump_error_code */
            WARNING((ctrump_error_code) -1, "assignment makes pointer from integer without a cast"
                    , logs_, en);
            break;
        case ASSIGN_ERR_INTEGER_FROM_POINTER:
            /* FIXME : ctrump_error_code */
            WARNING((ctrump_error_code) -1, "assignment makes integer from pointer without a cast"
                    , logs_, en);
            break;
        default:
            break;
        }
        e2 = makeImplicitCastNode(e2, t1, t2);
        ne1->setNextSibling(antlr::RefAST(e2));
        en->setFirstChild(antlr::RefAST(ne1));
        en->getValueRef().type = t1;
        return en;
    }

    RefNode typeComparisonExpr(RefNode en)
    {
        RefNode e1 = RefNode(en->getFirstChild());
        RefNode e2 = RefNode(e1->getNextSibling());
        RefNode ne1 = typeExpr(e1);
        e2 = typeExpr(e2);

        const Type* t1 = getOriginalType(ne1->getValueRef().type, true);
        const Type* t2 = getOriginalType(e2->getValueRef().type, true);

        do {
            if (t1->isArithmeticType() && t2->isArithmeticType()) {
                break;
            }
            const PointerType* pt1 = dynamic_cast<const PointerType*>(t1);
            const PointerType* pt2 = dynamic_cast<const PointerType*>(t2);
            if (pt1 != NULL && pt2 != NULL) {
                const Type* bpt1 = getOriginalType(pt1->getBaseType(), true);
                const Type* bpt2 = getOriginalType(pt2->getBaseType(), true);
                if (bpt1->isCompatibleType(bpt2)) {
                    break;
                }
                if (bpt1->isVoidType()) {
                    e2 = makeImplicitCastNode(e2, t1, t2);
                    break;
                }
                if (bpt2->isVoidType()) {
                    ne1 = makeImplicitCastNode(ne1, t2, t1);
                    break;
                }
            } else if (pt1 != NULL && isConstantZeroValue(e2)) {
                break;
            } else if (pt2 != NULL && isConstantZeroValue(e1)) {
                break;
            }
            ERROR1(CTRUMP_ERR_INVALID_OPERAND, "invalid operands to binary `%s'"
                   , logs_, en);
            return en;
        } while (0);

        ne1->setNextSibling(antlr::RefAST(e2));
        en->setFirstChild(antlr::RefAST(ne1));
        en->getValueRef().type = new BasicType(BasicType::SINT);
        return en;
    }

    const Type* convertUnaryExprType(const Type* t)
    {
        const Type* t1 = getOriginalType(t, true);
        const BasicType* bt = dynamic_cast<const BasicType*>(t1);
        if (bt != NULL) {
            BasicType::PrimitiveTag pt = bt->getPrimitiveTag();
            if (pt <= BasicType::USHORT) {
                /* XXX: sizeof(short) == sizeof(int) */
                return new BasicType(BasicType::SINT);
            } else {
                return t;
            }
        }

        const ArrayType* art = dynamic_cast<const ArrayType*>(t1);
        if (art != NULL) {
            /* FIXME : in case of sizeof */
            return new PointerType(art->getBaseType(), art->getQualFlags());
        }

        const FunctionType* ft = dynamic_cast<const FunctionType*>(t1);
        if (ft != NULL) {
            return new PointerType(ft, 0);
        }

        return t;
    }

    RefNode typeUnaryExpr(RefNode e)
    {
        const Type* et = e->getValueRef().type;
        const Type* tt = convertUnaryExprType(et);
        return makeImplicitCastNode(e, tt, et);
    }

    BasicType::PrimitiveTag getArithmeticTypeTag(const Type* t)
    {
        const EnumType* et = dynamic_cast<const EnumType*>(t);
        if (et != NULL) {
            return BasicType::SINT; /* enum type */
        }
        const BasicType* bt = dynamic_cast<const BasicType*>(t);
        if (bt != NULL) {
            BasicType::PrimitiveTag tag = bt->getPrimitiveTag();
            if (BasicType::isArithmeticTypeTag(tag)) {
                return tag;
            }
        }
        return BasicType::NONE;
    }

    BasicType::PrimitiveTag
    typeBinaryExpr(const Type* type1, const Type* type2)
    {
        BasicType::PrimitiveTag t1 = getArithmeticTypeTag(type1);
        BasicType::PrimitiveTag t2 = getArithmeticTypeTag(type2);
        if (t1 == BasicType::NONE || t2 == BasicType::NONE) {
            return BasicType::NONE;
        }

        if (t1 == t2) return t1;
        if (t1 == BasicType::LDOUBLE) return t1;
        if (t2 == BasicType::LDOUBLE) return t2;
        if (t1 == BasicType::DOUBLE) return t1;
        if (t2 == BasicType::DOUBLE) return t2;
        if (t1 == BasicType::FLOAT) return t1;
        if (t2 == BasicType::FLOAT) return t2;
        if (t1 == BasicType::ULLONG) return t1;
        if (t2 == BasicType::ULLONG) return t2;
        
#define SIGNED_UNSIGNED_CONV_LONG(ta, tb, bta)                  \
        do {                                                    \
            if (ta == BasicType::SLLONG) {                      \
                if (tb == BasicType::ULONG &&                   \
                    (targetInfo_->getSize(TargetInfo::LLONG) == \
                     targetInfo_->getSize(TargetInfo::LONG))) { \
                    return BasicType::ULLONG;                   \
                } else {                                        \
                    return ta;                                  \
                }                                               \
            }                                                   \
        } while (0)

        SIGNED_UNSIGNED_CONV_LONG(t1, t2, bt1);
        SIGNED_UNSIGNED_CONV_LONG(t2, t1, bt2);

#undef SIGNED_UNSIGNED_CONV_LONG

        if (t1 == BasicType::ULONG) return t1;
        if (t2 == BasicType::ULONG) return t2;

        
#define SIGNED_UNSIGNED_CONV_INT(ta, tb, bta)                   \
        do {                                                    \
            if (ta == BasicType::SLONG) {                       \
                if (tb == BasicType::UINT &&                    \
                    (targetInfo_->getSize(TargetInfo::LONG) ==  \
                     targetInfo_->getSize(TargetInfo::INT))) {  \
                    return BasicType::ULONG;                    \
                } else {                                        \
                    return ta;                                  \
                }                                               \
            }                                                   \
        } while (0)

        SIGNED_UNSIGNED_CONV_INT(t1, t2, bt1);
        SIGNED_UNSIGNED_CONV_INT(t2, t1, bt2);

#undef SIGNED_UNSIGNED_CONV_INT

        if (t1 == BasicType::UINT) return t1;
        if (t2 == BasicType::UINT) return t2;

        if (t1 == BasicType::SINT) return t1;
        if (t2 == BasicType::SINT) return t2;

        /* error */
        return BasicType::NONE;
    }

    RefNode typeFunctionArguments(ParameterTypes::const_iterator& i,
                                  ParameterTypes::const_iterator& end,
                                  RefNode argNode, bool hasVararg,
                                  RefNode locationNode)
    {
        if (i == end) {
            if (hasVararg) {
                return typeUnknownTypeFunctionArguments(argNode, locationNode);
            } else if (argNode != NULL) {
                ERROR1(CTRUMP_ERR_TOO_MANY_ARGS, "too many arguments to function `%s'"
                       , logs_, locationNode);
                throw UncontinuableError();
            } else {
                return NULL;
            }
        } else {
            if (argNode == NULL) {
                ERROR1(CTRUMP_ERR_TOO_FEW_ARGS, "too few arguments to function `%s'"
                       , logs_, locationNode);
                throw UncontinuableError();
            }
            RefNode newEn = typeFunctionArgument(argNode, *i, locationNode);
            RefNode nextAn =
                typeFunctionArguments(++i, end,
                                      RefNode(argNode->getNextSibling()),
                                      hasVararg, locationNode);
            argNode->setFirstChild(antlr::RefAST(newEn));
            argNode->setNextSibling(antlr::RefAST(nextAn));
            return argNode;
        }
    }

    RefNode typeUnknownTypeFunctionArguments(RefNode argNode,
                                             RefNode locationNode)
    {
        if (argNode == NULL) {
            return argNode;
        } else {
            RefNode newEn = typeFunctionArgument(argNode, NULL, locationNode);
            RefNode nextAn =
                typeUnknownTypeFunctionArguments(RefNode(argNode->getNextSibling()),
                                                 locationNode);
            argNode->setFirstChild(antlr::RefAST(newEn));
            argNode->setNextSibling(antlr::RefAST(nextAn));
            return argNode;
        }
    }

    RefNode typeFunctionArgument(RefNode argNode, const Type* paramType, 
                                 RefNode locationNode)
    {
        const Type* t;
        assert(argNode->getType() == CTokenTypes::NArgument);
        RefNode en = RefNode(argNode->getFirstChild());
#ifdef PARSER_DEBUG
        std::cout << argNode->toStringList() << std::endl;
#endif
        en = typeUnaryExpr(typeExpr(en));
        //argNode->setFirstChild(antlr::RefAST(en));
        const Type* argType = getOriginalType(en->getValueRef().type, true);
        if (paramType != NULL) {
            paramType = getOriginalType(convertUnaryExprType(paramType), true);
            AssignmentErrorTag err = checkAssignment(paramType, en);
            switch (err) {
            case ASSIGN_ERR_INCOMPATIBLE:
                {
                    /*
                     *  To support SPU built-in functions, vector types in
                     *  parameters are checked using the special typing rules.
                     */
                    const VectorType* pvt =
                        dynamic_cast<const VectorType*>(paramType);
                    if (pvt != NULL) {
                        if (argType->isArithmeticType()) {
                            t = argType;
                            break;
                        }
                        const VectorType* avt =
                            dynamic_cast<const VectorType*>(argType);
                        if (avt != NULL) {
                            t = argType;
                            break;
                        }
                    }
                    ERROR1(CTRUMP_ERR_INCOMPATIBLE_ARG_TYPE, "incompatible type for argument of `%s'"
                           , logs_, locationNode);
                    throw UncontinuableError();
                }
                break;
            case ASSIGN_ERR_INCOMPATIBLE_POINTER:
                // warning: passing argument `n' of `f' from incompatible pointer type
                break;
            default:
                t = paramType;
                break;
            }
        } else {
            const BasicType* abt = dynamic_cast<const BasicType*>(argType);
            if (abt != NULL &&
                abt->getPrimitiveTag() == BasicType::FLOAT) {
                t = new BasicType(BasicType::DOUBLE);
            } else {
                t = argType;
            }
        }
//         argNode->getValueRef().type = t;
//         return makeImplicitCastNode(argNode, t, argType);
        return makeImplicitCastNode(en, t, argType);
    }

    const Type* checkCondOperands(RefNode e1, RefNode e2)
    {
        const Type* t1 = getOriginalType(e1->getValueRef().type, true);
        const Type* t2 = getOriginalType(e2->getValueRef().type, true);
        const BasicType* bt1 = dynamic_cast<const BasicType*>(t1);
        if (bt1 != NULL) {
            const BasicType* bt2 = dynamic_cast<const BasicType*>(t2);
            if (bt2 != NULL) {
                BasicType::PrimitiveTag p1 = bt1->getPrimitiveTag();
                BasicType::PrimitiveTag p2 = bt2->getPrimitiveTag();
                BasicType::PrimitiveTag resTag = typeBinaryExpr(bt1, bt2);
                if (resTag != BasicType::NONE) {
                    return new BasicType(resTag);
                } else if (p1 == BasicType::VOID && p2 == BasicType::VOID) {
                    return bt1;
                }
            }
        }
        const PointerType* pt1 = dynamic_cast<const PointerType*>(t1);
        if (pt1 != NULL) {
            const PointerType* pt2 = dynamic_cast<const PointerType*>(t2);
            if (pt2 != NULL) {
                const Type* pbt1 = getOriginalType(pt1->getBaseType(), true);
                const Type* pbt2 = getOriginalType(pt2->getBaseType(), true);
                if (pbt1->isVoidType()) {
                    return t1;
                }
                if (pbt2->isVoidType()) {
                    return t2;
                }
                if (pbt1->isCompatibleType(pbt2)) {
                    // merge the qualifiers.
                    QualFlags qf = pt1->getQualFlags() | pt2->getQualFlags();
                    return new PointerType(pt1->getBaseType(), qf);
                }
            }
            if (isConstantZeroValue(e2)) {
                return pt1;
            }
        }
        const PointerType* pt2 = dynamic_cast<const PointerType*>(t2);
        if (pt2 != NULL) {
            if (isConstantZeroValue(e1)) {
                return pt2;
            }
        }
        if (t1->isCompatibleType(t2)) {
            return t1;
        }
        return NULL;
    }

    RefNode typeExpr(RefNode en)
    {
        assert(en != NULL);

        int nt = en->getType();
        if (nt == CTokenTypes::IDENT) {
            /* identifier expression is a special case of an expression. */
            return en;
        } else if (en->getValueRef().type != NULL) {
            /* already typed. */
            return en;
        }

#ifdef PARSER_DEBUG
        std::cout << "e: `" << (en != NULL ? en->toStringList() : "NULL") << "' (" << nt << ")\n";
#endif
        const Type* t = NULL;
        switch (nt) {
            // primary
        case CTokenTypes::CharLiteral:
        case CTokenTypes::WCharLiteral:
            t = en->getValueRef().signedValue.type;
            break;
        case CTokenTypes::NStringConstant:
        case CTokenTypes::NWideStringConstant: /* FIXME */
            t = new PointerType(new BasicType(BasicType::CHAR, Const), Const);
            break;
        case CTokenTypes::OctalIntConst:
        case CTokenTypes::DecimalIntConst:
        case CTokenTypes::HexadecimalIntConst:
            t = en->getValueRef().signedValue.type;
            break;
        case CTokenTypes::FloatDoubleConst:
            t = new BasicType(BasicType::FLOAT);
            break;
        case CTokenTypes::DoubleDoubleConst:
            t = new BasicType(BasicType::DOUBLE);
            break;
        case CTokenTypes::LongDoubleConst:
            t = new BasicType(BasicType::LDOUBLE);
            break;
        case CTokenTypes::NSizeofType:
            /* XXX : size_t */
            t = new BasicType(BasicType::UINT);
            break;
        }
        if (t != NULL) {
            en->getValueRef().type = t;
            return en; /* no implicit cast occurred. */
        }

        // unary
        RefNode e1 = RefNode(en->getFirstChild());

        switch (nt) {
        case CTokenTypes::NUnary:
            {
                RefNode rand = RefNode(e1->getNextSibling());
                rand = typeExpr(rand);
                int opt = e1->getType();
                if (opt == CTokenTypes::AND) {
                    const Type* randType =
                        getOriginalType(rand->getValueRef().type, false);
                    t = new PointerType(randType, 0);
                } else if (opt == CTokenTypes::MULT) {
                    const Type* randType =
                        getOriginalType(rand->getValueRef().type, true);
                    const PointerType* pt =
                        dynamic_cast<const PointerType*>(randType);
                    if (pt == NULL) {
                        ERROR1(CTRUMP_ERR_INVALID_DEREFERENCE, "invalid type argument of `%s'"
                               , logs_, e1);
                    }
                    t = pt->getBaseType();
                } else {
                    rand = typeUnaryExpr(rand);
                    t = rand->getValueRef().type;

                }
                e1->setNextSibling(antlr::RefAST(rand));
                break;
            }
        case CTokenTypes::NParen:
        case CTokenTypes::PLUS_PLUS:
        case CTokenTypes::MINUS_MINUS:
        case CTokenTypes::NPlusPlusPostfix:
        case CTokenTypes::NMinusMinusPostfix:
            e1 = typeExpr(e1);
            t = convertUnaryExprType(e1->getValueRef().type);
            break;

        case CTokenTypes::SIZEOF:
            /* XXX : size_t */
            e1 = typeExpr(e1);
            t = new BasicType(BasicType::UINT);
            break;

        case CTokenTypes::VA_ARG:
            e1 = typeExpr(e1);
            t = RefNode(e1->getNextSibling())->getValueRef().type;
            break;

        case CTokenTypes::NCast:
            {
                RefNode es = RefNode(e1->getNextSibling());
                es = typeExpr(es);
                t = typeCastExpr(e1, es);
                // XXX? e1->setNextSibling(es); 
                break;
            }
        case CTokenTypes::NCompoundLiteral:
            {
                /* FIXME */
                t = e1->getValueRef().type;
                break;
            }
        case CTokenTypes::DOT:
        case CTokenTypes::DEREF:
            {
                e1 = typeExpr(e1);
                const Type* t1 = getOriginalType(e1->getValueRef().type, true);
                if (nt == CTokenTypes::DEREF) {
                    const PointerType* pt1 =
                        dynamic_cast<const PointerType*>(t1);
                    if (pt1 == NULL) {
                        ERROR1(CTRUMP_ERR_INVALID_DEREFERENCE, "invalid type argument of `%s'"
                               , logs_, en);
                        throw UncontinuableError();
                    }
                    t1 = getOriginalType(pt1->getBaseType(), true);
                }
                const FieldInclusionType* ft1 =
                    dynamic_cast<const FieldInclusionType*>(t1);
                antlr::RefAST e2 = e1->getNextSibling(); 
                const std::string& fieldName = e2->getText();
                if (ft1 == NULL) {
                    ERROR1(CTRUMP_ERR_INVALID_MEMBER_ACCESS, "request for member `%s' in something not a structure or union"
                           , logs_, en);
                    throw UncontinuableError();
                }
                SUDefinition* def = ft1->getDefinition();
                Environment* env = def->getEnv();
                if (env == NULL) {
                    ERROR1(CTRUMP_ERR_DEREFERENCE_INCOMPLETE_TYPE, "dereferencing pointer to incomplete type"
                           , logs_, en);
                }
                NameDescription* nd;
                Environment* foundEnv = env->lookupOrdinaryName(fieldName, &nd);
                if (foundEnv == NULL) {
                    ERROR1(CTRUMP_ERR_INVALID_MEMBER_ACCESS, "request for member `%s' in something not a structure or union"
                           , logs_, en);
                }
                t = nd->getType();
                break;
            }
        case CTokenTypes::NCall:
            {
                RefNode ne1 = typeUnaryExpr(typeExpr(e1));
                const Type* t1 = getOriginalType(ne1->getValueRef().type, true);
                const PointerType* pft1 = dynamic_cast<const PointerType*>(t1);
                if (pft1 == NULL) {
                    ERROR1(CTRUMP_ERR_INVALID_FUNCTION_CALL, "called object `%s' is not a function"
                           , logs_, e1);
                    throw UncontinuableError();
                }
                const Type* pbt1 = getOriginalType(pft1->getBaseType(), false);
                const FunctionType* ft1 =
                    dynamic_cast<const FunctionType*>(pbt1);
                if (ft1 == NULL) {
                    ERROR1(CTRUMP_ERR_INVALID_FUNCTION_CALL, "called object `%s' is not a function"
                           , logs_, e1);
                    throw UncontinuableError();
                }
                RefNode an = RefNode(e1->getNextSibling());
                const ParameterTypes& pts = ft1->getParameterTypes();
                ParameterTypes::const_iterator i = pts.begin();
                ParameterTypes::const_iterator end = pts.end();
                RefNode newAn =
                    typeFunctionArguments(i, end, an, ft1->hasVararg(), e1);
                ne1->setNextSibling(antlr::RefAST(newAn));
                t = ft1->getReturnType();
                break;
            }
        }
        if (t != NULL) {
            en->setFirstChild(antlr::RefAST(e1));
            en->getValueRef().type = t;
            return en;
        }

        // binary / assignment
        RefNode ne1 = typeExpr(e1);
        RefNode e2 = RefNode(e1->getNextSibling());

        if (nt == CTokenTypes::QUERY) {
            RefNode ne2 = typeExpr(e2);
            RefNode e3 = RefNode(e2->getNextSibling());
            e3 = typeExpr(e3);
            t = checkCondOperands(e2, e3);
            if (t == NULL) {
                ERROR(CTRUMP_ERR_TYPE_MISMATCHED_COND, "type mismatched in conditional expression"
                      , logs_, en);
            }
            ne2->setNextSibling(antlr::RefAST(e3));
            ne1->setNextSibling(antlr::RefAST(ne2));
            en->setFirstChild(antlr::RefAST(ne1));
            en->getValueRef().type = t;
            return en;
        }

        e2 = typeExpr(e2);
        switch (nt) {
        case CTokenTypes::EQ:
        case CTokenTypes::MULT_EQ:
        case CTokenTypes::DIV_EQ:
        case CTokenTypes::MOD_EQ:
        case CTokenTypes::PLUS_EQ:
        case CTokenTypes::MINUS_EQ:
        case CTokenTypes::LSHIFT_EQ:
        case CTokenTypes::RSHIFT_EQ:
        case CTokenTypes::AND_EQ:
        case CTokenTypes::XOR_EQ:
        case CTokenTypes::OR_EQ:
            return typeAssignmentExpr(en);
        case CTokenTypes::EQ_EQ:
        case CTokenTypes::NOT_EQ:
            return typeComparisonExpr(en);
        }

        ne1 = typeUnaryExpr(ne1);
        e2 = typeUnaryExpr(e2);

        const Type* at1 = getOriginalType(ne1->getValueRef().type, true);
        const Type* at2 = getOriginalType(e2->getValueRef().type, true);
        switch (nt) {
        case CTokenTypes::PLUS:
        case CTokenTypes::MINUS:
            {
                t = checkPointerArithmeticAdditive(at1, at2);
                if (t != NULL) {
                    t = new PointerType(t, 0);
                    break;
                }
                t = checkPointerArithmeticAdditive(at2, at1);
                if (t != NULL) {
                    t = new PointerType(t, 0);
                    break;
                }
                if (nt == CTokenTypes::MINUS) {
                    t = checkPointerSubtraction(at1, at2);
                    if (t != NULL) {
                        break;
                    }
                }
                t = checkBinaryArithmetic(at1, at2, en);
                ne1 = makeImplicitCastNode(ne1, t, at1);
                e2 = makeImplicitCastNode(e2, t, at2);
                break;
            }
        case CTokenTypes::OR_OR:
        case CTokenTypes::AND_AND:
            {
                if (!at1->isScalarType() || !at2->isScalarType()) {
                    ERROR1(CTRUMP_ERR_INVALID_OPERAND, "invalid operands to binary `%s'"
                           , logs_, en);
                }
                t = new BasicType(BasicType::SINT);
                break;
            }
        case CTokenTypes::LESS:
        case CTokenTypes::GREATER:
        case CTokenTypes::LESS_EQ:
        case CTokenTypes::GREATER_EQ:
            {
                const PointerType* pt1 = dynamic_cast<const PointerType*>(at1);
                const PointerType* pt2 = dynamic_cast<const PointerType*>(at2);
                if (pt1 != NULL && pt2 != NULL) {
                    if (pt1->getBaseType()->
                        isCompatibleType(pt2->getBaseType())) {
                        t = at1;
                        break;
                    }
                }
            }
            /* FALLTHROUGH */
        case CTokenTypes::OR:
        case CTokenTypes::XOR:
        case CTokenTypes::AND:
        case CTokenTypes::LSHIFT:
        case CTokenTypes::RSHIFT:
        case CTokenTypes::MULT:
        case CTokenTypes::DIV:
        case CTokenTypes::MOD:
            {
                t = checkBinaryArithmetic(at1, at2, en);
                ne1 = makeImplicitCastNode(ne1, t, at1);
                e2 = makeImplicitCastNode(e2, t, at2);
                break;
            }
        case CTokenTypes::OPEN_SQUARE:
            {
                t = checkPointerArithmeticAdditive(at1, at2);
                if (t == NULL) {
                    t = checkPointerArithmeticAdditive(at2, at1);
                    if (t == NULL) {
                        ERROR1(CTRUMP_ERR_INVALID_SUBSCRIPTING, "subscripted value is neither array nor pointer"
                               , logs_, en);
                        throw UncontinuableError();
                    }
                }
                break;
            }
        case CTokenTypes::COMMA:
            t = at2;
            break;
        }
        if (t != NULL) {
            ne1->setNextSibling(antlr::RefAST(e2));
            en->setFirstChild(antlr::RefAST(ne1));
            en->getValueRef().type = t;
            return en;
        }
        throw InternalError("typeExpr");
    }


    eint evalConstExpr(antlr::RefAST en) throw(EvalFailedException)
    {
        if (en == NULL) return 0;
        int nt = en->getType();
#ifdef PARSER_DEBUG
        std::cout << "e: `" << (en != NULL ? en->toStringList() : "NULL") << "' (" << nt << ")\n";
#endif
        switch (nt) {
        case CTokenTypes::IDENT:
            {
                NameDescription* nd;
                Environment* env =
                    currentEnv_->lookupOrdinaryName(en->getText(), &nd);
                assert(env != NULL);
                if (nd->getLocation() == NameDescription::ENUM) {
                    return nd->getConstantValue();
                }
                throw EvalFailedException(nt);
            }
        case CTokenTypes::CharLiteral:
        case CTokenTypes::WCharLiteral:
        case CTokenTypes::OctalIntConst:
            return strtoll(en->getText().c_str(), NULL, 8);
        case CTokenTypes::DecimalIntConst:
            return strtoll(en->getText().c_str(), NULL, 10);
        case CTokenTypes::HexadecimalIntConst:
            return strtoll(en->getText().c_str(), NULL, 16);
        case CTokenTypes::NParen:
        case CTokenTypes::NImplicitCast:
            return evalConstExpr(en->getFirstChild());
        case CTokenTypes::NUnary:
            {
                antlr::RefAST codeNode = en->getFirstChild();
                antlr::RefAST randNode = codeNode->getNextSibling();
                switch (codeNode->getType()) {
                case CTokenTypes::AND:
                case CTokenTypes::MULT:
                    throw EvalFailedException(nt);
                case CTokenTypes::PLUS: return evalConstExpr(randNode);
                case CTokenTypes::MINUS: return - evalConstExpr(randNode);
                case CTokenTypes::COMPL: return ~ evalConstExpr(randNode);
                case CTokenTypes::NOT: return ! evalConstExpr(randNode);
                default:
                    throw InternalError("evalConstExpr: invalid unary expr");
                }
            }

        case CTokenTypes::NSizeofType:
            return RefNode(en->getFirstChild())->getValueRef().type->
                getSize(*targetInfo_);
        case CTokenTypes::SIZEOF:
            {
                RefNode e1 = RefNode(en->getFirstChild());
                const Type* t = e1->getValueRef().type;
                assert(t != NULL);
                return t->getSize(*targetInfo_);
            }
        case CTokenTypes::NCast:
            /* FIXME */
            return evalConstExpr(en->getFirstChild()->getNextSibling());
            // error
        case CTokenTypes::PLUS_PLUS:
        case CTokenTypes::MINUS_MINUS:
        case CTokenTypes::OPEN_SQUARE:
        case CTokenTypes::NPlusPlusPostfix:
        case CTokenTypes::NMinusMinusPostfix:
        case CTokenTypes::DOT:
        case CTokenTypes::DEREF:
        case CTokenTypes::NCall:
        case CTokenTypes::NStringConstant:
        case CTokenTypes::NWideStringConstant:
        case CTokenTypes::FloatDoubleConst:
        case CTokenTypes::DoubleDoubleConst:
        case CTokenTypes::LongDoubleConst:
        case CTokenTypes::NCompoundLiteral:
        case CTokenTypes::VA_ARG:
            throw EvalFailedException(nt);
        }
        
        // binary
        antlr::RefAST e1 = en->getFirstChild();
        antlr::RefAST e2 = e1->getNextSibling();
        eint v1 = evalConstExpr(e1);
        eint v2 = evalConstExpr(e2);
        switch (nt) {
        case CTokenTypes::OR_OR:      return v1 || v2;
        case CTokenTypes::AND_AND:    return v1 && v2;
        case CTokenTypes::OR:         return v1 | v2;
        case CTokenTypes::XOR:        return v1 ^ v2;
        case CTokenTypes::AND:        return v1 & v2;
        case CTokenTypes::EQ_EQ:      return v1 == v2;
        case CTokenTypes::NOT_EQ:     return v1 != v2;
        case CTokenTypes::LESS:       return v1 < v2;
        case CTokenTypes::GREATER:    return v1 > v2;
        case CTokenTypes::LESS_EQ:    return v1 <= v2;
        case CTokenTypes::GREATER_EQ: return v1 >= v2;
        case CTokenTypes::LSHIFT:     return v1 << v2;
        case CTokenTypes::RSHIFT:     return v1 >> v2;
        case CTokenTypes::PLUS:       return v1 + v2;
        case CTokenTypes::MINUS:      return v1 - v2;
        case CTokenTypes::MULT:       return v1 * v2;
        case CTokenTypes::DIV:        return v1 / v2;
        case CTokenTypes::MOD:        return v1 % v2;
        case CTokenTypes::COMMA:      return v2;
        case CTokenTypes::QUERY:
            if (v1) {
                return v2;
            } else {
                return evalConstExpr(e2->getNextSibling());
            }
        }

        throw EvalFailedException(nt);
    }

    void setLogs(Logs* logs)
    {
        logs_ = logs;
    }

    void setTargetInfo(TargetInfo* info)
    {
        targetInfo_ = info;
    }

protected:
    Environment* currentEnv_;

    FunctionType* currentFunctionType_;

    static const char * const gccBuiltinNames[];

    bool supportVectorExt_;

    Logs* logs_;

    TargetInfo* targetInfo_;

    antlr::ASTFactory* astFactory_;

private:
    unsigned int nameCount_; /* used from `generateNome()' */

};



// const char * const CParser::gccBuiltinNames[] = {
//     "__builtin_va_list"
// };

// bool CParser::isGccBuiltinName(const std::string& name) const
// {
//     size_t numBuiltins =
//         sizeof(gccBuiltinNames) / sizeof(const char * const);
//     for (size_t i = 0; i < numBuiltins; ++i) {
//         if (name == gccBuiltinNames[i]) {
//             return true;
//         }
//     }
//     return false;
// }

// void CParser::initializeTypes()
// {
// }



} // namespace cfront

#endif

---