void Expr::append(const Expr& expr)
{
ListExpr* le = dynamic_cast<ListExpr*>(ptr().get());
if (le != 0)
{
le->append(expr);
return;
}
else
{
if (ptr().get()==0)
{
Array<Expr> e(1);
e[0] = expr;
ptr() = rcp(new ListExpr(e));
}
else
{
Array<Expr> e(2);
e[0] = *this;
e[1] = expr;
ptr() = rcp(new ListExpr(e));
}
}
}
void Resolver::visit(ListExpr& expr, int dummy)
{
for (int i = 0; i < expr.elements().count(); i++)
{
resolve(expr.elements()[i]);
}
}
void
avtApplyEnumerationExpression::ProcessArguments(ArgsExpr *args,
ExprPipelineState *state)
{
// Check the number of arguments
std::vector<ArgExpr*> *arguments = args->GetArgs();
if (arguments->size() != 2)
{
EXCEPTION2(ExpressionException, outputVariableName,
"the enumerate expression accepts only two arguments");
}
ArgExpr *listarg = (*arguments)[1];
ExprParseTreeNode *listTree = listarg->GetExpr();
if (listTree->GetTypeName() != "List")
{
debug1 << "avtApplyEnumerationExpression: second arg is not a list: "
<< listTree->GetTypeName() << endl;
EXCEPTION2(ExpressionException, outputVariableName,
"the last argument to enumerate "
"must be a list");
}
ListExpr *list = dynamic_cast<ListExpr*>(listTree);
std::vector<ListElemExpr*> *elems = list->GetElems();
enumeratedValues.resize(elems->size());
for (int i = 0 ; i < elems->size() ; i++)
{
if ((*elems)[i]->GetEnd())
{
EXCEPTION2(ExpressionException, outputVariableName,
"the list for the enumerate "
"expression cannot contain ranges.");
}
ExprNode *item = (*elems)[i]->GetItem();
if (item->GetTypeName() == "FloatConst")
{
ConstExpr *c = dynamic_cast<ConstExpr*>(item);
enumeratedValues[i] = dynamic_cast<FloatConstExpr*>(c)->GetValue();
}
else if (item->GetTypeName() == "IntegerConst")
{
ConstExpr *c = dynamic_cast<ConstExpr*>(item);
enumeratedValues[i] = dynamic_cast<IntegerConstExpr*>(c)->GetValue();
}
else
{
EXCEPTION2(ExpressionException, outputVariableName,
"the list for the enumerate "
"expression may contain only numbers.");
}
}
// Let the base class do this processing. We only had to over-ride this
// function to determine the number of arguments.
avtMultipleInputExpressionFilter::ProcessArguments(args, state);
}
void ExprCompiler::visit(ListExpr& expr, int dest)
{
// TODO(bob): Putting these all in registers and then copying them to the
// list after creation may be slow. Another option to consider is to write
// a start list bytecode first, and then have each element get pushed
// directly to the new list.
int firstElement = getNextTemp();
for (int i = 0; i < expr.elements().count(); i++)
{
int element = makeTemp();
compile(expr.elements()[i], element);
}
write(expr, OP_LIST, firstElement, expr.elements().count(), dest);
releaseTemps(expr.elements().count());
}
bool Flower::onParseComplete(Unit* unit)
{
std::list<Symbol*> calls;
printf("Flower.onParseComplete()\n");
for (auto& call: FlowCallIterator(unit)) {
if (call->callee()->name() != "assert" && call->callee()->name() != "assert_fail")
continue;
ListExpr* args = call->args();
if (args->empty()) continue;
// add a string argument that equals the expression's source code
Expr* arg = args->at(0);
std::string source = arg->sourceLocation().text();
args->push_back(new StringExpr(source, SourceLocation()));
}
return true;
}
void
avtArrayComposeWithBinsExpression::ProcessArguments(ArgsExpr *args,
ExprPipelineState *state)
{
// Check the number of arguments
std::vector<ArgExpr*> *arguments = args->GetArgs();
nvars = (int)arguments->size()-1;
int idx_of_list = arguments->size()-1;
ArgExpr *listarg = (*arguments)[idx_of_list];
ExprParseTreeNode *listTree = listarg->GetExpr();
if (listTree->GetTypeName() != "List")
{
debug1 << "avtArrayComposeWithBinsExpression: second arg is not a "
<< "list: " << listTree->GetTypeName() << endl;
EXCEPTION2(ExpressionException, outputVariableName,
"the last argument to array_compose_"
"with_bins must be a list");
}
ListExpr *list = dynamic_cast<ListExpr*>(listTree);
std::vector<ListElemExpr*> *elems = list->GetElems();
binRanges.resize(elems->size());
if ((int)elems->size() != nvars+1)
{
EXCEPTION2(ExpressionException, outputVariableName,
"the list for array_compose_with_bins"
" must have one more number than there are variables. "
" For two variables (V1 and V2), there should be a list of"
" size 3: [L0, L1, L2]. V1's bin goes from L0 to L1, "
"and V2's bin goes from L1 to L2.");
}
for (size_t i = 0 ; i < elems->size() ; i++)
{
if ((*elems)[i]->GetEnd())
{
EXCEPTION2(ExpressionException, outputVariableName,
"the list for array_compose_with"
"_bins expression cannot contain ranges.");
}
ExprNode *item = (*elems)[i]->GetItem();
if (item->GetTypeName() == "FloatConst")
{
ConstExpr *c = dynamic_cast<ConstExpr*>(item);
binRanges[i] = dynamic_cast<FloatConstExpr*>(c)->GetValue();
}
else if (item->GetTypeName() == "IntegerConst")
{
ConstExpr *c = dynamic_cast<ConstExpr*>(item);
binRanges[i] = dynamic_cast<IntegerConstExpr*>(c)->GetValue();
}
else
{
EXCEPTION2(ExpressionException, outputVariableName,
"the list for the array_compose"
"_with_bins expression may contain only numbers.");
}
}
// Let the base class do this processing. We only had to over-ride this
// function to determine the number of arguments.
avtMultipleInputExpressionFilter::ProcessArguments(args, state);
}
void ListExpr::addBefore(const ListExpr &l){
std::vector<ExprPtr> v = l.getExprs();
exprs.insert(exprs.begin(),v.begin(),v.end());
}
ListExpr::ListExpr(const ListExpr &l){
for(ExprPtr e : l.getExprs())
exprs.push_back(e);
}
// ****************************************************************************
// Method: avtMatvfExpression::ProcessArguments
//
// Purpose:
// Tells the first argument to go generate itself. Parses the second
// argument into a list of material names.
//
// Arguments:
// inDS The input dataset.
//
// Returns: The derived variable. The calling class must free this
// memory.
//
// Programmer: Sean Ahern
// Creation: Tue Mar 18 23:20:06 America/Los_Angeles 2003
//
// Modifications:
// Jeremy Meredith, Mon Sep 29 12:13:04 PDT 2003
// Added support for integer material indices.
// Added support for integer ranges.
//
// Hank Childs, Thu Jul 15 14:44:17 PDT 2004
// Make sure the base pointer type for the dynamic cast is in the
// inheritance tree of what we are downcasting type. ('5201)
//
// Jeremy Meredith, Wed Nov 24 12:26:21 PST 2004
// Renamed EngineExprNode to avtExprNode due to a refactoring.
// Also renamed Token to ExprToken for the same reason.
// Changed the base type for an Arg's expression.
//
// Jeremy Meredith, Mon Jun 13 11:42:38 PDT 2005
// Changed the way constant expressions work.
//
// ****************************************************************************
void
avtMatvfExpression::ProcessArguments(ArgsExpr *args, ExprPipelineState *state)
{
// Check the number of arguments
std::vector<ArgExpr*> *arguments = args->GetArgs();
int nargs = arguments->size();
if (nargs == 0)
{
EXCEPTION2(ExpressionException, outputVariableName, "avtMatvfExpression: No arguments given.");
}
// Tell the first argument to create its filters.
ArgExpr *firstarg = (*arguments)[0];
avtExprNode *firstTree = dynamic_cast<avtExprNode*>(firstarg->GetExpr());
firstTree->CreateFilters(state);
// Check if there's a second argument.
if (nargs == 1)
{
debug5 << "avtMatvfExpression: No second argument." << endl;
return;
}
// See if there are other arguments.
if (nargs > 2)
{
EXCEPTION2(ExpressionException, outputVariableName, "avtMatvfExpression only expects two "
"arguments. To specify more than one material, use a "
"list (e.g. [1,4,5:9].");
}
// Pull off the second argument and see if it's a string or a list.
ArgExpr *secondarg = (*arguments)[1];
ExprParseTreeNode *secondTree = secondarg->GetExpr();
std::string type = secondTree->GetTypeName();
if ((type != "IntegerConst") && (type != "StringConst") && (type != "List"))
{
debug5 << "avtMatvfExpression: Second argument is not a constant or a list: " << type.c_str() << endl;
EXCEPTION2(ExpressionException, outputVariableName, "avtMatvfExpression: Second argument is not a constant or a list.");
}
if (type == "IntegerConst" || type == "StringConst")
{
// It's a single constant.
AddMaterial(dynamic_cast<ConstExpr*>(secondTree));
}
else
{
// It's a list. Process all of them.
ListExpr *list = dynamic_cast<ListExpr*>(secondTree);
std::vector<ListElemExpr*> *elems = list->GetElems();
for(int i=0;i<elems->size();i++)
{
if ((*elems)[i]->GetEnd())
{
// it's a range
ExprNode *begExpr = (*elems)[i]->GetBeg();
ExprNode *endExpr = (*elems)[i]->GetEnd();
ExprNode *skipExpr = (*elems)[i]->GetSkip();
if (begExpr->GetTypeName() != "IntegerConst" ||
endExpr->GetTypeName() != "IntegerConst" ||
(skipExpr && skipExpr->GetTypeName() != "IntegerConst"))
{
EXCEPTION2(ExpressionException, outputVariableName, "avtMatvfExpression: "
"Range must contain integers.");
}
int beg = dynamic_cast<IntegerConstExpr*>(begExpr)->GetValue();
int end = dynamic_cast<IntegerConstExpr*>(endExpr)->GetValue();
int skip = !skipExpr ? 1 :
dynamic_cast<IntegerConstExpr*>(skipExpr)->GetValue();
if (skip <= 0 || beg > end)
{
EXCEPTION2(ExpressionException, outputVariableName, "avtMatvfExpression: "
"Range must be of the form beg:end[:skip].");
}
for (int m = beg; m <= end ; m += skip)
matIndices.push_back(m);
}
else
{
ExprNode *item = (*elems)[i]->GetItem();
std::string type = item->GetTypeName();
if (type != "IntegerConst" && type != "StringConst")
{
debug5 << "avtMatvfExpression: List element is not an "
"integer constant, a string constant, "
"or a list: " << type.c_str() << endl;
EXCEPTION2(ExpressionException, outputVariableName, "avtMatvfExpression: "
"List element is not an int/string constant "
"or a list.");
}
AddMaterial(dynamic_cast<ConstExpr*>(item));
}
}
}
}