Method evalAndFold

src/ast/ast_const_folding.cpp:353–419

    }

    ExpressionPtr FoldingVisitor::evalAndFold ( Expression * expr ) {
        if ( expr->type->baseType == Type::tString ) return evalAndFoldString(expr);
        if ( expr->rtti_isConstant() ) return expr->clone();
        bool failed;
        vec4f value = eval(expr, failed);
        if ( !failed ) {
            if ( expr->type->isEnumT() ) {
                int64_t ival = 0;
                switch ( expr->type->enumType->baseType ) {
                case Type::tInt8:       ival = cast<int8_t>::to(value); break;
                case Type::tUInt8:      ival = cast<uint8_t>::to(value); break;
                case Type::tInt16:      ival = cast<int16_t>::to(value); break;
                case Type::tUInt16:     ival = cast<uint16_t>::to(value); break;
                case Type::tInt:        ival = cast<int32_t>::to(value); break;
                case Type::tUInt:       ival = cast<uint32_t>::to(value); break;
                case Type::tBitfield:   ival = cast<uint32_t>::to(value); break;
                case Type::tBitfield8:  ival = cast<uint8_t>::to(value); break;
                case Type::tBitfield16: ival = cast<uint16_t>::to(value); break;
                case Type::tBitfield64: ival = cast<uint64_t>::to(value); break;
                case Type::tInt64:      ival = cast<int64_t>::to(value); break;
                case Type::tUInt64:     ival = cast<uint64_t>::to(value); break;
                default: DAS_ASSERTF(0,"we should not be here. unsupported enum type");
                }
                auto cef = expr->type->enumType->find(ival, "");
                if ( cef.empty() ) return expr; // it folded to unsupported value
                auto sim = new ExprConstEnumeration(expr->at, cef, expr->type);
                sim->type = expr->type->enumType->makeEnumType();
                sim->constexpression = true;
                sim->at = encloseAt(expr);
                sim->value = value;
                sim->foldedNonConst = !expr->type->constant;
                reportFolding();
                return sim;
            } else if ( expr->type->isBitfield() ) {
                uint64_t ival = 0;
                switch ( expr->type->baseType ) {
                case Type::tBitfield8:  ival = cast<uint8_t>::to(value); break;
                case Type::tBitfield16: ival = cast<uint16_t>::to(value); break;
                case Type::tBitfield:   ival = cast<uint32_t>::to(value); break;
                case Type::tBitfield64: ival = cast<uint64_t>::to(value); break;
                default: DAS_ASSERTF(0,"we should not be here. unsupported bitfield type");
                }
                auto sim = new ExprConstBitfield(expr->at, ival);
                sim->type = new TypeDecl(*expr->type);
                sim->constexpression = true;
                sim->at = encloseAt(expr);
                sim->foldedNonConst = !expr->type->constant;
                sim->baseType = expr->type->baseType;
                sim->bitfieldType = new TypeDecl(*expr->type);
                reportFolding();
                return sim;
            } else {
                auto wasRef = expr->type->ref;
                expr->type->ref = false;
                auto sim = Program::makeConst(expr->at, expr->type, value);
                expr->type->ref = wasRef;
                sim->type = new TypeDecl(*expr->type);
                sim->constexpression = true;