protected override object DoEvaluate(ScriptThread thread)
{
// standard prolog
thread.CurrentNode = this;
object result = null;
// is this variable a part of a pattern?
if (UseType == NodeUseType.Name)
{
// don't evaluate it
result = CreateVariable();
}
else
{
// get last recognized pattern
var pattern = thread.GetLastPattern();
if (pattern == null)
{
thread.ThrowScriptError("No pattern recognized!");
return null;
}
// read variable from the last recognized pattern
result = pattern.GetVariable(Index);
}
// standard epilog
thread.CurrentNode = Parent;
return result;
}
protected override object DoEvaluate(ScriptThread thread)
{
thread.CurrentNode = this; //standard prolog
var pi = thread.GetPageInfo();
var test = globalNode.AsString.ToLower();
if (test.Contains(":")) {
Console.WriteLine("");
}
if ( test == "pagenumber") {
return pi.PageNumber;
} else if (test == "pages") {
return pi.TotalPages;
} else if (test == "reportname") {
return pi.ReportName;
} else if (test == "reportfolder") {
return pi.ReportFolder;
} else if (test == "reportfilename") {
return pi.ReportFileName;
}
else {
return String.Format(CultureInfo.CurrentCulture,"Syntaxerror in Globals <{0}>",globalNode.AsString);
}
}
protected override object DoEvaluate(Irony.Interpreter.ScriptThread thread)
{
thread.CurrentNode = this;
try
{
var res = new MtResult();
var accessor = thread.Bind(_targetName.AsString, BindingRequestFlags.Write | BindingRequestFlags.ExistingOrNew);
accessor.SetValueRef(thread, res);
// To allow recursive definitions, we have
// to evaluate _expression inside the new context.
var exprResult = _expression.Evaluate(thread) as MtResult;
exprResult.GetValue((o) =>
{
res.SetValue((state) =>
{
return(o);
});
});
return(res);
}
catch (Exception e)
{
throw new Exception("Exception on MtBind.DoEvaluate", e);
}
finally
{
//thread.CurrentNode = Parent;
}
}
// Evaluation for special forms
private object EvaluateSpecialForm(ScriptThread thread)
{
thread.CurrentNode = this; //standard prolog
var result = _specialForm(thread, _specialFormArgs);
thread.CurrentNode = Parent; //standard epilog
return result;
}
protected override object ReallyDoEvaluate(ScriptThread thread)
{
Context.CurrentAct = actnumber;
thread.rs().Action.At(Span).Label(actnumber);
return base.ReallyDoEvaluate(thread);
}
public static object Iif(ScriptThread thread, AstNode[] childNodes)
{
var testValue = childNodes[0].Evaluate(thread);
object result = thread.Runtime.IsTrue(testValue) ? childNodes[1].Evaluate(thread) : childNodes[2].Evaluate(thread);
return result;
}
protected override object DoEvaluate(ScriptThread thread)
{
// standard prolog
thread.CurrentNode = this;
if (EntryPoint == null)
{
thread.ThrowScriptError("No entry point defined (entry point is a function named «Go»)");
return null;
}
// define built-in runtime library functions
var libraryFunctions = LibraryFunction.ExtractLibraryFunctions(thread, new RefalLibrary(thread));
foreach (var libFun in libraryFunctions)
{
var binding = thread.Bind(libFun.Name, BindingRequestFlags.Write | BindingRequestFlags.ExistingOrNew);
binding.SetValueRef(thread, libFun);
}
// define functions declared in the compiled program
foreach (var fun in FunctionList)
{
fun.Evaluate(thread);
}
// call entry point with an empty expression
EntryPoint.Call(thread, new object[] { PassiveExpression.Build() });
// standard epilog
thread.CurrentNode = Parent;
return null;
}
protected override object DoEvaluate(ScriptThread thread)
{
// standard prolog
thread.CurrentNode = this;
var binding = thread.Bind(FunctionName, BindingRequestFlags.Read);
var result = binding.GetValueRef(thread);
if (result == null)
{
thread.ThrowScriptError("Unknown identifier: {0}", FunctionName);
return null;
}
CallTarget = result as ICallTarget;
if (CallTarget == null)
{
thread.ThrowScriptError("This identifier cannot be called: {0}", FunctionName);
return null;
}
// set Evaluate pointer
Evaluate = DoCall;
// standard epilog is done by DoCall
return DoCall(thread);
}
protected override object DoEvaluate(ScriptThread thread)
{
thread.CurrentNode = this;
try
{
var result = new MtResult();
var targetThread = _target.NewScriptThread(thread);
var rTarget = _target.Evaluate(targetThread) as MtResult;
var sourceThread = _source.NewScriptThread(thread);
var rSource = _source.Evaluate(sourceThread) as MtResult;
rTarget.GetValue(target =>
{
rSource.GetValue(source =>
{
MtStream.ReadFromWriteTo(
source.Value as MtStream, target.Value as MtStream, () => {
result.SetValue(MtObject.True);
});
});
});
return result;
}
catch (Exception e)
{
throw new Exception("Exception on MtFlowRightToLeft.DoEvaluate", e);
}
finally
{
//thread.CurrentNode = Parent;
}
}
protected override object DoEvaluate(ScriptThread thread)
{
thread.CurrentNode = this; //standard prolog
//assign implementation method
switch (Op) {
case ExpressionType.AndAlso:
this.Evaluate = EvaluateAndAlso;
break;
case ExpressionType.OrElse:
this.Evaluate = EvaluateOrElse;
break;
default:
this.Evaluate = DefaultEvaluateImplementation;
break;
}
// actually evaluate and get the result.
var result = Evaluate(thread);
// Check if result is constant - if yes, save the value and switch to method that directly returns the result.
if (IsConstant()) {
_constValue = result;
AsString = Op + "(operator) Const=" + _constValue;
this.Evaluate = EvaluateConst;
}
thread.CurrentNode = Parent; //standard epilog
return result;
}
public static object Sum(ScriptThread thread, AstNode[] childNodes) {
double sum = 0;
var fieldName = childNodes[0].Evaluate(thread).ToString();
var dataSource = thread.GetDataSource();
var grouped = ImportAggregateHelper.IsGrouped(dataSource);
if (grouped != null) {
foreach (var element in grouped) {
var s = element.Sum(o => {
var v = ReadValueFromObject(fieldName, o);
return TypeNormalizer.EnsureType<double>(v);
});
sum = sum + s;
}
} else {
if (ImportAggregateHelper.FieldExist(dataSource.FirstOrDefault(),fieldName)) {
sum = dataSource.Sum(o => {
var v = ReadValueFromObject(fieldName, o);
return TypeNormalizer.EnsureType<double>(v);
});
}
}
return sum.ToString();
}
public static LibraryFunction[] ExtractLibraryFunctions(ScriptThread thread, object instance)
{
if (instance == null)
return new LibraryFunction[0];
var list = new List<LibraryFunction>();
var languageCaseSensitive = thread.App.Language.Grammar.CaseSensitive;
MethodInfo[] methods = instance.GetType().GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
foreach (MethodInfo method in methods)
{
var fun = method.CreateDelegate<LibraryDelegate>(instance, false);
if (fun != null)
{
var fname = method.GetCustomAttribute<FunctionNamesAttribute>();
var names = (fname == null) ? new string[] { method.Name } : fname.Names;
foreach (var strName in names)
{
string name = languageCaseSensitive ? strName : strName.ToLowerInvariant();
list.Add(new LibraryFunction(name, fun));
}
}
}
return list.ToArray();
}
public RefalLibrary(ScriptThread thread)
{
ScriptThread = thread;
OpenFiles = new Dictionary<string, object>();
BuriedKeys = new Dictionary<string, PassiveExpression>();
BuriedValues = new Dictionary<string, PassiveExpression>();
CommandLineArguments = null;
}
protected override object DoEvaluate(ScriptThread thread)
{
thread.CurrentNode = this; //standard prolog
SetupEvaluateMethod(thread);
var result = Evaluate(thread);
thread.CurrentNode = Parent; //standard epilog
return result;
}
protected override object DoEvaluate(ScriptThread thread)
{
thread.CurrentNode = this; //standard prolog
var arg = Argument.Evaluate(thread);
var result = thread.Runtime.ExecuteUnaryOperator(base.ExpressionType, arg, ref _lastUsed);
thread.CurrentNode = Parent; //standard epilog
return result;
}
protected override object DoEvaluate(ScriptThread thread)
{
thread.CurrentNode = this;
try
{
var programResult = new MtResult();
// do NOT use this for anything else other than counting the number of to-finish-threads
var count = _chains.Count;
var waitForAllToEnd = new ManualResetEvent(false);
// TODO THIS NEEDS TO BE FIXED!
// The rest of the program only cares about the result of the last expression
// which doesn't depend of the result of the previous expressions;
// however, the program shouldn't end.
// SOLUTION: Keep a global counter of all awaiting MtResults?
for (int i = 0; i < _chains.Count; ++i)
{
// This is here because of issues with closures using the for variable
var safe_i = i + 0;
var ch = _chains[i];
var subthread = ch.NewScriptThread(thread);
var chResult = ch.Evaluate(subthread) as MtResult;
// Lookout:
// do not capture anything loop related inside here
chResult.GetValue(delegate(MtObject x)
{
if (Interlocked.Decrement(ref count) == 0)
{
waitForAllToEnd.Set();
}
// Wait for the last chain to end.
// Last refers in the order of the chain in the code,
// not the order of execution!!!
if (safe_i == _chains.Count - 1)
{
// Wait for the end of *all* the chains before returning ...
waitForAllToEnd.WaitOne();
programResult.SetValue(x);
}
});
}
// Return value does not matter. This is asynchronous, remember?
return programResult;
}
catch (Exception e)
{
throw new Exception("Exception on MtProgram.", e);
}
finally
{
//thread.CurrentNode = Parent;
}
}
internal PassiveExpression EvaluateExpression(ScriptThread thread)
{
if (InnerExpression == null)
{
return PassiveExpression.Build(new OpeningBrace(), new ClosingBrace());
}
return PassiveExpression.Build(new OpeningBrace(), InnerExpression.Evaluate(thread), new ClosingBrace());
}
protected override object DoEvaluate(ScriptThread thread)
{
thread.CurrentNode=this;
object ret=_Identifier.Evaluate(thread);
thread.CurrentNode=Parent;
return ret;
}
protected object DefaultEvaluateImplementation(ScriptThread thread)
{
thread.CurrentNode = this; //standard prolog
var arg1 = Left.Evaluate(thread);
var arg2 = Right.Evaluate(thread);
var result = thread.Runtime.ExecuteBinaryOperator(this.Op, arg1, arg2, ref _lastUsed);
thread.CurrentNode = Parent; //standard epilog
return result;
}
//Executed only once, on the first call
protected override object DoEvaluate(ScriptThread thread)
{
thread.CurrentNode = this; //standard prolog
_accessor = thread.Bind(Symbol, BindingRequestFlags.Read);
this.Evaluate = _accessor.GetValueRef; // Optimization - directly set method ref to accessor's method. EvaluateReader;
var result = this.Evaluate(thread);
thread.CurrentNode = Parent; //standard epilog
return result;
}
private object EvaluateAfter(ScriptThread thread)
{
thread.CurrentNode = this; //standard prolog
var closure = new Closure(thread.CurrentScope, this);
if (NameNode != null)
NameNode.SetValue(thread, closure);
thread.CurrentNode = Parent; //standard epilog
return closure;
}
public override void DoSetValue(ScriptThread thread, object value)
{
thread.CurrentNode = this; //standard prolog
if (_accessor == null) {
_accessor = thread.Bind(Symbol, BindingRequestFlags.Write | BindingRequestFlags.ExistingOrNew);
}
_accessor.SetValueRef(thread, value);
thread.CurrentNode = Parent; //standard epilog
}
public BindingRequest(ScriptThread thread, AstNode fromNode, string symbol, BindingRequestFlags flags) {
Thread = thread;
FromNode = fromNode;
FromModule = thread.App.DataMap.GetModule(fromNode.ModuleNode);
Symbol = symbol;
Flags = flags;
FromScopeInfo = thread.CurrentScope.Info;
IgnoreCase = !thread.Runtime.Language.Grammar.CaseSensitive;
}
protected override object DoEvaluate(ScriptThread thread)
{
thread.CurrentNode = this; //standard prolog
var oldValue = Argument.Evaluate(thread);
var newValue = thread.Runtime.ExecuteBinaryOperator(BinaryOp, oldValue, 1, ref _lastUsed);
Argument.SetValue(thread, newValue);
var result = IsPostfix ? oldValue : newValue;
thread.CurrentNode = Parent; //standard epilog
return result;
}
private object EvaluateAugmented(ScriptThread thread)
{
thread.CurrentNode = this; //standard prolog
var value = Target.Evaluate(thread);
var exprValue = Expression.Evaluate(thread);
var result = thread.Runtime.ExecuteBinaryOperator(BinaryExpressionType, value, exprValue, ref _lastUsed);
Target.SetValue(thread, result);
thread.CurrentNode = Parent; //standard epilog
return result;
}
protected override object DoEvaluate(Irony.Interpreter.ScriptThread thread)
{
base.DoEvaluate(thread);
thread.CurrentNode = this; //standard prolog
var obj = ReallyDoEvaluate(thread);
thread.CurrentNode = Parent; //standard epilog
return(obj);
}
protected override object DoEvaluate(ScriptThread thread)
{
BasicParameter result = null;
thread.CurrentNode = this; //standard prolog
var parametersCollection = thread.GetParametersCollection();
result = parametersCollection.Find(parameterNode.AsString);
if (result == null)
return ExpressionHelper.ComposeAstNodeError("Parameters",parameterNode);
return result.ParameterValue;
}
protected override object DoEvaluate(ScriptThread thread)
{
thread.CurrentNode = this; //standard prolog
var values = new object[ChildNodes.Count];
for (int i = 0; i < values.Length; i++) {
values[i] = ChildNodes[i].Evaluate(thread);
}
thread.CurrentNode = Parent; //standard epilog
return values;
}
protected override object DoEvaluate(ScriptThread thread)
{
switch (_value.ToLower())
{
case "true": case "vrai": return true;
case "false": case "faux": return false;
}
return base.DoEvaluate(thread);
}
protected override object DoEvaluate(ScriptThread thread)
{
thread.CurrentNode = this; //standard prolog
var container = thread.GetCurrentContainer();
var column = (ExportText)container.ExportedItems.Where(x => x.Name == fieldNode.AsString).FirstOrDefault();
if (column == null) {
return ExpressionHelper.ComposeAstNodeError("Fields",fieldNode);
}
return column.Text;
}
protected override object DoEvaluate(ScriptThread thread)
{
thread.CurrentNode = this; //standard prolog
var ret = new object[this.ChildNodes.Count];
// Creates parameter slots
for (int i = 0; i < this.ChildNodes.Count; i++)
ret[i] = this.ChildNodes[i].Evaluate(thread);
thread.CurrentNode = Parent; //standard epilog
return ret;
}
private object EvaluateMultiple(ScriptThread thread)
{
thread.CurrentNode = this; //standard prolog
object result = null;
for (int i=0; i< ChildNodes.Count; i++) {
result = ChildNodes[i].Evaluate(thread);
}
thread.CurrentNode = Parent; //standard epilog
return result; //return result of last statement
}
protected override object DoEvaluate(Irony.Interpreter.ScriptThread thread)
{
// PROLOG
thread.CurrentNode = this;
try
{
var appResult = new MtResult();
MtResult[] args = _args.Evaluate(thread) as MtResult[];
if (args == null)
{
throw new Exception("Args evaluated to null!");
}
var subthreadF = _head.NewScriptThread(thread);
var headResult = _head.Evaluate(subthreadF);
if (headResult == null)
{
throw new Exception("Head can't evaluate to null!");
}
MtFunctionObjectBase.ExtractAsFunction(headResult, (wrkFun) =>
{
#if DEBUG && !SILVERLIGHT
if (wrkFun is BuiltInCallTarget)
{
var builtin = wrkFun as BuiltInCallTarget;
Debug.Print("Calling builtin: {0}", builtin.Name);
}
else
{
Debug.Print("Calling user function");
}
#endif
var resultFun = wrkFun.Call(thread, args) as MtResult;
resultFun.GetValue((r3) =>
{
appResult.SetValue(r3);
});
});
return(appResult);
}
catch (Exception e)
{
throw new Exception("Exception on MtApplication.", e);
}
finally
{
// EPILOG
//thread.CurrentNode = Parent;
}
}
protected override object ReallyDoEvaluate(Irony.Interpreter.ScriptThread thread)
{
var sw = thread.tc().Writer;
sw.WriteLine("/*********************************************************************");
sw.WriteLine(" * This C# program was generated by Shakespeare2CS by James Curran *");
sw.WriteLine(" * based on spl2c, the Shakespeare to C *");
sw.WriteLine(" * converter by Jon Åslund and Karl Hasselström. *");
sw.WriteLine(" *********************************************************************/");
sw.WriteLine();
sw.WriteLine("using System;");
sw.WriteLine("using Shakespeare.Support;");
sw.WriteLine();
sw.WriteLine("namespace Shakespeare.Program");
sw.WriteLine("{");
sw.WriteLine("\tclass Program");
sw.WriteLine("\t{");
sw.WriteLine("\t\tstatic void Main(string[] args)");
sw.WriteLine("\t\t{");
sw.WriteLine("\t\t\tvar script = new Script();");
sw.WriteLine("\t\t\tscript.Action();");
sw.WriteLine("\t\t}");
sw.WriteLine("\t}");
sw.WriteLine();
sw.WriteLine("\t\tclass Script : Dramaturge");
sw.WriteLine("\t\t{");
sw.WriteLine();
sw.WriteLine("\t\tpublic Script()");
sw.WriteLine("\t\t : base(Console.In, Console.Out)");
sw.WriteLine("\t\t{ }");
sw.WriteLine();
sw.WriteLine("\t\tpublic void Action()");
sw.WriteLine("\t\t{");
AstNode1.Evaluate(thread); // Title
sw.WriteLine();
var cdl = AstNode2 as CharacterDeclarationListNode;
foreach (var ch in cdl.Characters)
{
ch.Evaluate(thread);
}
sw.WriteLine();
AstNode3.Evaluate(thread);
sw.WriteLine("\t\t}");
sw.WriteLine("\t}");
sw.WriteLine("}");
sw.Flush();
sw.Close();
return(sw);
}
protected override object ReallyDoEvaluate(Irony.Interpreter.ScriptThread thread)
{
var rs = thread.rs();
var ag = rs.AG;
using (ag.Namespace("Shakespeare.Program"))
{
TypeGen scriptClass = ag.Public.Class("Script", typeof(Shakespeare.Support.Dramaturge));
{
rs.Script = scriptClass;
var console = typeof(Console);
CodeGen ctor = scriptClass.Public.Constructor();
ctor.InvokeBase(Static.Property(console, "In"), Static.Property(console, "Out"));
{
}
CodeGen action = scriptClass.Public.Void("Action");
{
rs.Action = action;
action.At(Span);
AstNode1.Evaluate(thread);
var cdl = AstNode2 as CharacterDeclarationListNode;
foreach (var ch in cdl.Characters)
{
ch.Evaluate(thread);
}
AstNode3.Evaluate(thread);
}
}
scriptClass.Complete();
TypeGen MyClass = ag.Public.Class("Program");
CodeGen Main = MyClass.Public.Static.Void("Main").Parameter <string[]>("args");
{
var script = Main.Local(Exp.New(scriptClass.GetCompletedType()));
Main.Invoke(script, "Action");
}
}
ag.Save();
return(ag.GetAssembly().GetName().Name);
}
protected override object DoEvaluate(Irony.Interpreter.ScriptThread thread)
{
thread.CurrentNode = this;
try
{
var myRes = new MtResult();
// Eval expression
var subthread = _expression.NewScriptThread(thread);
var res = _expression.Evaluate(subthread) as MtResult;
res.GetValue((resExpr) =>
{
AstNode toEval = null;
if (resExpr.Value == MtObject.False.Value)
{
// Evaluate false branch
toEval = _falseBranch;
}
else
{
// Evaluate true branch
toEval = _trueBranch;
}
// Evaluate!
var subsubthread = toEval.NewScriptThread(thread);
var resBranch = toEval.Evaluate(subsubthread) as MtResult;
resBranch.GetValue((_resBranch) =>
{
myRes.SetValue(_resBranch);
});
});
return(myRes);
}
catch (Exception e)
{
throw new Exception("Exception on If.DoEvaluate.", e);
}
finally
{
//thread.CurrentNode = Parent;
}
}
object ICallTarget.Call(Irony.Interpreter.ScriptThread thread, object[] parameters)
{
try
{
if (_thread != null)
{
thread = _thread;
}
var body_to_eval = _body.ConvertToTS(); // Cloners.Convert(_body);
// 2. Function object is responsable for:
// 2.1 Create a new context
var subthread = body_to_eval.NewScriptThread(thread);
// 2.2 For each parameter, bind its correspondent argument
// (ignore extra parameters, set missing to Empty)
for (var i = 0; i < _args.ArgList.Length; ++i)
{
var argDecl = _args.ArgList[i];
var accessor = subthread.Bind(argDecl.AsString, BindingRequestFlags.Write | BindingRequestFlags.ExistingOrNew);
accessor.SetValueRef(subthread, parameters[i]);
}
// Add var for recursive definitions
{
var accessor = subthread.Bind("$", BindingRequestFlags.Write | BindingRequestFlags.ExistingOrNew);
accessor.SetValueRef(subthread, this);
}
// 2.3 Call body in this new context
var res = body_to_eval.Evaluate(subthread) as MtResult;
if (res == null)
{
throw new Exception("Function can't evaluate to null!");
}
return(res);
}
catch (Exception e)
{
throw new Exception("Exception on Function Object call.", e);
}
}
protected override object DoEvaluate(Irony.Interpreter.ScriptThread thread)
{
thread.CurrentNode = this;
try
{
var ret = new MtResult();
ret.SetValue(new MtObject(new MtFunctionObject(_body, _arguments, thread)));
return(ret);
}
catch (Exception e)
{
throw new Exception("Error on MtFunctionLiteral.DoEvaluate", e);
}
finally
{
//thread.CurrentNode = Parent;
}
}
//Actual implementation
private object EvaluateParsedScript()
{
LastScript.Tag = DataMap;
var root = LastScript.Root.AstNode as AstNode;
root.DependentScopeInfo = MainScope.Info;
Status = AppStatus.Evaluating;
ScriptThread thread = null;
try {
thread = new ScriptThread(this);
var result = root.Evaluate(thread);
if (result != null)
{
thread.App.WriteLine(result.ToString());
}
Status = AppStatus.Ready;
return(result);
} catch (ScriptException se) {
Status = AppStatus.RuntimeError;
se.Location = thread.CurrentNode.Location;
se.ScriptStackTrace = thread.GetStackTrace();
LastException = se;
if (RethrowExceptions)
{
throw;
}
return(null);
} catch (Exception ex) {
Status = AppStatus.RuntimeError;
var se = new ScriptException(ex.Message, ex, thread.CurrentNode.Location, thread.GetStackTrace());
LastException = se;
if (RethrowExceptions)
{
throw se;
}
return(null);
}//catch
}
protected override object ReallyDoEvaluate(Irony.Interpreter.ScriptThread thread)
{
var sw = thread.tc().Writer;
sw.WriteLine("/********************************************************************");
sw.WriteLine(" * This C program was generated by spl2c, the Shakespeare to C *");
sw.WriteLine(" * converter by Jon Åslund and Karl Hasselström. *");
sw.WriteLine(" ********************************************************************/");
sw.WriteLine("");
sw.WriteLine("/* libspl definitions and function prototypes */");
sw.WriteLine("#include \"spl.h\"");
sw.WriteLine("");
sw.WriteLine("int main(void)");
sw.WriteLine("{");
AstNode1.Evaluate(thread); // Title
sw.WriteLine();
var cdl = AstNode2 as CharacterDeclarationListNode;
foreach (var ch in cdl.Characters)
{
sw.WriteLine(ch.Declaration);
}
sw.WriteLine("\tint comp1, comp2;");
sw.WriteLine("\tglobal_initialize();");
foreach (var ch in cdl.Characters)
{
sw.WriteLine(ch.Initialization);
}
sw.WriteLine();
sw.WriteLine();
AstNode3.Evaluate(thread);
sw.WriteLine("\treturn 0;");
sw.WriteLine("}");
sw.Flush();
sw.Close();
return(sw);
}
protected override object DoEvaluate(Irony.Interpreter.ScriptThread thread)
{
thread.CurrentNode = this;
try
{
// TODO Create a new context with $ as the current array? RECURSIVE ARRAYS? \ :D /
var ret = new MtResult();
var expressions = _expressionList.Evaluate(thread) as MtResult[];
ret.SetValue(new MtObject(expressions));
return(ret);
}
catch (Exception e)
{
throw new Exception("Exception on MtArray.DoEvaluate.", e);
}
finally
{
//thread.CurrentNode = Parent;
}
}
private void SetPropertyValue(ScriptThread thread, object value)
{
Property.SetValue(Instance, value, null);
}
private object GetPropertyValue(ScriptThread thread)
{
var result = Field.GetValue(Instance);
return(result);
}
protected virtual object ReallyDoEvaluate(Irony.Interpreter.ScriptThread thread)
{
return(null);
}
object ICallTarget.Call(Irony.Interpreter.ScriptThread thread, object[] parameters)
{
throw new NotImplementedException("Any child of MtFunctionObjectBase should implement Call().");
}
public object Call(ScriptThread thread, object[] parameters)
{
return(Method(thread, parameters));
}
private void SetParentScopeParameter(ScriptThread thread, object value)
{
var targetScope = GetTargetScope(thread);
targetScope.SetParameter(SlotIndex, value);
}
private object GetParentScopeParameter(ScriptThread thread)
{
var targetScope = GetTargetScope(thread);
return(targetScope.GetParameter(SlotIndex));
}
private void SetImmediateParentScopeParameter(ScriptThread thread, object value)
{
thread.CurrentScope.Parent.SetParameter(SlotIndex, value);
}
private void SetStatic(ScriptThread thread, object value)
{
thread.App.StaticScopes[StaticScopeIndex].SetValue(SlotIndex, value);
}
private void SetCurrentScopeValue(ScriptThread thread, object value)
{
thread.CurrentScope.SetValue(SlotIndex, value);
}
private void SetPropertyValue(ScriptThread thread, object value)
{
Field.SetValue(Instance, value);
}
private object GetStaticValue(ScriptThread thread)
{
try {
return(thread.App.StaticScopes[StaticScopeIndex].GetValue(SlotIndex));
} catch { thread.CurrentNode = FromNode; throw; }
}
private object GetPropertyValue(ScriptThread thread)
{
var result = Property.GetValue(Instance, null);
return(result);
}
private object GetCurrentScopeParameter(ScriptThread thread)
{
try {
return(thread.CurrentScope.GetParameter(SlotIndex));
} catch { thread.CurrentNode = FromNode; throw; }
}
public object GetValue(ScriptThread thread)
{
return(Target);
}