C++ Expression::GetType方法代码示例

	bool Expression::operator==(const Expression &expr) const
	{
		if (GetType()!=expr.GetType())
			return false;

		return Equals(expr);
	}

    void MacroExpChecker::Do(const Expression& Exp, 
                             const vector<const ESFixedTypeBase*>& DomainTypes,
                             const ESFixedTypeBase* RangeType, 
                             vector<Expression>& FormalParamExps)
    {
        if (Exp->GetType() != RangeType) {
            throw TypeException((string)"Macro Expression has mismatched type");
        }

        MacroExpChecker Checker;
        Exp->Accept(&Checker);
        
        // Check if the formal param expressions obtained have the same type as expected
        // Also, ALL formal params MUST be used
        for (uint32 i = 0; i < DomainTypes.size(); ++i) {
            auto it = Checker.FormalParamExpressions.find(i);
            if (it == Checker.FormalParamExpressions.end()) {
                throw TypeException((string)"Formal parameter " + to_string(i) + " unused in macro. " + 
                                    "Please eliminate unused parameters from macro definitions.");
            }
            if (it->second->GetType() != DomainTypes[i]) {
                throw TypeException((string)"Formal parameter type mismatch at position " + to_string(i) + 
                                    " in macro definition");
            }
            FormalParamExps.push_back(it->second);
        }
    }

    Expression ESolver::CreateExpression(const string& OperatorName,
                                         const Expression& Exp1,
                                         const Expression& Exp2,
                                         const Expression& Exp3)
    {
        // special case for bv extract

        if (OperatorName == "bvextract") {
            if (Exp2->As<UserConstExpression>() == nullptr ||
                Exp3->As<UserConstExpression>() == nullptr) {
                throw TypeException((string)"bvextract can only be applied to constant indices");
            }
            if (Exp2->GetType() != IntType ||
                Exp3->GetType() != IntType) {
                throw TypeException((string)"bvextract can only be applied to constant integer indices");
            }

            auto OpName = BVLogic::GetExtractOpName(Exp1->GetType(), 
                                                    Exp2->GetOp()->As<ConstOperator>()->GetConstantValue()->GetValue(), 
                                                    Exp3->GetOp()->As<ConstOperator>()->GetConstantValue()->GetValue());
            // recurse with new name
            auto Op = LookupOperator(OpName);
            if (Op == nullptr) {
                LoadedBVLogic->InstantiateExtractOperator(Exp1->GetType(), 
                                                          Exp2->GetOp()->As<ConstOperator>()->GetConstantValue()->GetValue(), 
                                                          Exp3->GetOp()->As<ConstOperator>()->GetConstantValue()->GetValue());
                Op = LookupOperator(OpName);
            }
            vector<Expression> Children = { Exp1 };
            return CreateExpression(Op, Children);
        }

        vector<Expression> Children(3);
        Children[0] = Exp1;
        Children[1] = Exp2;
        Children[2] = Exp3;
        return CreateExpression(OperatorName, Children);
    }

/*
 *  command-def := 'command' ident stmt
 */
CommandDef* Parser::commanddef() {
    // save the line containing the "command" keyword
    int line = last.line;
    //if(expect(identifier)) {
    expect(identifier);
    CommandDef* cmd = new CommandDef(line, last.sval, error);

    // Read argument definitions, if any
    if(accept(leftparen)) {
        // Initial argument
        if(sym != rightparen) {
            expect(identifier);
            cmd->AddArg(last.sval);
        }
        // Subsequent arguments must be preceded by a comma
        while(sym != rightparen && sym != finished) {
            if(!expect(comma)) break;
            if(!expect(identifier)) break;
            cmd->AddArg(last.sval);
        }
        // Don't forget the closing parenthesis!
        expect(rightparen);
    }

    Expression* body = expression();

    // DUCT TAPE:
    if(body->GetType() == blockexpr) {
        (dynamic_cast<BlockExpr*>(body))->NoLocalScope(true);
    }

    cmd->SetBody(body);
    return cmd;
    //}

    //return new ErrorExpr(line, "invalid command def");
}

