C++ (Cpp) fillType Examples

Example #1

File: caselabel_expr.cpp Project: 4144/paranucker

void parseCaseLabelExprNode(CaseLabelExprNode *node)
{
    fillType(node);
    fillExprLocation(node);
    Log::dump(node);

    fillExprOperands(node);

    node->caseLabel = createParseNode(
        node,
        CASE_LABEL(node->gccNode),
        "case label");

    if (CASE_LOW(node->gccNode))
    {
        node->caseLow = static_cast<IntegerCstNode*>(createParseNode(
            node,
            CASE_LOW(node->gccNode),
            "case low"));
        node->caseHigh = static_cast<IntegerCstNode*>(createParseNode(
            node,
            CASE_HIGH(node->gccNode),
            "case high"));
    }
}

Example #2

File: compound_expr.cpp Project: 4144/paranucker

void parseCompoundExprNode(CompoundExprNode *node)
{
    fillType(node);
    fillExprLocation(node);
    Log::dump(node);

    fillExprOperands(node);
}

Example #3

File: nonlvalue_expr.cpp Project: 4144/paranucker

void parseNonLvalueExprNode(NonLvalueExprNode *node)
{
    fillType(node);
    fillExprLocation(node);
    Log::dump(node);

    fillExprOperands(node);
}

Example #4

File: exit_expr.cpp Project: 4144/paranucker

void parseExitExprNode(ExitExprNode *node)
{
    fillType(node);
    fillExprLocation(node);
    Log::dump(node);

    fillExprOperands(node);
}

Example #5

File: truncdiv_expr.cpp Project: 4144/paranucker

void parseTruncDivExprNode(TruncDivExprNode *node)
{
    fillType(node);
    fillExprLocation(node);
    Log::dump(node);

    fillExprOperands(node);
}

Example #6

File: viewconvert_expr.cpp Project: 4144/paranucker

void parseViewConvertExprNode(ViewConvertExprNode *node)
{
    fillType(node);
    fillExprLocation(node);
    Log::dump(node);

    fillExprOperands(node);
}

Example #7

File: TypeBuilder.cpp Project: coral-framework/coral-old

IType* TypeBuilder::createType()
{
	if( _typeWasCreated )
		return _type.get();

	fillType();
	_typeWasCreated = true;

	return _type.get();
}

Example #8

File: le_expr.cpp Project: 4144/paranucker

void parseLeExprNode(LeExprNode *node)
{
    fillType(node);
    fillExprLocation(node);
    Log::dump(node);

//    if (node->parseChilds <= 0)
//        return;

    fillExprOperands(node);
}

Example #9

File: emptyclass_expr.cpp Project: 4144/paranucker

void parseEmptyClassExprNode(EmptyClassExprNode *node)
{
    fillType(node);
    fillExprLocation(node);
    Log::dump(node);

    node->type = static_cast<TypeNode*>(createParseNode(
        node,
        TREE_TYPE(node->gccNode),
        "type"));
}

Example #10

File: templatetypeparm.cpp Project: 4144/paranucker

void parseTemplateTypeParmNode(TemplateTypeParmNode *node)
{
    fillType(node);
    Log::dump(node);

#ifdef ENABLE_CXXLANG
    node->index = createParseNode(
        node,
        TEMPLATE_TYPE_PARM_INDEX(node->gccNode),
        "index");
#endif
}

Example #11

File: decl_expr.cpp Project: scriptum/paranucker

void parseDeclExprNode(DeclExprNode *node)
{
    fillType(node);
    fillExprLocation(node);
    Log::dump(node);

//    if (node->parseChilds <= 0)
//        return;

    fillExprOperands(node);

    // args 0 - DECL_EXPR_DECL
}

Example #12

File: expr_stmt.cpp Project: 4144/paranucker

void parseExprStmtNode(ExprStmtNode *node)
{
    fillType(node);
    fillExprLocation(node);
    Log::dump(node);

    if (node->parseChilds <= 0)
        return;

    node->expression = static_cast<ExprNode*>(createParseNode(
        node,
        EXPR_STMT_EXPR(node->gccNode),
        "expresssion"));
}

Example #13

File: statement_list.cpp Project: 4144/paranucker

void parseStatementListNode(StatementListNode *node)
{
    fillType(node);
    Log::dump(node);

    if (node->parseChilds <= 0)
        return;

    for (tree_stmt_iterator it = tsi_start (node->gccNode);
         !tsi_end_p (it);
         tsi_next (&it))
    {
        node->statements.push_back(createParseNode(
            node,
            tsi_stmt (it),
            "statement"));
    }
}

Example #14

File: call_expr.cpp Project: 4144/paranucker

void parseCallExprNode(CallExprNode *node)
{
    fillType(node);
    fillExprLocation(node);
    Log::dump(node);

// not recommended
//    fillExprOperands(node);

    if (CALL_EXPR_FN(node->gccNode) != NULL_TREE)
    {
        node->function = createParseNode(
            node,
            CALL_EXPR_FN(node->gccNode),
            "function");
    }
    else
    {
        node->functionName = internal_fn_name(CALL_EXPR_IFN (node->gccNode));
        Log::dump(node, "- function: %s", node->functionName.c_str());
    }

//    if (node->parseChilds <= 0)
//        return;

    const int argsCount = call_expr_nargs(node->gccNode);
    for (int f = 0; f < argsCount; f ++)
    {
        node->args.push_back(createParseNode(
            node,
            CALL_EXPR_ARG(node->gccNode, f),
            "arg"));
    }

    node->chain = createParseNode(
        node,
        CALL_EXPR_STATIC_CHAIN(node->gccNode),
        "chain");

    if (node->functionName == "LOAD_LANES")
        return;
}

Example #15

File: function_type.cpp Project: 4144/paranucker

void parseFunctionTypeNode(FunctionTypeNode *node)
{
    fillType(node);
    Log::dump(node);

    node->returnType = static_cast<TypeNode*>(createParseNode(
        node,
        TREE_TYPE(node->gccNode),
        "function return type",
        node->parseChilds));

    fillTypeAttributes(node);

    if (node->parseChilds <= 0)
        return;

    fillTypeName(node);
    node->argTypes = static_cast<TreeListNode*>(createParseNode(
        node,
        TYPE_ARG_TYPES(node->gccNode),
        TREE_LIST,
        "arg types"));
}

Example #16

File: break_stmt.cpp Project: 4144/paranucker

void parseBreakStmtNode(BreakStmtNode *node)
{
    fillType(node);
    fillExprLocation(node);
    Log::dump(node);
}