public void True_False_Literals()
{
var target = new Interpreter();
Assert.IsTrue((bool)target.Eval("true"));
Assert.IsFalse((bool)target.Eval("false"));
}
public override double Evaluate(Parser parser, Interpreter ii)
{
var name = _left as NameExpression;
if (name == null)
{
throw new ProcessusException(parser.Source, _token, "Left side of increment/decrement postfix was not a variable.");
}
switch (_token.Identifier)
{
case MathTokenType.Increment:
{
double d = name.Evaluate(parser, ii);
ii.Engine.Variables.SetVar(name.Name, d + 1);
return d;
}
case MathTokenType.Decrement:
{
double d = name.Evaluate(parser, ii);
ii.Engine.Variables.SetVar(name.Name, d - 1);
return d;
}
default:
throw new ProcessusException(parser.Source, _token, "Invalid postfix operator '" + _token.Value + "'.");
}
}
internal void LoadFunctions(Interpreter interpreter)
{
foreach (var func in _functions)
{
interpreter.SetFunction(func.Name, func.GetDelegate());
}
}
public override void EvaluateNode(Interpreter.EvaluationContext context, AstMode mode, DateTime time)
{
foreach (var rule in TradingRules)
{
rule.EvaluateNode(context, AstMode.None, time);
}
}
public void Can_use_overloaded_operators_on_class()
{
var target = new Interpreter();
var x = new ClassWithOverloadedBinaryOperators(3);
target.SetVariable("x", x);
string y = "5";
Assert.IsFalse(x == y);
Assert.IsFalse(target.Eval<bool>("x == y", new Parameter("y", y)));
y = "3";
Assert.IsTrue(x == y);
Assert.IsTrue(target.Eval<bool>("x == y", new Parameter("y", y)));
Assert.IsFalse(target.Eval<bool>("x == \"4\""));
Assert.IsTrue(target.Eval<bool>("x == \"3\""));
Assert.IsTrue(!x == "-3");
Assert.IsTrue(target.Eval<bool>("!x == \"-3\""));
var z = new ClassWithOverloadedBinaryOperators(10);
Assert.IsTrue((x + z) == "13");
Assert.IsTrue(target.Eval<bool>("(x + z) == \"13\"", new Parameter("z", z)));
}
public void New_And_Member_Access()
{
var target = new Interpreter();
Assert.AreEqual(new DateTime(2015, 1, 24).Month, target.Eval("new DateTime(2015, 1, 24).Month"));
Assert.AreEqual(new DateTime(2015, 1, 24).Month + 34, target.Eval("new DateTime( 2015, 1, 24).Month + 34"));
}
public void New_Of_Base_Type()
{
var target = new Interpreter();
Assert.AreEqual(new DateTime(2015, 1, 24), target.Eval("new DateTime(2015, 1, 24)"));
Assert.AreEqual(new string('a', 10), target.Eval("new string('a', 10)"));
}
public void Static_Methods_of_Base_Types()
{
var target = new Interpreter();
Assert.AreEqual(TimeSpan.FromMilliseconds(2000.49), target.Eval("TimeSpan.FromMilliseconds(2000.49)"));
Assert.AreEqual(DateTime.DaysInMonth(2094, 11), target.Eval("DateTime.DaysInMonth(2094, 11)"));
}
/// <summary>
/// Perform additional checks based on the parameter types
/// </summary>
/// <param name="root">The element on which the errors should be reported</param>
/// <param name="context">The evaluation context</param>
/// <param name="actualParameters">The parameters applied to this function call</param>
public override void additionalChecks(ModelElement root, Interpreter.InterpretationContext context, Dictionary<string, Interpreter.Expression> actualParameters)
{
CheckFunctionalParameter(root, context, actualParameters[First.Name], 1);
CheckFunctionalParameter(root, context, actualParameters[Second.Name], 1);
Function function1 = actualParameters[First.Name].GetExpressionType() as Function;
Function function2 = actualParameters[Second.Name].GetExpressionType() as Function;
if (function1 != null && function2 != null)
{
if (function1.FormalParameters.Count == 1 && function2.FormalParameters.Count == 1)
{
Parameter p1 = (Parameter)function1.FormalParameters[0];
Parameter p2 = (Parameter)function2.FormalParameters[0];
if (p1.Type != p2.Type && p1.Type != EFSSystem.DoubleType && p2.Type != EFSSystem.DoubleType)
{
root.AddError("The formal parameters for the functions provided as parameter are not the same");
}
}
if (function1.ReturnType != function2.ReturnType && function1.ReturnType != EFSSystem.DoubleType && function2.ReturnType != EFSSystem.DoubleType)
{
root.AddError("The return values for the functions provided as parameter are not the same");
}
}
}
public void Convert_Class()
{
var target = new Interpreter();
Assert.AreEqual(Convert.ToString(3), target.Eval("Convert.ToString(3)"));
Assert.AreEqual(Convert.ToInt16("23"), target.Eval("Convert.ToInt16(\"23\")"));
}
public void Math_Class()
{
var target = new Interpreter();
Assert.AreEqual(Math.Pow(3, 4), target.Eval("Math.Pow(3, 4)"));
Assert.AreEqual(Math.Sin(30.234), target.Eval("Math.Sin(30.234)"));
}
public static void DoTable(Tree<Cell> table, Interpreter activeFixture, bool inFlow)
{
var activeFlowFixture = activeFixture as FlowInterpreter;
if (activeFlowFixture != null) activeFlowFixture.DoSetUp(table);
activeFixture.Interpret(table);
if (activeFlowFixture != null && !inFlow) activeFlowFixture.DoTearDown(table);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="rule"></param>
/// <param name="preCondition">The precondition which setup the initial state</param>
/// <param name="initialState">The initial stae of this transition</param>
/// <param name="update">The statement which set up the target state</param>
/// <param name="targetState">The target state of this transition</param>
public Transition(PreCondition preCondition, State initialState, Interpreter.Statement.VariableUpdateStatement update, State targetState)
{
PreCondition = preCondition;
InitialState = initialState;
Update = update;
TargetState = targetState;
}
public static void Instantiate(Assembly a, Interpreter interp)
{
Hashtable table = interp.VarTable;
try {
CodeChunk chunk = (CodeChunk)a.CreateInstance("CsiChunk");
chunk.Go(table);
// vs 0.8 we display the type and value of expressions. The variable $_ is
// always set, which is useful if you want to save the result of the last
// calculation.
if (interp.returnsValue && DumpingValue) {
object val = table["_"];
Type type = val.GetType();
string stype = type.ToString();
if (stype.StartsWith("System.")) // to simplify things a little bit...
stype = stype.Substring(7);
stype = "("+stype+")";
if (val is string) {
Print(stype,"'"+val+"'");
} else
if (val is IEnumerable) {
Print(stype);
Dumpl((IEnumerable)val);
} else
Print(stype,val);
}
} catch(Exception ex) {
Print(ex.GetType() + " was thrown: " + ex.Message);
}
}
public override ReturnCode Execute(
Interpreter interpreter,
IClientData clientData,
ArgumentList arguments,
ref Result result
)
{
if ((arguments == null) || (arguments.Count < 2))
{
result = Utility.WrongNumberOfArguments(
this, 1, arguments, "command");
return ReturnCode.Error;
}
try
{
var processor = new CommandLineProcessor();
var o = processor.Pharse(arguments.Select(argument => (string) argument).Skip(1).ToArray());
if (!(o is string) && o is IEnumerable)
result = new StringList(o);
else
{
result = o == null ? "" : new Variant(o).ToString();
}
}
catch (Exception exception)
{
Log.Error("Script error ", exception);
result = "Error on command execution " + exception.Message;
}
return ReturnCode.Ok;
}
public virtual object GetProperty(Interpreter interpreter, TemplateFrame frame, object o, object property, string propertyName)
{
object value;
IDictionary map = (IDictionary)o;
if (property == null)
value = map[TemplateGroup.DefaultKey];
else if (property.Equals("Keys"))
value = map.Keys;
else if (property.Equals("Values"))
value = map.Values;
else if (map.Contains(property))
value = map[property];
else if (map.Contains(propertyName))
value = map[propertyName]; // if can't find the key, try ToString version
else
value = map[TemplateGroup.DefaultKey]; // not found, use default
if (object.ReferenceEquals(value, TemplateGroup.DictionaryKey))
{
value = property;
}
return value;
}
public override object Execute(Interpreter interpreter)
{
Console.WriteLine ("Mono Debugger (C) 2003-2007 Novell, Inc.\n" +
"Written by Martin Baulig ([email protected])\n" +
" and Chris Toshok ([email protected])\n");
return null;
}
public override double Evaluate(Parser parser, Interpreter ii)
{
var name = _right as NameExpression;
switch (_token.Identifier)
{
case MathTokenType.Minus:
return -_right.Evaluate(parser, ii);
case MathTokenType.Increment:
{
if (name == null)
{
throw new ManhoodException(parser.Source, _token, "Increment prefix could not find a variable.");
}
double d = name.Evaluate(parser, ii) + 1;
ii.Engine.Variables.SetVar(name.Name, d);
return d;
}
case MathTokenType.Decrement:
{
if (name == null)
{
throw new ManhoodException(parser.Source, _token, "Decrement prefix could not find a variable.");
}
double d = name.Evaluate(parser, ii) - 1;
ii.Engine.Variables.SetVar(name.Name, d);
return d;
}
default:
throw new ManhoodException(parser.Source, _token, "Invalid prefix operator '" + _token + "'.");
}
}
public TagBlueprint(Interpreter interpreter, Source source, Stringe name, IEnumerable<Token<TokenType>>[] args = null)
: base(interpreter)
{
Source = source;
Name = name;
if (!Interpreter.TagFuncs.TryGetValue(Name.Value.ToLower().Trim(), out _tagDef))
{
throw new ManhoodException(Source, Name, "The tag '" + Name.Value + "' does not exist.");
}
_tagDef.ValidateArgCount(source, name, args != null ? args.Length : 0);
if (args == null)
{
_args = Enumerable.Empty<TagArg>().ToArray();
}
else
{
// Insert token arguments into the array, set string args to null.
_args = args.Select((a, i) => _tagDef.ArgTypes[i] == TagArgType.Tokens ? TagArg.FromTokens(a) : null).ToArray();
// Queue string arguments on the stack.
for (int i = 0; i < _tagDef.ArgTypes.Length; i++)
{
if (_tagDef.ArgTypes[i] == TagArgType.Result)
{
interpreter.PushState(Interpreter.State.CreateDerivedDistinct(source, args[i], interpreter));
}
}
}
}
/// <summary>
/// Ensures that the parameter provided corresponds to a function double->double
/// </summary>
/// <param name="root">Element on which the errors shall be attached</param>
/// <param name="context">The context used to evaluate the expression</param>
/// <param name="expression">The expression which references the function</param>
/// <param name="count">the expected number of parameters</param>
protected virtual void CheckFunctionalParameter(ModelElement root, Interpreter.InterpretationContext context, Interpreter.Expression expression, int count)
{
Types.Type type = expression.GetExpressionType();
Function function = type as Function;
if (function != null)
{
if (function.FormalParameters.Count == count)
{
foreach (Parameter parameter in function.FormalParameters)
{
if (!parameter.Type.IsDouble())
{
root.AddError(expression.ToString() + " does not takes a double for parameter " + parameter.Name);
}
}
}
else
{
root.AddError(expression.ToString() + " does not take " + count + "parameter(s) as input");
}
if (!function.ReturnType.IsDouble())
{
root.AddError(expression.ToString() + " does not return a double");
}
}
else
{
if (!type.IsDouble())
{
root.AddError(expression.ToString() + " type is not double");
}
}
}
public void If_Operators()
{
var target = new Interpreter();
Assert.AreEqual(10 > 3 ? "yes" : "no", target.Eval("10 > 3 ? \"yes\" : \"no\""));
Assert.AreEqual(10 < 3 ? "yes" : "no", target.Eval("10 < 3 ? \"yes\" : \"no\""));
}
public void CanInterpretTwoSentences()
{
Interpreter interpreter = new Interpreter();
var commands = interpreter.Parse("PRESS A,\"B\",C\r\nPRESS A,B").ToList();
Assert.AreEqual(2, commands.Count);
Assert.AreEqual(2, commands[1].Parameters.Count);
}
public void Alphabetic_Literals()
{
var target = new Interpreter();
Assert.AreEqual("ciao", target.Eval("\"ciao\""));
Assert.AreEqual('c', target.Eval("'c'"));
}
private static bool CapsInfer(Interpreter interpreter, Source source, Stringe tagname, TagArg[] args)
{
// TODO: Make capsinfer properly infer "first" capitalization given multiple sentences. Currently, it mistakes it for "word" mode.
var words = Regex.Matches(args[0].GetString(), @"\w+").OfType<Match>().Select(m => m.Value).ToArray();
int wCount = words.Length;
int uCount = 0;
int fwCount = 0;
bool firstCharIsUpper = false;
for (int i = 0; i < wCount; i++)
{
if (words[i].All(Char.IsUpper))
{
uCount++;
}
if (Char.IsUpper(words[i][0]))
{
fwCount++;
if (i == 0) firstCharIsUpper = true;
}
}
if (uCount == wCount)
{
interpreter.CurrentState.Output.SetCaps(Capitalization.Upper);
}
else if (wCount > 1 && fwCount == wCount)
{
interpreter.CurrentState.Output.SetCaps(Capitalization.Word);
}
else if (firstCharIsUpper)
{
interpreter.CurrentState.Output.SetCaps(Capitalization.First);
}
return false;
}
public SpiderView(SpiderHost host)
{
this.Host = host;
this.Scripting = new Scripting.LuaInterpreter(this);
this.Preprocessor = new Preprocessor.LuaMako(this);
this.Scripting.RegisterFunction("refresh", GetType().GetMethod("refresh"), this);
this.timer = new Timer();
InitializeComponent();
this.tabBar = new TabBar(this);
this.deck = new Panel();
tabBar.Dock = DockStyle.Top;
tabBar.Height = 23;
this.Controls.Add(deck);
this.Controls.Add(tabBar);
deck.Dock = DockStyle.Fill;
this.tabBar.Dock = DockStyle.Top;
Block = Stylesheet.Blocks["Body"];
this.BackColor = Block.BackColor;
this.ForeColor = Block.ForeColor;
this.tabBar.TabChange += tabBar_TabChange;
this.timer.Tick += timer_Tick;
this.timer.Interval = 1000;
this.Click += SpiderView_Click;
}
public override double Evaluate(Parser parser, Interpreter ii)
{
if (_token.Identifier == MathTokenType.Swap)
{
var left = _left as NameExpression;
var right = _right as NameExpression;
if (left == null) throw new ManhoodException(parser.Source, _token, "Left side of swap operation was not a variable.");
if (right == null) throw new ManhoodException(parser.Source, _token, "Right side of swap operation was not a variable.");
double temp = left.Evaluate(parser, ii);
double b = right.Evaluate(parser, ii);
ii.Engine.Variables.SetVar(left.Name, b);
ii.Engine.Variables.SetVar(right.Name, temp);
return b;
}
Func<Parser, Interpreter, NameExpression, Expression, double> assignFunc;
if (AssignOperations.TryGetValue(_token.Identifier, out assignFunc))
{
var left = _left as NameExpression;
if (left == null) throw new ManhoodException(parser.Source, _token, "Left side of assignment was not a variable.");
return assignFunc(parser, ii, left, _right);
}
Func<double, double, double> func;
if (!Operations.TryGetValue(_token.Identifier, out func))
{
throw new ManhoodException(parser.Source, _token, "Invalid binary operation '" + _token + "'.");
}
return func(_left.Evaluate(parser, ii), _right.Evaluate(parser, ii));
}
private void calculateButton_Click(object sender, RoutedEventArgs e)
{
try
{
ClearScreen();
string formula = formulaTextBox.Text;
TokenReader reader = new TokenReader(CultureInfo.InvariantCulture);
List<Token> tokens = reader.Read(formula);
ShowTokens(tokens);
AstBuilder astBuilder = new AstBuilder();
Operation operation = astBuilder.Build(tokens);
ShowAbstractSyntaxTree(operation);
Dictionary<string, double> variables = new Dictionary<string, double>();
foreach (Variable variable in GetVariables(operation))
{
double value = AskValueOfVariable(variable);
variables.Add(variable.Name, value);
}
IExecutor executor = new Interpreter();
double result = executor.Execute(operation, variables);
resultTextBox.Text = "" + result;
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Error", MessageBoxButton.OK, MessageBoxImage.Error);
}
}
public void SystemExceptions_are_preserved_using_method_invocation()
{
var target = new Interpreter();
target.SetVariable("a", new MyTestService());
target.Eval("a.ThrowException()");
}
public override void EvaluateNode(Interpreter.EvaluationContext context, AstMode mode, DateTime time)
{
if (ExecuteFrequency.CanExecute(context.StartDate, time))
{
Statements.EvaluateNode(context, AstMode.None, time);
}
}
public void Numeric_Operators_Priority()
{
var target = new Interpreter();
Assert.AreEqual(8 / 2 + 2, target.Eval("8 / 2 + 2"));
Assert.AreEqual(8 + 2 / 2, target.Eval("8 + 2 / 2"));
}
/// <summary>
///
/// </summary>
/// <param name="dsObject"></param>
/// <param name="context"></param>
/// <param name="dsi"></param>
public override void OnDispose(StackValue dsObject, ProtoCore.Runtime.Context context, Interpreter dsi)
{
lock (DSObjectMap)
{
Object clrobject;
if (DSObjectMap.TryGetValue(dsObject, out clrobject))
{
DSObjectMap.Remove(dsObject);
CLRObjectMap.Remove(clrobject);
dsi.runtime.Core.FFIPropertyChangedMonitor.RemoveFFIObject(clrobject);
}
}
}
private void OnLoadFiles(string[] paths)
{
if (paths == null || paths.Length == 0 || string.IsNullOrWhiteSpace(paths[0]))
{
if (FullFilename == null)
{
wizardDlg.CloseDialog(DialogAction.Cancel);
}
return;
}
FullFilename = paths[0];
var filename = Path.GetFileName(FullFilename);
fileLabel.text = filename;
interpreter = Interpreter.Get(FullFilename);
fileInfo = interpreter.GetBasicInfo(FullFilename);
if (fileInfo == null)
{
ShowWarningMessage(translator.Get("Invalid file"), openFile, true);
return;
}
// Update field dropdown if file is vector data
bool isVectorData = interpreter is ShapefileInterpreter;
if (isVectorData)
{
UpdateFieldDropdown(FullFilename);
}
// Show/hide field label and dropdown depending on vector or raster data
fieldLabel.gameObject.SetActive(isVectorData);
fieldDropdown.gameObject.SetActive(isVectorData);
var filename_lc = filename.ToLower();
// Try to guess the site
if (string.IsNullOrWhiteSpace(siteDropdown.input.text))
{
var sites = dataManager.sites;
for (int i = 0; i < sites.Count; i++)
{
if (filename_lc.Contains(sites[i].Name.ToLower()))
{
siteDropdown.value = i;
break;
}
}
}
// Try to guess the layer (and group)
if (!layerDropdown.HasSelected)
{
var layer = GetLayer(filename_lc);
if (layer == null && !string.IsNullOrWhiteSpace(fileInfo.suggestedLayerName))
{
layer = GetLayer(fileInfo.suggestedLayerName.ToLower());
}
if (layer != null)
{
groupDropdown.value = dataManager.groups.IndexOf(layer.Group);
layerDropdown.value = layer.Group.layers.IndexOf(layer);
}
}
// Suggest the resolution
if (!resolutionDropdown.HasSelected && fileInfo.degreesPerPixel != 0)
{
for (int i = 0; i < resolutions.Length; i++)
{
if (fileInfo.degreesPerPixel.Similar(resolutions[i].ToDegrees()))
{
resolutionDropdown.value = i;
break;
}
}
}
// Suggest the units
if (string.IsNullOrWhiteSpace(unitsInput.text) && !string.IsNullOrWhiteSpace(fileInfo.suggestedUnits))
{
unitsInput.text = translator.Get(fileInfo.suggestedUnits);
}
if (fileInfo != null)
{
CheckBounds();
CheckRasterSize();
CheckResolution();
}
ValidateResolutionDrowndown();
UpdateProgress();
}
///////////////////////////////////////////////////////////////////////
#region Debugger Breakpoint Support Methods
#if DEBUGGER
public static ReturnCode Breakpoint(
IDebugger debugger,
Interpreter interpreter,
InteractiveLoopData loopData,
ref Result result
)
{
if (interpreter == null)
{
result = "invalid interpreter";
return(ReturnCode.Error);
}
if (!interpreter.Interactive)
{
result = "cannot break into interactive loop";
return(ReturnCode.Error);
}
if (debugger != null)
{
/* IGNORED */
debugger.EnterLoop();
}
try
{
ReturnCode code;
InteractiveLoopCallback interactiveLoopCallback =
interpreter.InteractiveLoopCallback;
if (interactiveLoopCallback != null)
{
code = interactiveLoopCallback(
interpreter, new InteractiveLoopData(loopData, true),
ref result);
}
else
{
#if SHELL
//
// NOTE: This is the only place in the debugger subsystem
// where the InteractiveLoop method may be called.
// All other methods in the Debugger class and/or
// any external classes that desire the interactive
// debugging functionality should call this method.
//
code = Interpreter.InteractiveLoop(
interpreter, new InteractiveLoopData(loopData, true),
ref result);
#else
result = "not implemented";
code = ReturnCode.Error;
#endif
}
//
// NOTE: Only check (or update) the interpreter state at this
// point if the interpreter is still usable (i.e. it is
// not disposed) -AND- the interactive loop returned a
// successful result.
//
if ((code == ReturnCode.Ok) && Engine.IsUsable(interpreter))
{
//
// NOTE: Upon exiting the interactive loop, temporarily
// prevent the engine from checking interpreter
// readiness. This is used to avoid potentially
// breaking back into the interactive loop due to
// breakpoints caused by script cancellation, etc.
//
interpreter.IsDebuggerExiting = true;
}
return(code);
}
finally
{
if (debugger != null)
{
/* IGNORED */
debugger.ExitLoop();
}
}
}
void TestIt(string input, decimal value)
{
Interpreter I = new Interpreter();
Assert.AreEqual(value, I.Calculate(input));
}
public override ReturnCode Execute(
Interpreter interpreter,
IClientData clientData,
ArgumentList arguments,
ref Result result
)
{
ReturnCode code = ReturnCode.Ok;
if (interpreter != null)
{
if (arguments != null)
{
if ((arguments.Count == 5) || (arguments.Count == 6))
{
///////////////////////////////////////////////////////////////////////////////////////////////
//
// test name description ?constraints? body result
//
///////////////////////////////////////////////////////////////////////////////////////////////
string name = arguments[1];
#if DEBUGGER
if (DebuggerOps.CanHitBreakpoints(interpreter,
EngineFlags.None, BreakpointType.Test))
{
code = interpreter.CheckBreakpoints(
code, BreakpointType.Test, name,
null, null, this, null, clientData,
arguments, ref result);
}
if (code == ReturnCode.Ok)
#endif
{
string description = arguments[2];
string constraints;
string body;
IScriptLocation bodyLocation;
string expectedResult;
if (arguments.Count == 6)
{
constraints = arguments[3];
body = arguments[4];
bodyLocation = arguments[4];
expectedResult = arguments[5];
}
else
{
constraints = null;
body = arguments[3];
bodyLocation = arguments[3];
expectedResult = arguments[4];
}
ReturnCodeList returnCodes = new ReturnCodeList(new ReturnCode[] {
ReturnCode.Ok, ReturnCode.Return
});
MatchMode mode = StringOps.DefaultResultMatchMode;
bool noCase = false;
///////////////////////////////////////////////////////////////////////////////////////////////
int testLevels = interpreter.EnterTestLevel();
try
{
//
// NOTE: Create a place to put all the output of the this command.
//
StringBuilder testData = StringOps.NewStringBuilder();
//
// NOTE: Are we going to skip this test?
//
bool skip = false;
bool fail = true;
code = TestOps.CheckConstraints(
interpreter, testLevels, name, constraints,
false, false, testData, ref skip, ref fail,
ref result);
//
// NOTE: Track the fact that we handled this test.
//
int[] testStatistics = null;
if (code == ReturnCode.Ok)
{
testStatistics = interpreter.TestStatistics;
if ((testStatistics != null) && (testLevels == 1) && skip)
{
Interlocked.Increment(ref testStatistics[
(int)TestInformationType.Total]);
}
}
if ((code == ReturnCode.Ok) && !skip)
{
code = TestOps.RecordInformation(
interpreter, TestInformationType.Counts, name,
null, true, ref result);
}
//
// NOTE: Check test constraints to see if we should run the test.
//
if ((code == ReturnCode.Ok) && !skip)
{
ReturnCode bodyCode = ReturnCode.Ok;
Result bodyResult = null;
//
// NOTE: Only run the test body if the setup is successful.
//
if (body != null)
{
TestOps.AppendFormat(
interpreter, testData, TestOutputType.Start,
"---- {0} start", name);
TestOps.AppendLine(
interpreter, testData, TestOutputType.Start);
int savedPreviousLevels = interpreter.BeginNestedExecution();
try
{
ICallFrame frame = interpreter.NewTrackingCallFrame(
StringList.MakeList(this.Name, "body", name),
CallFrameFlags.Test);
interpreter.PushAutomaticCallFrame(frame);
try
{
bodyCode = interpreter.EvaluateScript(
body, bodyLocation, ref bodyResult);
if ((bodyResult == null) && ScriptOps.HasFlags(
interpreter, InterpreterFlags.TestNullIsEmpty,
true))
{
bodyResult = String.Empty;
}
if (bodyCode == ReturnCode.Error)
{
/* IGNORED */
interpreter.CopyErrorInformation(
VariableFlags.None, ref bodyResult);
}
}
finally
{
//
// NOTE: Pop the original call frame that we pushed above
// and any intervening scope call frames that may be
// leftover (i.e. they were not explicitly closed).
//
/* IGNORED */
interpreter.PopScopeCallFramesAndOneMore();
}
}
catch (Exception e)
{
bodyResult = e;
bodyCode = ReturnCode.Error;
}
finally
{
interpreter.EndNestedExecution(savedPreviousLevels);
}
}
//
// NOTE: Did we fail to match the return code?
//
bool codeFailure = !returnCodes.Contains(bodyCode);
//
// NOTE: Does the actual result match the expected result?
//
bool scriptFailure = false;
ReturnCode scriptCode = ReturnCode.Ok;
Result scriptResult = null;
if (!codeFailure)
{
if (expectedResult != null)
{
scriptCode = TestOps.Match(
interpreter, mode, bodyResult,
expectedResult, noCase, null,
TestOps.RegExOptions, false,
ref scriptFailure, ref scriptResult);
if (scriptCode == ReturnCode.Ok)
{
scriptFailure = !scriptFailure;
}
else
{
scriptFailure = true;
}
}
}
//
// NOTE: If any of the important things failed, the test fails.
//
if (!(codeFailure || scriptFailure))
{
//
// PASS: Test ran with no errors and the results match
// what we expected.
//
if ((testStatistics != null) && (testLevels == 1))
{
Interlocked.Increment(ref testStatistics[
(int)TestInformationType.Passed]);
Interlocked.Increment(ref testStatistics[
(int)TestInformationType.Total]);
}
TestOps.AppendFormat(
interpreter, testData, TestOutputType.Pass,
"++++ {0} PASSED", name);
TestOps.AppendLine(
interpreter, testData, TestOutputType.Pass);
}
else
{
//
// FAIL: Test ran with errors or the result does not match
// what we expected.
//
if ((testStatistics != null) && (testLevels == 1))
{
if (fail)
{
Interlocked.Increment(ref testStatistics[
(int)TestInformationType.Failed]);
Interlocked.Increment(ref testStatistics[
(int)TestInformationType.Total]);
}
}
//
// NOTE: Keep track of each test that fails.
//
if (testLevels == 1)
{
TestOps.RecordInformation(
interpreter, TestInformationType.FailedNames,
name, null, true);
}
TestOps.AppendLine(
interpreter, testData, TestOutputType.Fail);
TestOps.AppendFormat(
interpreter, testData, TestOutputType.Fail,
"==== {0} {1} {2}", name, description.Trim(),
fail ? "FAILED" : "IGNORED");
TestOps.AppendLine(
interpreter, testData, TestOutputType.Fail);
if (body != null)
{
TestOps.AppendLine(
interpreter, testData, TestOutputType.Body,
"==== Contents of test case:");
TestOps.AppendLine(
interpreter, testData, TestOutputType.Body,
body);
}
if (scriptFailure)
{
if (scriptCode == ReturnCode.Ok)
{
TestOps.AppendLine(
interpreter, testData, TestOutputType.Reason,
"---- Result was:");
TestOps.AppendLine(
interpreter, testData, TestOutputType.Reason,
bodyResult);
TestOps.AppendFormat(
interpreter, testData, TestOutputType.Reason,
"---- Result should have been ({0} matching):",
mode);
TestOps.AppendLine(
interpreter, testData, TestOutputType.Reason);
TestOps.AppendLine(
interpreter, testData, TestOutputType.Reason,
expectedResult);
}
else
{
TestOps.Append(
interpreter, testData, TestOutputType.Reason,
"---- Error testing result: ");
TestOps.AppendLine(
interpreter, testData, TestOutputType.Reason,
scriptResult);
if ((scriptResult != null) &&
(scriptResult.ErrorInfo != null))
{
TestOps.Append(
interpreter, testData, TestOutputType.Error,
"---- errorInfo(matchResult): ");
TestOps.AppendLine(
interpreter, testData, TestOutputType.Error,
scriptResult.ErrorInfo);
TestOps.Append(
interpreter, testData, TestOutputType.Error,
"---- errorCode(matchResult): ");
TestOps.AppendLine(
interpreter, testData, TestOutputType.Error,
scriptResult.ErrorCode);
}
}
}
if (codeFailure)
{
ReturnCodeDictionary returnCodeMessages =
interpreter.TestReturnCodeMessages;
string codeMessage;
if ((returnCodeMessages == null) ||
(!returnCodeMessages.TryGetValue(
bodyCode, out codeMessage) &&
!returnCodeMessages.TryGetValue(
ReturnCode.Invalid, out codeMessage)))
{
codeMessage = "Unknown";
}
TestOps.AppendFormat(
interpreter, testData, TestOutputType.Reason,
"---- {0}; Return code was: {1}",
codeMessage, bodyCode);
TestOps.AppendLine(
interpreter, testData, TestOutputType.Reason);
TestOps.Append(
interpreter, testData, TestOutputType.Reason,
"---- Return code should have been one of: ");
TestOps.AppendLine(
interpreter, testData, TestOutputType.Reason,
returnCodes.ToString());
if ((bodyResult != null) &&
(bodyResult.ErrorInfo != null) &&
!returnCodes.Contains(ReturnCode.Error))
{
TestOps.Append(
interpreter, testData, TestOutputType.Error,
"---- errorInfo(body): ");
TestOps.AppendLine(
interpreter, testData, TestOutputType.Error,
bodyResult.ErrorInfo);
TestOps.Append(
interpreter, testData, TestOutputType.Error,
"---- errorCode(body): ");
TestOps.AppendLine(
interpreter, testData, TestOutputType.Error,
bodyResult.ErrorCode);
}
}
TestOps.AppendFormat(
interpreter, testData, TestOutputType.Fail,
"==== {0} {1}", name, fail ? "FAILED" : "IGNORED");
TestOps.AppendLine(
interpreter, testData, TestOutputType.Fail);
}
}
//
// NOTE: Did the above code succeed?
//
if (code == ReturnCode.Ok)
{
//
// NOTE: The result is the complete output produced by the
// entire test.
//
if (testData != null)
{
result = testData;
}
else
{
result = String.Empty;
}
}
}
catch (Exception e)
{
Engine.SetExceptionErrorCode(interpreter, e);
result = e;
code = ReturnCode.Error;
}
finally
{
interpreter.ExitTestLevel();
}
}
}
else
{
result = String.Format(
"wrong # args: should be \"{0} name description constraints body result\"",
this.Name);
code = ReturnCode.Error;
}
}
else
{
result = "invalid argument list";
code = ReturnCode.Error;
}
}
else
{
result = "invalid interpreter";
code = ReturnCode.Error;
}
return(code);
}
/// <summary>
/// Initializes primary properties on the DS object for given FFI
/// object.
/// </summary>
/// <param name="ffiObject">FFI object in context</param>
/// <param name="dsObject">Design script object</param>
/// <param name="context">Execution context</param>
/// <param name="dsi">Interpreter</param>
/// <param name="classIndex">Class index of design script data type</param>
private void PopulatePrimaryProperties(object ffiObject, StackValue dsObject, ProtoCore.Runtime.Context context, Interpreter dsi, int classIndex)
{
Dictionary <string, object> properties = GetPrimaryProperties(ffiObject);
if (null == properties || properties.Count == 0)
{
return;
}
var core = dsi.runtime.Core;
StackValue[] svs = core.Heap.Heaplist[(int)dsObject.opdata].Stack;
for (int ix = 0; ix < svs.Length; ++ix)
{
SymbolNode symbol = core.DSExecutable.classTable.ClassNodes[classIndex].symbols.symbolList[ix];
object prop = null;
if (properties.TryGetValue(symbol.name, out prop) && null != prop)
{
svs[ix] = Marshal(prop, context, dsi, GetMarshaledType(prop.GetType()));
}
}
}
/// <summary>
///
/// </summary>
/// <param name="obj"></param>
/// <param name="context"></param>
/// <param name="dsi"></param>
/// <returns></returns>
private StackValue CreateDSObject(object obj, ProtoCore.Runtime.Context context, Interpreter dsi)
{
//We are here, because we want to create DS object of user defined type.
var core = dsi.runtime.Core;
var classTable = core.DSExecutable.classTable;
Type objType = GetPublicType(obj.GetType());
int type = classTable.IndexOf(GetTypeName(objType));
//Recursively get the base class type if available.
while (type == -1 && objType != null)
{
objType = objType.BaseType;
if (null != objType)
{
type = classTable.IndexOf(GetTypeName(objType));
}
}
int ptr = ProtoCore.DSASM.Constants.kInvalidPointer;
lock (core.Heap.cslock)
{
ptr = core.Heap.Allocate(classTable.ClassNodes[type].size);
}
MetaData metadata;
metadata.type = type;
StackValue retval = StackUtils.BuildPointer(ptr, metadata);
BindObjects(obj, retval);
dsi.runtime.Core.FFIPropertyChangedMonitor.AddFFIObject(obj);
//If we are in debug mode, populate primary properties if there is any.
//if (core.Options.IDEDebugMode)
// PopulatePrimaryProperties(obj, retval, context, dsi, type);
return(retval);
}
/// <summary>
///
/// </summary>
/// <param name="dsObject"></param>
/// <param name="context"></param>
/// <param name="dsi"></param>
/// <param name="type"></param>
/// <returns></returns>
public override object UnMarshal(StackValue dsObject, ProtoCore.Runtime.Context context, Interpreter dsi, System.Type type)
{
object clrObject = null;
switch (dsObject.optype)
{
case AddressType.ArrayPointer:
{
if (type.IsArray || type == typeof(object))
{
return(ConvertDSArrayToCSArray(dsObject, context, dsi, type));
}
if (typeof(System.Collections.ICollection).IsAssignableFrom(type))
{
Type arrayType = type.GetGenericArguments()[0].MakeArrayType();
object arr = ConvertDSArrayToCSArray(dsObject, context, dsi, arrayType);
return(Activator.CreateInstance(type, new[] { arr })); //Create the collection using
}
else if (typeof(System.Collections.IEnumerable).IsAssignableFrom(type))
{
Type arrayType = type.GetGenericArguments()[0].MakeArrayType();
object arr = ConvertDSArrayToCSArray(dsObject, context, dsi, arrayType);
return(arr);
/*
* Type genericType = type.GetGenericArguments()[0];
* return ConvertDSArrayToCSList(dsObject, context, dsi, genericType);
*
* Type listType = typeof(List<>).MakeGenericType(genericType);
* var list = Activator.CreateInstance(listType);
* listType.GetMethod("AddRange").Invoke(list, new object[]{arr});
* return list;
*/
}
break;
}
case AddressType.Int:
case AddressType.Double:
case AddressType.Boolean:
case AddressType.Char:
case AddressType.String:
{
clrObject = TryGetPrimitiveObject(dsObject, context, dsi, type);
break;
}
case AddressType.Null:
{
return(null);
}
case AddressType.Pointer:
{
DSObjectMap.TryGetValue(dsObject, out clrObject);
break;
}
default:
{
throw new NotSupportedException(string.Format("Operand type {0} not supported for marshalling", dsObject.optype));
}
}
if (null != clrObject)
{
return(clrObject);
}
return(CreateCLRObject(dsObject, context, dsi, type));
}
public override object UnMarshal(StackValue dsObject, ProtoCore.Runtime.Context context, Interpreter dsi, Type type)
{
char[] array = PrimitiveMarshler.ConvertDSArrayToCSArray <char>(kCharMarshaler, dsObject, context, dsi);
return(new string(array));
}
private object TryGetPrimitiveObject(StackValue dsObject, ProtoCore.Runtime.Context context, Interpreter dsi, System.Type type)
{
FFIObjectMarshler marshaler;
Type dsObjectType = type;
if (dsObjectType == typeof(object))
{
dsObjectType = GetPrimitiveType(dsObject.optype);
}
else if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable <>))
{
dsObjectType = Nullable.GetUnderlyingType(type);
}
if (mPrimitiveMarshalers.TryGetValue(dsObjectType, out marshaler))
{
return(marshaler.UnMarshal(dsObject, context, dsi, type));
}
return(null);
}
public override object UnMarshal(StackValue dsObject, ProtoCore.Runtime.Context context, Interpreter dsi, Type type)
{
return(ProtoCore.Utils.EncodingUtils.ConvertInt64ToCharacter(dsObject.opdata));
}
/// <summary>
///
/// </summary>
/// <param name="obj"></param>
/// <param name="context"></param>
/// <param name="dsi"></param>
/// <param name="type"></param>
/// <returns></returns>
public override StackValue Marshal(object obj, ProtoCore.Runtime.Context context, Interpreter dsi, ProtoCore.Type type)
{
if (obj == null)
{
return(StackUtils.BuildNull());
}
FFIObjectMarshler marshaler = null;
StackValue retVal;
Type objType = obj.GetType();
if (type.IsIndexable)
{
if (obj is System.Collections.ICollection)
{
System.Collections.ICollection collection = obj as System.Collections.ICollection;
object[] array = new object[collection.Count];
collection.CopyTo(array, 0);
return(PrimitiveMarshler.ConvertCSArrayToDSArray(this, array, context, dsi, type));
}
else if (obj is System.Collections.IEnumerable)
{
System.Collections.IEnumerable enumerable = obj as System.Collections.IEnumerable;
return(PrimitiveMarshler.ConvertCSArrayToDSArray(this, enumerable, context, dsi, type));
}
}
Array arr = obj as Array;
if (null != arr)
{
return(PrimitiveMarshler.ConvertCSArrayToDSArray(this, arr, context, dsi, type));
}
else if ((PrimitiveMarshler.IsPrimitiveDSType(type) || PrimitiveMarshler.IsPrimitiveObjectType(obj, type)) && mPrimitiveMarshalers.TryGetValue(objType, out marshaler))
{
return(marshaler.Marshal(obj, context, dsi, type));
}
else if (CLRObjectMap.TryGetValue(obj, out retVal))
{
return(retVal);
}
return(CreateDSObject(obj, context, dsi));
}
public override object UnMarshal(StackValue dsObject, ProtoCore.Runtime.Context context, Interpreter dsi, Type type)
{
return(dsObject.opdata == 0 ? false : true);
}
public override StackValue Marshal(object obj, ProtoCore.Runtime.Context context, Interpreter dsi, ProtoCore.Type type)
{
string str = (string)obj;
StackValue dsarray = PrimitiveMarshler.ConvertCSArrayToDSArray(kCharMarshaler, str.ToCharArray(), context, dsi, type);
return(StackUtils.BuildString(dsarray.opdata));
}
public override object UnMarshal(StackValue dsObject, ProtoCore.Runtime.Context context, Interpreter dsi, Type type)
{
if (dsObject.opdata_d > MaxValue || dsObject.opdata_d < MinValue)
{
string message = String.Format(ProtoCore.RuntimeData.WarningMessage.kFFIInvalidCast, dsObject.opdata_d, type.Name, MinValue, MaxValue);
dsi.LogWarning(ProtoCore.RuntimeData.WarningID.kTypeMismatch, message);
}
return(CastToDouble(dsObject.opdata_d));
}
public override StackValue Marshal(object obj, ProtoCore.Runtime.Context context, Interpreter dsi, ProtoCore.Type type)
{
return(StackUtils.BuildChar((char)obj));
}
public override void OnDispose(StackValue dsObject, ProtoCore.Runtime.Context context, Interpreter dsi)
{
throw new NotImplementedException();
}
public override StackValue Marshal(object obj, ProtoCore.Runtime.Context context, Interpreter dsi, ProtoCore.Type type)
{
return(StackUtils.BuildNode(AddressType.Boolean, (bool)obj ? 1 : 0));
}
public static StackValue ConvertCSArrayToDSArray(FFIObjectMarshler marshaler, IEnumerable enumerable, ProtoCore.Runtime.Context context, Interpreter dsi, ProtoCore.Type type)
{
var core = dsi.runtime.Core;
List <StackValue> svs = new List <StackValue>();
//Create new dsType for marshaling the elements, by reducing the rank
ProtoCore.Type dsType = new ProtoCore.Type {
Name = type.Name, rank = type.rank - 1, UID = type.UID
};
dsType.IsIndexable = dsType.rank > 0;
foreach (var item in enumerable)
{
StackValue value = marshaler.Marshal(item, context, dsi, dsType);
svs.Add(value);
}
var retVal = dsi.runtime.rmem.BuildArray(svs.ToArray());
return(retVal);
}
public override StackValue Marshal(object obj, ProtoCore.Runtime.Context context, Interpreter dsi, ProtoCore.Type type)
{
return(StackUtils.BuildDouble(System.Convert.ToDouble(obj)));
}
/// <summary>
///
/// </summary>
/// <param name="dsObject"></param>
/// <param name="context"></param>
/// <param name="dsi"></param>
/// <param name="type"></param>
/// <returns></returns>
private object CreateCLRObject(StackValue dsObject, ProtoCore.Runtime.Context context, Interpreter dsi, System.Type type)
{
object clrObject = TryGetPrimitiveObject(dsObject, context, dsi, type);
if (null != clrObject)
{
return(clrObject);
}
//Must be a user defined type, and expecting a var object
if (type == typeof(object) && dsObject.optype == AddressType.Pointer)
{
//TOD: Fix GC issue, don't know how/when this will get GCed??
dsi.runtime.rmem.Heap.IncRefCount(dsObject);
BindObjects(dsObject, dsObject);
return(dsObject);
}
throw new InvalidOperationException("Unable to locate managed object for given dsObject.");
}
/// <summary>
///
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="dsObject"></param>
/// <param name="context"></param>
/// <param name="dsi"></param>
/// <returns></returns>
public static T[] ConvertDSArrayToCSArray <T>(FFIObjectMarshler marshaler, StackValue dsObject, ProtoCore.Runtime.Context context, Interpreter dsi)
{
StackValue[] arr = dsi.runtime.rmem.GetArrayElements(dsObject);
int count = arr.Length;
T[] array = new T[count];
Type objType = typeof(T);
for (int idx = 0; idx < count; ++idx)
{
object obj = marshaler.UnMarshal(arr[idx], context, dsi, objType);
if (null == obj)
{
if (objType.IsValueType)
{
throw new System.InvalidCastException(string.Format("Null value cannot be cast to {0}", objType.Name));
}
array[idx] = default(T);
}
else
{
array[idx] = (T)obj;
}
}
return(array);
}
private SelectorContext selector(int _p)
{
ParserRuleContext _parentctx = Context;
int _parentState = State;
SelectorContext _localctx = new SelectorContext(Context, _parentState);
SelectorContext _prevctx = _localctx;
int _startState = 12;
EnterRecursionRule(_localctx, 12, RULE_selector, _p);
try {
int _alt;
EnterOuterAlt(_localctx, 1);
{
State = 64;
ErrorHandler.Sync(this);
switch (Interpreter.AdaptivePredict(TokenStream, 5, Context))
{
case 1:
{
State = 62;
identifier();
}
break;
case 2:
{
State = 63;
functionInvoke();
}
break;
}
Context.Stop = TokenStream.LT(-1);
State = 76;
ErrorHandler.Sync(this);
_alt = Interpreter.AdaptivePredict(TokenStream, 7, Context);
while (_alt != 2 && _alt != global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER)
{
if (_alt == 1)
{
if (ParseListeners != null)
{
TriggerExitRuleEvent();
}
_prevctx = _localctx;
{
State = 74;
ErrorHandler.Sync(this);
switch (Interpreter.AdaptivePredict(TokenStream, 6, Context))
{
case 1:
{
_localctx = new SelectorContext(_parentctx, _parentState);
PushNewRecursionContext(_localctx, _startState, RULE_selector);
State = 66;
if (!(Precpred(Context, 2)))
{
throw new FailedPredicateException(this, "Precpred(Context, 2)");
}
State = 67;
Match(DOT);
State = 68;
identifier();
}
break;
case 2:
{
_localctx = new SelectorContext(_parentctx, _parentState);
PushNewRecursionContext(_localctx, _startState, RULE_selector);
State = 69;
if (!(Precpred(Context, 1)))
{
throw new FailedPredicateException(this, "Precpred(Context, 1)");
}
State = 70;
Match(LBRACKET);
State = 71;
simple();
State = 72;
Match(RBRACKET);
}
break;
}
}
}
State = 78;
ErrorHandler.Sync(this);
_alt = Interpreter.AdaptivePredict(TokenStream, 7, Context);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
ErrorHandler.ReportError(this, re);
ErrorHandler.Recover(this, re);
}
finally {
UnrollRecursionContexts(_parentctx);
}
return(_localctx);
}
/// <summary>
///
/// </summary>
/// <param name="csArray"></param>
/// <param name="context"></param>
/// <param name="dsi"></param>
/// <returns></returns>
public static StackValue ConvertCSArrayToDSArray(FFIObjectMarshler marshaler, Array csArray, ProtoCore.Runtime.Context context, Interpreter dsi, ProtoCore.Type type)
{
var core = dsi.runtime.Core;
StackValue[] sv = new StackValue[csArray.Length];
int size = sv.Length;
//Create new dsType for marshaling the elements, by reducing the rank
ProtoCore.Type dsType = new ProtoCore.Type {
Name = type.Name, rank = type.rank - 1, UID = type.UID
};
dsType.IsIndexable = dsType.rank > 0;
for (int i = 0; i < size; ++i)
{
StackValue value = marshaler.Marshal(csArray.GetValue(i), context, dsi, dsType);
sv[i] = value;
}
var retVal = dsi.runtime.rmem.BuildArray(sv);
return(retVal);
}
/// <summary>
///
/// </summary>
/// <param name="terp"></param>
/// <returns></returns>
public Interpreter GetInterpreter(Interpreter terp)
{
return(terp);
}
/// <summary>
///
/// </summary>
/// <param name="dsObject"></param>
/// <param name="context"></param>
/// <param name="dsi"></param>
/// <param name="arrayType"></param>
/// <returns></returns>
private object ConvertDSArrayToCSArray(StackValue dsObject, ProtoCore.Runtime.Context context, Interpreter dsi, System.Type arrayType)
{
if (arrayType.IsArray)
{
// processing only for the primitive types
// anything else will be dealt with as it was earlier
//
if (arrayType.UnderlyingSystemType == typeof(int[]))
{
return(PrimitiveMarshler.ConvertDSArrayToCSArray <int>(this, dsObject, context, dsi));
}
else if (arrayType.UnderlyingSystemType == typeof(double[]))
{
return(PrimitiveMarshler.ConvertDSArrayToCSArray <double>(this, dsObject, context, dsi));
}
else if (arrayType.UnderlyingSystemType == typeof(bool[]))
{
return(PrimitiveMarshler.ConvertDSArrayToCSArray <bool>(this, dsObject, context, dsi));
}
}
int ptr = (int)dsObject.opdata;
HeapElement hs = dsi.runtime.rmem.Heap.Heaplist[ptr];
int count = hs.VisibleSize;
// use arraylist instead of object[], this allows us to correctly capture
// the type of objects being passed
//
ArrayList arrList = new ArrayList();
var elementType = arrayType.GetElementType();
if (elementType == null)
{
elementType = typeof(object);
}
for (int idx = 0; idx < count; ++idx)
{
arrList.Add(UnMarshal(hs.Stack[idx], context, dsi, elementType));
}
return(arrList.ToArray(elementType));
}
private static ReturnCode InteractiveLoopCallback(Interpreter interpreter, InteractiveLoopData loopData, ref Result result)
{
return(ReturnCode.Ok);
}
public void SetUp()
{
_interpreter = new Interpreter();
}
private static ReturnCode ExecuteCallback(Interpreter interpreter, IClientData clientData, ArgumentList arguments, ref Result result)
{
return(ReturnCode.Ok);
}
/// <summary>
///
/// </summary>
/// <param name="terp"></param>
public void StoreInterpreter(Interpreter terp)
{
}