void
ParallelCoordinatesViewerPluginInfo::InitializePlotAtts(
    AttributeSubject *atts, ViewerPlot *plot)
{
    // If we had scalar names, we can just copy the default atts
    // and return.
    if (defaultAtts->GetScalarAxisNames().size() != 0)
    {
        // One helpful thing we can do: make sure the user set the
        // visual axis names.  They really should have, but since
        // we can blindly copy them from the scalar axis names in
        // this case, no harm doing it for them.
        if (defaultAtts->GetVisualAxisNames().size() == 0)
            defaultAtts->SetVisualAxisNames(defaultAtts->GetScalarAxisNames());

        *(ParallelCoordinatesAttributes*)atts = *defaultAtts;

        return;
    }

    // Otherwise,  we must be an array variable; try to get
    // some names for its components....
    const avtDatabaseMetaData *md = plot->GetMetaData();
    const std::string &var = plot->GetVariableName();
    const avtArrayMetaData *array = md->GetArray(var);
    stringVector subNames;
    if (array)
    {
        subNames = array->compNames;
    }
    else
    {
        Expression *exp =
            ParsingExprList::GetExpression(plot->GetVariableName());
        if (exp == NULL || exp->GetType() != Expression::ArrayMeshVar)
        {
            debug3 << "ParallelCoordinatesAttributes::InitializePlotAtts: "
                   << "variable wasn't an array database variable, an "
                   << "array expression, or a list of scalars.  This can "
                   << "happen if the user attempts to create this plot "
                   << "without the use off a wizard, e.g. in the case of "
                   << "the cli.  Assuming this is the case and continuing "
                   << "without error.\n";
            return;
        }
        // If we have any problems walking the expression tree, just return;
        // the worst case scenario if we don't populate the visual axis
        // name list is that the GUI window is temporarily blank.
        ExprNode *root = ParsingExprList::GetExpressionTree(exp);
        if (root->GetTypeName() != "Function")
            return;
        FunctionExpr *fn = dynamic_cast<FunctionExpr*>(root);
        if (fn->GetName() != "array_compose" &&
            fn->GetName() != "array_compose_with_bins")
            return;
        ArgsExpr *argsExpr = fn->GetArgsExpr();
        std::vector<ArgExpr*> *args = argsExpr ? argsExpr->GetArgs() : NULL;
        if (!args)
            return;
        for (size_t i=0; i<args->size(); i++)
        {
            ExprNode *arg = (ExprNode*)((*args)[i]->GetExpr());
            if (arg->GetTypeName() == "List")
                break;
            subNames.push_back(arg->GetPos().GetText(exp->GetDefinition()));
        }
    }

    doubleVector extMin(subNames.size(), -1e+37);
    doubleVector extMax(subNames.size(), +1e+37);

    // Set up the default attributes to contain these values, so
    // if the user hits reset, the axis names are retained.
    defaultAtts->SetVisualAxisNames(subNames);
    defaultAtts->SetExtentMinima(extMin);
    defaultAtts->SetExtentMaxima(extMax);
    *(ParallelCoordinatesAttributes*)atts = *defaultAtts;
}

	void Emit(const Expression& expr, int _backtrackIndex)
	{
		switch (expr.GetType())
		{
			case ExpressionType_Empty:
			{
				Line("r = true;");
				break;
			}
				
			case ExpressionType_Choice:
			{
				const Expression::Group& group = expr.GetGroup();
				bool mayUndoVisit = !group.first.isLeaf;
				DefineBacktrack(_backtrackIndex, mayUndoVisit);
				Emit(group.first, _backtrackIndex);
				If("!r");
				OpenBlock();
				Backtrack(_backtrackIndex, mayUndoVisit);
				Emit(group.second, _backtrackIndex);
				CloseBlock();
				break;
			}
				
			case ExpressionType_Sequence:
			{
				const Expression::Group& group = expr.GetGroup();
				Emit(group.first, _backtrackIndex);
				If("r");
				OpenBlock();
				Emit(group.second, -1);
				CloseBlock();
				break;
			}

			case ExpressionType_Not:
			{
				bool traverse = mTraverse;
				mTraverse = false;
				DefineBacktrack(_backtrackIndex, false);
				Emit(expr.GetChild(), _backtrackIndex);
				Line("r = !r;");
				Line(format("p = %1%;") % BacktrackVar(_backtrackIndex));
				mTraverse = traverse;
				break;
			}
				
			case ExpressionType_ZeroOrMore:
			{
				_backtrackIndex = -1;
				Line("for (;;)");
				OpenBlock();
				const Expression& child = expr.GetChild();
				bool mayUndoVisit = !child.isLeaf;
				DefineBacktrack(_backtrackIndex, mayUndoVisit);
				Emit(child, _backtrackIndex);
				If("!r");
				OpenBlock();
				Backtrack(_backtrackIndex, mayUndoVisit);
				Line("break;");
				CloseBlock();
				CloseBlock();
				Line("r = true;");
				break;
			}
				
			case ExpressionType_NonTerminal:
			{
				const string& nonTerminal = expr.GetNonTerminal();
				const Def& def = *mGrammar.defs.find(nonTerminal);
				const DefValue& defval = def.second;
				if (mTraverse)
				{
					if (defval.isNode)
						Line(format("r = Visit(_ctx, SymbolType_%1%, p, v);") % nonTerminal);
					else if (defval.isMemoized)
						Line(format("r = TraverseSkip(_ctx, SkipType_%1%, p, v);") % nonTerminal);
					else
						Line(format("r = Traverse_%1%(_ctx, p, v);") % nonTerminal);
				}
				else
				{
					if (defval.isNode)
						Line(format("r = ParseSymbol(_ctx, SymbolType_%1%, p);") % nonTerminal);
					else if (defval.isMemoized)
						Line(format("r = ParseSkip(_ctx, SkipType_%1%, p);") % nonTerminal);
					else
						Line(format("r = Parse_%1%(_ctx, p);") % nonTerminal);
				}
				break;
			}
				
			case ExpressionType_Range:
			{
				int charIndex = mNextCharIndex++;
				Line(format("Char c%1% = *p++;") % charIndex);
				Line(format("r = (c%1% >= \'%2%\' && c%1% <= \'%3%\');") % charIndex % EscapeChar(expr.GetFirst()) % EscapeChar(expr.GetLast()));
				break;
			}
				
//.........这里部分代码省略.........