/**
* Run a function given its call string, eg "doSomething(1,2,opt=True)"
*/
boost::shared_ptr<Variable> ScriptModule::runFunction(const std::string& fnStr)
{
Kernel::EParser pars;
pars.parse(fnStr);
std::string fnName = pars.name();
ScriptFunction_ptr fun = getFunction(fnName);
if (fun)
{
bool keyWords = false;
const std::vector<std::string>& argNames = fun->arguments();
for(int i=0;i<pars.size();++i)
{
const Kernel::EParser& arg = pars[i];
if (!keyWords){ keyWords = (arg.name() == "=");}
if (!keyWords)
{
if (i >= argNames.size())
{
throw std::invalid_argument("Wrong number of arguments in "+fnName);
}
Expression valExpr(m_namespace,arg);
fun->setArgument(argNames[i],valExpr.eval());
}
else
{
if (arg.name() != "=")
{
throw std::invalid_argument("Keyword argument expected in "+fnName);
}
Expression valExpr(m_namespace,arg[1]);
fun->setArgument(arg[0].name(),valExpr.eval());
}
}
fun->eval();
Variable_ptr res = fun->getLocalNamespace_ptr()->getVariable("return");
return res;
}
return Variable_ptr();
}
Node* WidthRatioNodeFactory::getNode( const QString &tagContent, Parser *p ) const
{
QStringList expr = smartSplit( tagContent );
if ( expr.size() != 4 ) {
throw Grantlee::Exception( TagSyntaxError, QStringLiteral( "widthratio takes three arguments" ) );
}
FilterExpression valExpr( expr.at( 1 ), p );
FilterExpression maxExpr( expr.at( 2 ), p );
FilterExpression maxWidth( expr.at( 3 ), p );
return new WidthRatioNode( valExpr, maxExpr, maxWidth, p );
}
ScriptLine* ScriptLineBlock::createLine(const Kernel::EParser& code)
{
if (code.name() == ":") // define variable
{
std::string type = code[0].name();
std::string name,value = "";
if (code[1].name() != "=")
{
name = code[1].name();
}
else
{
name = code[1][0].name();
Expression valExpr(m_local_namespace,code[1][1].str());
value = valExpr.eval().toString();
}
return new ScriptLineDef(m_local_namespace,type,name,value);
}
else if (code.name() == "=") // assign new value
{
std::string name = code[0].name();
const Kernel::EParser& value = code[1];
return new ScriptLineSet(m_local_namespace,name,Expression_ptr(new Expression(m_local_namespace,value)));
}
else if (code.name() == "if") // if(cond1:expr1,cond2:(expr2;expr3;expr4;...),def_expr)
{
ScriptLineIf *sif = new ScriptLineIf(m_local_namespace);
size_t n = code.size();
for(size_t i=0; i<n; ++i)
{
const Kernel::EParser& clause = code[i];
if (clause.name() == ":")
{
Expression* cond = new Expression(m_local_namespace,clause[0]);
ScriptAnonymousBlock* block = new ScriptAnonymousBlock(this);
//block->addLines(clause[1]);
sif->addCondition(Expression_ptr(cond),ScriptAnonymousBlock_ptr(block));
}
else
{
ScriptAnonymousBlock* block = new ScriptAnonymousBlock(this);
//block->addLines(clause);
sif->addDefault(ScriptAnonymousBlock_ptr(block));
}
}
return sif;
}
else if (code.name() == "for") // for(Scalar: i=0,i<10,i = i + 1,(line1;line2;line3;...))
{
if (code.size() != 4)
{
throw std::runtime_error("Script line -for- has a wrong structure");
}
ScriptAnonymousBlock_ptr block = ScriptAnonymousBlock_ptr(new ScriptAnonymousBlock(this));
ScriptLine* init = block->createLine(code[0]);
Expression_ptr end_cond(new Expression(block->getLocalNamespace_ptr(),code[1]));
ScriptLine* next = block->createLine(code[2]);
//block->addLines(code[3]);
ScriptLineFor* sfor = new ScriptLineFor(init,end_cond,next,block);
return sfor;
}
else // function call
{
std::string fnName = code.name();
ScriptLineCall* call = new ScriptLineCall(m_local_namespace,*this,fnName);
for(int i=0; i<code.size(); ++i) // looping the function arguments
{
const Kernel::EParser& arg = code[i];
if (arg.name() != "=")
{
throw std::invalid_argument("Actual function arguments must be passed as name=value");
}
std::string name = arg[0].name();
const Kernel::EParser& value = arg[1];
call->setArgument(name,value);
}
call->check();
return call;
}
return NULL;
}
