C++ (Cpp) new_Element Examples

Example #1

File: FBXParser.cpp Project: ppiecuch/assimp-portable

// ------------------------------------------------------------------------------------------------
Scope::Scope(Parser& parser,bool topLevel)
{
    if(!topLevel) {
        TokenPtr t = parser.CurrentToken();
        if (t->Type() != TokenType_OPEN_BRACKET) {
            ParseError("expected open bracket",t);
        }
    }

    TokenPtr n = parser.AdvanceToNextToken();
    if(n == NULL) {
        ParseError("unexpected end of file");
    }

    // note: empty scopes are allowed
    while(n->Type() != TokenType_CLOSE_BRACKET) {
        if (n->Type() != TokenType_KEY) {
            ParseError("unexpected token, expected TOK_KEY",n);
        }

        const std::string& str = n->StringContents();
        elements.insert(ElementMap::value_type(str,new_Element(*n,parser)));

        // Element() should stop at the next Key token (or right after a Close token)
        n = parser.CurrentToken();
        if(n == NULL) {
            if (topLevel) {
                return;
            }
            ParseError("unexpected end of file",parser.LastToken());
        }
    }
}

Example #2

File: eval.c Project: virtualdev/pico

/**
 * derv_ExprExt : calcule la dérivé première d'une expression
 * @param expr l'expression pour laquel calculer la dérivé
 * @return l'expresssion dérivé
 */
extern Expr * derv_ExprExt(Expr * expr) {
    switch (expr->type) {
        case ELEMENT:
            switch (expr->u.Element.elType) {
                case VAL:
                    return new_Element(0, 0, INT, VAL);
                case VAR:
                    return new_Element(expr->u.Element.power, expr->u.Element.power - 1, INT, (expr->u.Element.power - 1) == 0 ? VAL : VALVAR);
                case VALVAR:
                    return new_Element(
                            expr->u.Element.power * expr->u.Element.value, expr->u.Element.power - 1, 
                            expr->u.Element.typecst == REEL ? REEL : INT, 
                            (expr->u.Element.power - 1) == 0 ? VAL : VALVAR);
            }
        case OPBINAIRE:
            switch (expr->u.OpBinaire.operateur) {
                case PLUS:
                    return new_OpBinaire(derv_ExprExt(expr->u.OpBinaire.left), '+', derv_ExprExt(expr->u.OpBinaire.rigth));
                case MULT:
                    return new_OpBinaire(
                           new_Par(new_OpBinaire(new_Par(derv_ExprExt(expr->u.OpBinaire.left)), '*', expr->u.OpBinaire.rigth)),
                            '+',
                           new_Par(new_OpBinaire(expr->u.OpBinaire.left, '*', new_Par(derv_ExprExt(expr->u.OpBinaire.rigth)))));
            }
        case FUNCT:
        {
            Expr* identFunc = exprList_get(expr->u.Func.name);
            if (identFunc == NULL) {
                fprintf(stderr, "ERROR dans la simplification, l'identifiant de la fonction [%s] n'existe pas!\n", expr->u.Func.name);
                exit(EXIT_FAILURE);
            }
            Expr* simplified = expr_simplify(identFunc);
            Expr* derivated = expr_derivate(simplified, expr->u.Func.derivative);
            Expr* paramExpr = expr_simplify(expr->u.Func.child);
            identFunc = expr_replaceVariable(derivated, paramExpr);
            return derv_ExprExt(identFunc);
        }
        case PAR:
            return derv_ExprExt(expr->u.Par.single);
    }
}