ExpressionResult NegateExpression::DoEvaluate(ScriptFrame& frame, DebugHint *dhint) const { ExpressionResult operand = m_Operand->Evaluate(frame); CHECK_RESULT(operand); return ~(long)operand.GetValue(); }
ExpressionResult LogicalNegateExpression::DoEvaluate(ScriptFrame& frame, DebugHint *dhint) const { ExpressionResult operand = m_Operand->Evaluate(frame); CHECK_RESULT(operand); return !operand.GetValue().ToBool(); }
ExpressionResult ThrowExpression::DoEvaluate(ScriptFrame& frame, DebugHint *dhint) const { ExpressionResult messageres = m_Message->Evaluate(frame); CHECK_RESULT(messageres); Value message = messageres.GetValue(); BOOST_THROW_EXCEPTION(ScriptError(message, m_DebugInfo, m_IncompleteExpr)); }
ExpressionResult ImportExpression::DoEvaluate(ScriptFrame& frame, DebugHint *dhint) const { if (frame.Sandboxed) BOOST_THROW_EXCEPTION(ScriptError("Imports are not allowed in sandbox mode.", m_DebugInfo)); String type = VMOps::GetField(frame.Self, "type", frame.Sandboxed, m_DebugInfo); ExpressionResult nameres = m_Name->Evaluate(frame); CHECK_RESULT(nameres); Value name = nameres.GetValue(); if (!name.IsString()) BOOST_THROW_EXCEPTION(ScriptError("Template/object name must be a string", m_DebugInfo)); ConfigItem::Ptr item = ConfigItem::GetByTypeAndName(Type::GetByName(type), name); if (!item) BOOST_THROW_EXCEPTION(ScriptError("Import references unknown template: '" + name + "'", m_DebugInfo)); Dictionary::Ptr scope = item->GetScope(); if (scope) scope->CopyTo(frame.Locals); ExpressionResult result = item->GetExpression()->Evaluate(frame, dhint); CHECK_RESULT(result); return Empty; }
ExpressionResult DictExpression::DoEvaluate(ScriptFrame& frame, DebugHint *dhint) const { Value self; if (!m_Inline) { self = frame.Self; frame.Self = new Dictionary(); } Value result; try { for (Expression *aexpr : m_Expressions) { ExpressionResult element = aexpr->Evaluate(frame, m_Inline ? dhint : NULL); CHECK_RESULT(element); result = element.GetValue(); } } catch (...) { if (!m_Inline) std::swap(self, frame.Self); throw; } if (m_Inline) return result; else { std::swap(self, frame.Self); return self; } }
ExpressionResult FunctionCallExpression::DoEvaluate(ScriptFrame& frame, DebugHint *dhint) const { Value self, vfunc; String index; if (m_FName->GetReference(frame, false, &self, &index)) vfunc = VMOps::GetField(self, index, frame.Sandboxed, m_DebugInfo); else { ExpressionResult vfuncres = m_FName->Evaluate(frame); CHECK_RESULT(vfuncres); vfunc = vfuncres.GetValue(); } if (vfunc.IsObjectType<Type>()) { std::vector<Value> arguments; for (Expression *arg : m_Args) { ExpressionResult argres = arg->Evaluate(frame); CHECK_RESULT(argres); arguments.push_back(argres.GetValue()); } return VMOps::ConstructorCall(vfunc, arguments, m_DebugInfo); } if (!vfunc.IsObjectType<Function>()) BOOST_THROW_EXCEPTION(ScriptError("Argument is not a callable object.", m_DebugInfo)); Function::Ptr func = vfunc; if (!func->IsSideEffectFree() && frame.Sandboxed) BOOST_THROW_EXCEPTION(ScriptError("Function is not marked as safe for sandbox mode.", m_DebugInfo)); std::vector<Value> arguments; for (Expression *arg : m_Args) { ExpressionResult argres = arg->Evaluate(frame); CHECK_RESULT(argres); arguments.push_back(argres.GetValue()); } return VMOps::FunctionCall(frame, self, func, arguments); }
ExpressionResult ForExpression::DoEvaluate(ScriptFrame& frame, DebugHint *dhint) const { if (frame.Sandboxed) BOOST_THROW_EXCEPTION(ScriptError("For loops are not allowed in sandbox mode.", m_DebugInfo)); ExpressionResult valueres = m_Value->Evaluate(frame, dhint); CHECK_RESULT(valueres); return VMOps::For(frame, m_FKVar, m_FVVar, valueres.GetValue(), m_Expression, m_DebugInfo); }
ExpressionResult ApplyExpression::DoEvaluate(ScriptFrame& frame, DebugHint *dhint) const { if (frame.Sandboxed) BOOST_THROW_EXCEPTION(ScriptError("Apply rules are not allowed in sandbox mode.", m_DebugInfo)); ExpressionResult nameres = m_Name->Evaluate(frame); CHECK_RESULT(nameres); return VMOps::NewApply(frame, m_Type, m_Target, nameres.GetValue(), m_Filter, m_Package, m_FKVar, m_FVVar, m_FTerm, m_ClosedVars, m_IgnoreOnError, m_Expression, m_DebugInfo); }
ExpressionResult LibraryExpression::DoEvaluate(ScriptFrame& frame, DebugHint *dhint) const { if (frame.Sandboxed) BOOST_THROW_EXCEPTION(ScriptError("Loading libraries is not allowed in sandbox mode.", m_DebugInfo)); ExpressionResult libres = m_Operand->Evaluate(frame, dhint); CHECK_RESULT(libres); Loader::LoadExtensionLibrary(libres.GetValue()); return Empty; }
ExpressionResult ObjectExpression::DoEvaluate(ScriptFrame& frame, DebugHint *dhint) const { if (frame.Sandboxed) BOOST_THROW_EXCEPTION(ScriptError("Object definitions are not allowed in sandbox mode.", m_DebugInfo)); ExpressionResult typeres = m_Type->Evaluate(frame, dhint); CHECK_RESULT(typeres); Type::Ptr type = typeres.GetValue(); String name; if (m_Name) { ExpressionResult nameres = m_Name->Evaluate(frame, dhint); CHECK_RESULT(nameres); name = nameres.GetValue(); } return VMOps::NewObject(frame, m_Abstract, type, name, m_Filter, m_Zone, m_Package, m_DefaultTmpl, m_IgnoreOnError, m_ClosedVars, m_Expression, m_DebugInfo); }
ExpressionResult ConditionalExpression::DoEvaluate(ScriptFrame& frame, DebugHint *dhint) const { ExpressionResult condition = m_Condition->Evaluate(frame, dhint); CHECK_RESULT(condition); if (condition.GetValue().ToBool()) return m_TrueBranch->Evaluate(frame, dhint); else if (m_FalseBranch) return m_FalseBranch->Evaluate(frame, dhint); return Empty; }
ExpressionResult ArrayExpression::DoEvaluate(ScriptFrame& frame, DebugHint *dhint) const { Array::Ptr result = new Array(); result->Reserve(m_Expressions.size()); for (Expression *aexpr : m_Expressions) { ExpressionResult element = aexpr->Evaluate(frame); CHECK_RESULT(element); result->Add(element.GetValue()); } return result; }
ExpressionResult UsingExpression::DoEvaluate(ScriptFrame& frame, DebugHint *dhint) const { if (frame.Sandboxed) BOOST_THROW_EXCEPTION(ScriptError("Using directives are not allowed in sandbox mode.", m_DebugInfo)); ExpressionResult importres = m_Name->Evaluate(frame); CHECK_RESULT(importres); Value import = importres.GetValue(); if (!import.IsObjectType<Dictionary>()) BOOST_THROW_EXCEPTION(ScriptError("The parameter must resolve to an object of type 'Dictionary'", m_DebugInfo)); ScriptFrame::AddImport(import); return Empty; }
ExpressionResult WhileExpression::DoEvaluate(ScriptFrame& frame, DebugHint *dhint) const { if (frame.Sandboxed) BOOST_THROW_EXCEPTION(ScriptError("While loops are not allowed in sandbox mode.", m_DebugInfo)); for (;;) { ExpressionResult condition = m_Condition->Evaluate(frame, dhint); CHECK_RESULT(condition); if (!condition.GetValue().ToBool()) break; ExpressionResult loop_body = m_LoopBody->Evaluate(frame, dhint); CHECK_RESULT_LOOP(loop_body); } return Empty; }
ExpressionResult IncludeExpression::DoEvaluate(ScriptFrame& frame, DebugHint *dhint) const { if (frame.Sandboxed) BOOST_THROW_EXCEPTION(ScriptError("Includes are not allowed in sandbox mode.", m_DebugInfo)); Expression *expr; String name, path, pattern; switch (m_Type) { case IncludeRegular: { ExpressionResult pathres = m_Path->Evaluate(frame, dhint); CHECK_RESULT(pathres); path = pathres.GetValue(); } expr = ConfigCompiler::HandleInclude(m_RelativeBase, path, m_SearchIncludes, m_Zone, m_Package, m_DebugInfo); break; case IncludeRecursive: { ExpressionResult pathres = m_Path->Evaluate(frame, dhint); CHECK_RESULT(pathres); path = pathres.GetValue(); } { ExpressionResult patternres = m_Pattern->Evaluate(frame, dhint); CHECK_RESULT(patternres); pattern = patternres.GetValue(); } expr = ConfigCompiler::HandleIncludeRecursive(m_RelativeBase, path, pattern, m_Zone, m_Package, m_DebugInfo); break; case IncludeZones: { ExpressionResult nameres = m_Name->Evaluate(frame, dhint); CHECK_RESULT(nameres); name = nameres.GetValue(); } { ExpressionResult pathres = m_Path->Evaluate(frame, dhint); CHECK_RESULT(pathres); path = pathres.GetValue(); } { ExpressionResult patternres = m_Pattern->Evaluate(frame, dhint); CHECK_RESULT(patternres); pattern = patternres.GetValue(); } expr = ConfigCompiler::HandleIncludeZones(m_RelativeBase, name, path, pattern, m_Package, m_DebugInfo); break; } ExpressionResult res(Empty); try { res = expr->Evaluate(frame, dhint); } catch (const std::exception&) { delete expr; throw; } delete expr; return res; }