C++ (Cpp) Argument::setType Examples

Example #1

bool CheckDeclaration::visit(ParameterDeclarationAST *ast)
{
    unsigned sourceLocation = locationOfDeclaratorId(ast->declarator);
    if (! sourceLocation) {
        if (ast->declarator)
            sourceLocation = ast->declarator->firstToken();
        else
            sourceLocation = ast->firstToken();
    }

    const Name *argName = 0;
    FullySpecifiedType ty = semantic()->check(ast->type_specifier_list, _scope);
    FullySpecifiedType argTy = semantic()->check(ast->declarator, ty.qualifiedType(),
                                                 _scope, &argName);
    FullySpecifiedType exprTy = semantic()->check(ast->expression, _scope);
    Argument *arg = control()->newArgument(sourceLocation, argName);
    ast->symbol = arg;
    if (ast->expression) {
        unsigned startOfExpression = ast->expression->firstToken();
        unsigned endOfExpression = ast->expression->lastToken();
        std::string buffer;
        for (unsigned index = startOfExpression; index != endOfExpression; ++index) {
            const Token &tk = tokenAt(index);
            if (tk.whitespace() || tk.newline())
                buffer += ' ';
            buffer += tk.spell();
        }
        const StringLiteral *initializer = control()->findOrInsertStringLiteral(buffer.c_str(), buffer.size());
        arg->setInitializer(initializer);
    }
    arg->setType(argTy);
    _scope->enterSymbol(arg);
    return false;
}

Example #2

File: CppRewriter.cpp Project: FlavioFalcao/qt-creator

        virtual void visit(Function *type)
        {
            Function *funTy = control()->newFunction(0, 0);
            funTy->copy(type);
            funTy->setConst(type->isConst());
            funTy->setVolatile(type->isVolatile());

            funTy->setName(rewrite->rewriteName(type->name()));

            funTy->setReturnType(rewrite->rewriteType(type->returnType()));

            for (unsigned i = 0, argc = type->argumentCount(); i < argc; ++i) {
                Symbol *arg = type->argumentAt(i);

                Argument *newArg = control()->newArgument(0, 0);
                newArg->copy(arg);
                newArg->setName(rewrite->rewriteName(arg->name()));
                newArg->setType(rewrite->rewriteType(arg->type()));

                // the copy() call above set the scope to 'type'
                // reset it to 0 before adding addMember to avoid assert
                newArg->resetEnclosingScope();
                funTy->addMember(newArg);
            }

            temps.append(funTy);
        }

Example #3

File: glslengine.cpp Project: KDE/android-qt-creator

Argument *Engine::newArgument(Function *function, const QString &name, const Type *type)
{
    Argument *a = new Argument(function);
    a->setName(name);
    a->setType(type);
    _symbols.append(a);
    return a;
}

Example #4

File: CheckDeclaration.cpp Project: halsten/beaverdbg

bool CheckDeclaration::visit(ParameterDeclarationAST *ast)
{
    unsigned sourceLocation = locationOfDeclaratorId(ast->declarator);
    if (! sourceLocation) {
        if (ast->declarator)
            sourceLocation = ast->declarator->firstToken();
        else
            sourceLocation = ast->firstToken();
    }

    Name *argName = 0;
    FullySpecifiedType ty = semantic()->check(ast->type_specifier, _scope);
    FullySpecifiedType argTy = semantic()->check(ast->declarator, ty.qualifiedType(),
                                                 _scope, &argName);
    FullySpecifiedType exprTy = semantic()->check(ast->expression, _scope);
    Argument *arg = control()->newArgument(sourceLocation, argName);
    ast->symbol = arg;
    if (ast->expression)
        arg->setInitializer(true);
    arg->setType(argTy);
    _scope->enterSymbol(arg);
    return false;
}

Example #5

Argument *arg(const QString &name, const FullySpecifiedType &ty)
{
    Argument *a = new Argument(unit, 0, nameId(name));
    a->setType(ty);
    return a;
}

Example #6

File: X86RTLGenerator.cpp Project: BackupTheBerlios/tuxap

bool X86RTLGenerator::parseArgument(x86_op_t *pOp, Argument &aArgument)
{
	if(!pOp)
	{
		return false;
	}

	switch(pOp->type)
	{
		case op_register:
		{
			aArgument.setType(Argument::TYPE_REGISTER);
			std::string strRegisterName = pOp->data.reg.name;

			if(strRegisterName == "ah")
			{
				aArgument.setRegister((Argument::eRegister)REGISTER_X86_EAX);
				aArgument.setDataWidth(Argument::DATA_WIDTH_8_LW_HB);
			}
			else if(strRegisterName == "al")
			{
				aArgument.setRegister((Argument::eRegister)REGISTER_X86_EAX);
				aArgument.setDataWidth(Argument::DATA_WIDTH_8_LW_LB);
			}
			else if(strRegisterName == "ax")
			{
				aArgument.setRegister((Argument::eRegister)REGISTER_X86_EAX);
				aArgument.setDataWidth(Argument::DATA_WIDTH_16_LW);
			}
			else if(strRegisterName == "eax")
			{
				aArgument.setRegister((Argument::eRegister)REGISTER_X86_EAX);
				aArgument.setDataWidth(Argument::DATA_WIDTH_32);
			}
			else if(strRegisterName == "esi")
			{
				aArgument.setRegister((Argument::eRegister)REGISTER_X86_ESI);
				aArgument.setDataWidth(Argument::DATA_WIDTH_32);
			}
			else if(strRegisterName == "esp")
			{
				aArgument.setRegister((Argument::eRegister)REGISTER_X86_ESP);
				aArgument.setDataWidth(Argument::DATA_WIDTH_32);
			}
			else
				return false;
			break;
		}
		case op_immediate:
			aArgument.setType(Argument::TYPE_VALUE);

			switch(pOp->datatype)
			{
				case op_byte:
					aArgument.setValue(pOp->data.byte);
					aArgument.setDataWidth(Argument::DATA_WIDTH_8_LW_LB);
					break;
				default:
					return false;
			}
			break;
		case op_expression:
			aArgument.setType(Argument::TYPE_MEMORY_LOC);
			break;
		case op_offset:
			aArgument.setType(Argument::TYPE_MEMORY_LOC);
			break;
		case op_relative_far:
			aArgument.setType(Argument::TYPE_VALUE);
			break;
		case op_relative_near:
			aArgument.setType(Argument::TYPE_VALUE);
			break;
		default:
			return false;
	}

	return true;
}