public EngineController(DynamoModel dynamoModel, string geometryFactoryFileName)
{
this.dynamoModel = dynamoModel;
// Create a core which is used for parsing code and loading libraries
libraryCore = new ProtoCore.Core(new Options()
{
RootCustomPropertyFilterPathName = string.Empty
});
libraryCore.Executives.Add(Language.kAssociative, new ProtoAssociative.Executive(libraryCore));
libraryCore.Executives.Add(Language.kImperative, new ProtoImperative.Executive(libraryCore));
libraryCore.ParsingMode = ParseMode.AllowNonAssignment;
libraryServices = new LibraryServices(libraryCore);
libraryServices.LibraryLoading += this.LibraryLoading;
libraryServices.LibraryLoadFailed += this.LibraryLoadFailed;
libraryServices.LibraryLoaded += this.LibraryLoaded;
liveRunnerServices = new LiveRunnerServices(dynamoModel, this, geometryFactoryFileName);
liveRunnerServices.ReloadAllLibraries(libraryServices.ImportedLibraries);
codeCompletionServices = new CodeCompletionServices(LiveRunnerCore);
astBuilder = new AstBuilder(dynamoModel, this);
syncDataManager = new SyncDataManager();
dynamoModel.NodeDeleted += NodeDeleted;
}
// This constructor is only called for Preloading of assemblies and
// precompilation of CodeBlockNode nodes in GraphUI for global language blocks - pratapa
public CodeGen(Core coreObj) : base(coreObj)
{
Validity.Assert(core.IsParsingPreloadedAssembly || core.IsParsingCodeBlockNode);
classOffset = 0;
// either of these should set the console to flood
//
emitReplicationGuide = false;
setConstructorStartPC = false;
// Re-use the existing procedureTable and symbolTable to access the built-in and predefined functions
ProcedureTable procTable = core.CodeBlockList[0].procedureTable;
codeBlock = BuildNewCodeBlock(procTable);
// Remove global symbols from existing symbol table for subsequent run in Graph UI
//SymbolTable sTable = core.CodeBlockList[0].symbolTable;
//sTable.RemoveGlobalSymbols();
//codeBlock = core.CodeBlockList[0];
compilePass = ProtoCore.CompilerDefinitions.Associative.CompilePass.kClassName;
// Bouncing to this language codeblock from a function should immediately set the first instruction as the entry point
if (ProtoCore.DSASM.Constants.kGlobalScope != globalProcIndex)
{
isEntrySet = true;
codeBlock.instrStream.entrypoint = 0;
}
unPopulatedClasses = new Dictionary<int, ClassDeclNode>();
}
static void Run(string filename, bool verbose)
{
if (!File.Exists(filename))
{
Console.WriteLine("Cannot find file " + filename);
return;
}
var profilingThread = new Thread(new ThreadStart(CollectingMemory));
profilingThread.Start();
System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
sw.Start();
var opts = new Options();
opts.ExecutionMode = ExecutionMode.Serial;
ProtoCore.Core core = new Core(opts);
core.Compilers.Add(ProtoCore.Language.Associative, new ProtoAssociative.Compiler(core));
core.Compilers.Add(ProtoCore.Language.Imperative, new ProtoImperative.Compiler(core));
core.Options.DumpByteCode = verbose;
core.Options.Verbose = verbose;
ProtoFFI.DLLFFIHandler.Register(ProtoFFI.FFILanguage.CSharp, new ProtoFFI.CSModuleHelper());
ProtoScriptRunner runner = new ProtoScriptRunner();
runner.LoadAndExecute(filename, core);
long ms = sw.ElapsedMilliseconds;
sw.Stop();
done = true;
profilingThread.Join();
Console.WriteLine("{0},{1},{2}", ms, maxNetMemory, maxPrivateWorkingSet);
}
public void SetUp()
{
testCore = thisTest.SetupTestCore();
testRuntimeCore = new RuntimeCore(testCore.Heap, testCore.Options);
testExecutive = new TestExecutive(testRuntimeCore);
}
public CoreCodeGen(Core coreObj, ProtoCore.DSASM.CodeBlock parentBlock = null)
{
Debug.Assert(coreObj != null);
this.core = coreObj;
argOffset = 0;
globalClassIndex = core.ClassIndex;
if (null == CoreCodeGen.CodeRangeTable)
CoreCodeGen.CodeRangeTable = new CodeRangeTable();
if (null == CoreCodeGen.IdentLocation)
CoreCodeGen.IdentLocation = new IdentLocationTable();
if (null == CoreCodeGen.ImportTable)
CoreCodeGen.ImportTable = new ImportTable();
context = new ProtoCore.CompileTime.Context();
opKwData = new ProtoCore.DSASM.OpKeywordData();
targetLangBlock = ProtoCore.DSASM.Constants.kInvalidIndex;
enforceTypeCheck = true;
localProcedure = core.ProcNode;
globalProcIndex = null != localProcedure ? localProcedure.procId : ProtoCore.DSASM.Constants.kGlobalScope;
tryLevel = 0;
}
public override void Setup()
{
base.Setup();
libraryCore = new ProtoCore.Core(new Options());
libraryCore.Compilers.Add(Language.Associative, new ProtoAssociative.Compiler(libraryCore));
libraryCore.Compilers.Add(Language.Imperative, new ProtoImperative.Compiler(libraryCore));
libraryCore.ParsingMode = ParseMode.AllowNonAssignment;
var pathResolver = new TestPathResolver();
pathResolver.AddPreloadLibraryPath("Builtin.dll");
pathResolver.AddPreloadLibraryPath("DSCoreNodes.dll");
var pathManager = new PathManager(new PathManagerParams
{
PathResolver = pathResolver
});
var settings = new PreferenceSettings();
libraryServices = new LibraryServices(libraryCore, pathManager, settings);
RegisterEvents();
}
private void SetupCommonRunner(bool inDebugMode)
{
var options = new ProtoCore.Options();
options.Verbose = GetDisplayOutput();
options.ExecutionMode = ProtoCore.ExecutionMode.Serial;
options.SuppressBuildOutput = false;
options.IDEDebugMode = inDebugMode;
AppendSearchPaths(options);
this.core = new ProtoCore.Core(options);
this.core.CurrentDSFileName = options.RootModulePathName;
this.core.Executives.Add(ProtoCore.Language.kAssociative, new ProtoAssociative.Executive(this.core));
this.core.Executives.Add(ProtoCore.Language.kImperative, new ProtoImperative.Executive(this.core));
// Get configuration from host app
var configurations = Solution.Current.ExecutionSession.HostApplication.Configurations;
if (configurations != null)
{
foreach (var item in configurations)
{
this.core.Configurations[item.Key] = item.Value;
}
}
IOutputStream messageList = Solution.Current.GetMessage(false);
this.core.RuntimeStatus.MessageHandler = messageList;
workerParams.RegularRunMirror = null;
DLLFFIHandler.Register(FFILanguage.CSharp, new CSModuleHelper());
asynchronousExecution = Solution.Current.Asynchronous;
}
/// <summary>
/// For a given list of formal parameters, get the function end points that resolve
/// </summary>
/// <param name="context"></param>
/// <param name="formalParams"></param>
/// <param name="replicationInstructions"></param>
/// <param name="stackFrame"></param>
/// <param name="core"></param>
/// <param name="unresolvable">The number of argument sets that couldn't be resolved</param>
/// <returns></returns>
public Dictionary<FunctionEndPoint, int> GetExactMatchStatistics(
ProtoCore.Runtime.Context context,
List<List<StackValue>> reducedFormalParams, StackFrame stackFrame, Core core, out int unresolvable)
{
List<ReplicationInstruction> replicationInstructions = new List<ReplicationInstruction>(); //We've already done the reduction before calling this
unresolvable = 0;
Dictionary<FunctionEndPoint, int> ret = new Dictionary<FunctionEndPoint, int>();
foreach (List<StackValue> formalParamSet in reducedFormalParams)
{
List<FunctionEndPoint> feps = GetExactTypeMatches(context,
formalParamSet, replicationInstructions, stackFrame,
core);
if (feps.Count == 0)
{
//We have an arugment set that couldn't be resolved
unresolvable++;
}
foreach (FunctionEndPoint fep in feps)
{
if (ret.ContainsKey(fep))
ret[fep]++;
else
ret.Add(fep, 1);
}
}
return ret;
}
public void Setup()
{
var opts = new Options();
opts.ExecutionMode = ExecutionMode.Serial;
core = thisTest.CreateTestCore();
}
static void DevRun()
{
System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
sw.Start();
var opts = new Options();
opts.ExecutionMode = ExecutionMode.Serial;
ProtoCore.Core core = new Core(opts);
core.Executives.Add(ProtoCore.Language.kAssociative, new ProtoAssociative.Executive(core));
core.Executives.Add(ProtoCore.Language.kImperative, new ProtoImperative.Executive(core));
#if DEBUG
core.Options.DumpByteCode = true;
core.Options.Verbose = true;
#else
core.Options.DumpByteCode = false;
core.Options.Verbose = false;
#endif
ProtoFFI.DLLFFIHandler.Register(ProtoFFI.FFILanguage.CSharp, new ProtoFFI.CSModuleHelper());
ProtoScriptTestRunner runner = new ProtoScriptTestRunner();
ExecutionMirror mirror = runner.LoadAndExecute(@"C:\Users\Yu\dev\github\test.ds", core);
long ms = sw.ElapsedMilliseconds;
sw.Stop();
Console.WriteLine(ms);
Console.ReadLine();
}
public void TestCompilerAndRuntimeComponent01()
{
String code =
@"
a = 10;
";
// Compile core
var opts = new Options();
opts.ExecutionMode = ExecutionMode.Serial;
ProtoCore.Core core = new Core(opts);
core.Compilers.Add(ProtoCore.Language.kAssociative, new ProtoAssociative.Compiler(core));
core.Compilers.Add(ProtoCore.Language.kImperative, new ProtoImperative.Compiler(core));
ProtoScriptRunner runner = new ProtoScriptRunner();
// Compiler instance
ProtoCore.DSASM.Executable dsExecutable;
bool compileSucceeded = runner.CompileMe(code, core, out dsExecutable);
Assert.IsTrue(compileSucceeded == true);
// Pass compile data to the runtime
RuntimeCore runtimeCore = new RuntimeCore(core.Heap);
runtimeCore.SetProperties(core.Options, dsExecutable);
// Runtime
ExecutionMirror mirror = runner.ExecuteMe(runtimeCore);
Obj o = mirror.GetValue("a");
public ImperativeCodeGen(Core coreObj, ProtoCore.DSASM.CodeBlock parentBlock = null)
: base(coreObj, parentBlock)
{
// dumpbytecode is optionally enabled
//
astNodes = new List<ImperativeNode>();
SetCompileOptions();
// Create a new symboltable for this block
// Set the new symbol table's parent
// Set the new table as a child of the parent table
codeBlock = new ProtoCore.DSASM.CodeBlock(
ProtoCore.DSASM.CodeBlockType.kLanguage,
ProtoCore.Language.kImperative,
core.CodeBlockIndex,
new ProtoCore.DSASM.SymbolTable("imperative lang block", core.RuntimeTableIndex),
new ProtoCore.DSASM.ProcedureTable(core.RuntimeTableIndex));
++core.CodeBlockIndex;
++core.RuntimeTableIndex;
core.CodeBlockList.Add(codeBlock);
if (null != parentBlock)
{
// This is a nested block
parentBlock.children.Add(codeBlock);
codeBlock.parent = parentBlock;
}
blockScope = 0;
}
public EngineController(DynamoModel dynamoModel, string geometryFactoryFileName)
{
this.dynamoModel = dynamoModel;
// Create a core which is used for parsing code and loading libraries
libraryCore = new ProtoCore.Core(new Options()
{
RootCustomPropertyFilterPathName = string.Empty
});
libraryCore.Executives.Add(Language.kAssociative,new ProtoAssociative.Executive(libraryCore));
libraryCore.Executives.Add(Language.kImperative, new ProtoImperative.Executive(libraryCore));
libraryCore.ParsingMode = ParseMode.AllowNonAssignment;
libraryServices = new LibraryServices(libraryCore);
libraryServices.LibraryLoading += this.LibraryLoading;
libraryServices.LibraryLoadFailed += this.LibraryLoadFailed;
libraryServices.LibraryLoaded += this.LibraryLoaded;
liveRunnerServices = new LiveRunnerServices(dynamoModel, this, geometryFactoryFileName);
liveRunnerServices.ReloadAllLibraries(libraryServices.ImportedLibraries);
codeCompletionServices = new CodeCompletionServices(LiveRunnerCore);
astBuilder = new AstBuilder(dynamoModel, this);
syncDataManager = new SyncDataManager();
dynamoModel.NodeDeleted += NodeDeleted;
}
public CodeBlockNode GenerateAST(string pathFilename, ProtoCore.Core core)
{
Imperative.Scanner s = new Imperative.Scanner(pathFilename);
Imperative.Parser p = new Imperative.Parser(s, core);
p.Parse();
return(p.codeblock as CodeBlockNode);
}
public void TestCompilerAndRuntimeComponent01()
{
String code =
@"
// Any DS code goes here
a = 10;
";
// Compile core
var opts = new Options();
opts.ExecutionMode = ExecutionMode.Serial;
ProtoCore.Core core = new Core(opts);
core.Compilers.Add(ProtoCore.Language.kAssociative, new ProtoAssociative.Compiler(core));
core.Compilers.Add(ProtoCore.Language.kImperative, new ProtoImperative.Compiler(core));
ProtoScriptRunner runner = new ProtoScriptRunner();
// Compile
bool compileSucceeded = runner.CompileAndGenerateExe(code, core);
Assert.IsTrue(compileSucceeded == true);
// Execute
RuntimeCore runtimeCore = runner.ExecuteVM(core);
// Verify
ExecutionMirror mirror = new ExecutionMirror(runtimeCore.CurrentExecutive.CurrentDSASMExec, runtimeCore);
internal static ProtoCore.Core DebugRunnerRunOnly(string code)
{
ProtoCore.Core core;
DebugRunner fsr;
ProtoScript.Config.RunConfiguration runnerConfig;
string testPath = @"..\..\..\Scripts\Debugger\";
// Specify some of the requirements of IDE.
var options = new ProtoCore.Options();
options.ExecutionMode = ProtoCore.ExecutionMode.Serial;
options.SuppressBuildOutput = false;
core = new ProtoCore.Core(options);
core.Executives.Add(ProtoCore.Language.kAssociative, new ProtoAssociative.Executive(core));
core.Executives.Add(ProtoCore.Language.kImperative, new ProtoImperative.Executive(core));
runnerConfig = new ProtoScript.Config.RunConfiguration();
runnerConfig.IsParrallel = false;
fsr = new DebugRunner(core);
DLLFFIHandler.Register(FFILanguage.CSharp, new CSModuleHelper());
CLRModuleType.ClearTypes();
//Run
fsr.PreStart(code, runnerConfig);
DebugRunner.VMState vms = null;
vms = fsr.Run();
return(core);
}
static void Run(string filename, bool verbose)
{
if (!File.Exists(filename))
{
Console.WriteLine("Cannot find file " + filename);
return;
}
System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
sw.Start();
var opts = new Options();
opts.ExecutionMode = ExecutionMode.Serial;
ProtoCore.Core core = new Core(opts);
core.Compilers.Add(ProtoCore.Language.Associative, new ProtoAssociative.Compiler(core));
core.Compilers.Add(ProtoCore.Language.Imperative, new ProtoImperative.Compiler(core));
core.Options.DumpByteCode = verbose;
core.Options.Verbose = verbose;
ProtoFFI.DLLFFIHandler.Register(ProtoFFI.FFILanguage.CSharp, new ProtoFFI.CSModuleHelper());
ProtoScriptRunner runner = new ProtoScriptRunner();
runner.LoadAndExecute(filename, core);
long ms = sw.ElapsedMilliseconds;
sw.Stop();
Console.WriteLine(ms);
}
internal static ProtoCore.Core TestRunnerRunOnly(string code)
{
ProtoCore.Core core;
ProtoScript.Runners.ProtoScriptTestRunner fsr = new ProtoScriptTestRunner();
ProtoScript.Config.RunConfiguration runnerConfig;
// Specify some of the requirements of IDE.
var options = new ProtoCore.Options();
options.ExecutionMode = ProtoCore.ExecutionMode.Serial;
options.SuppressBuildOutput = false;
string testPath = @"..\..\..\test\Engine\ProtoTest\ImportFiles\";
options.IncludeDirectories.Add(testPath);
core = new ProtoCore.Core(options);
core.Executives.Add(ProtoCore.Language.kAssociative, new ProtoAssociative.Executive(core));
core.Executives.Add(ProtoCore.Language.kImperative, new ProtoImperative.Executive(core));
runnerConfig = new ProtoScript.Config.RunConfiguration();
runnerConfig.IsParrallel = false;
fsr = new ProtoScriptTestRunner();
DLLFFIHandler.Register(FFILanguage.CSharp, new CSModuleHelper());
CLRModuleType.ClearTypes();
//Run
fsr.Execute(code, core);
return(core);
}
// logs all errors and warnings by default
//
public BuildStatus(Core core,bool warningAsError, System.IO.TextWriter writer = null, bool errorAsWarning = false)
{
this.core = core;
//this.errorCount = 0;
//this.warningCount = 0;
warnings = new List<BuildData.WarningEntry>();
errors = new List<BuildData.ErrorEntry>();
this.warningAsError = warningAsError;
this.errorAsWarning = errorAsWarning;
if (writer != null)
{
consoleOut = System.Console.Out;
System.Console.SetOut(writer);
}
// Create a default console output stream, and this can
// be overwritten in IDE by assigning it a different value.
this.MessageHandler = new ConsoleOutputStream();
if (core.Options.WebRunner)
{
this.WebMsgHandler = new WebOutputStream(core);
}
}
static void DevRun()
{
System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
sw.Start();
var opts = new Options();
opts.ExecutionMode = ExecutionMode.Serial;
ProtoCore.Core core = new Core(opts);
core.Compilers.Add(ProtoCore.Language.Associative, new ProtoAssociative.Compiler(core));
core.Compilers.Add(ProtoCore.Language.Imperative, new ProtoImperative.Compiler(core));
#if DEBUG
core.Options.DumpByteCode = true;
core.Options.Verbose = true;
#else
core.Options.DumpByteCode = false;
core.Options.Verbose = false;
#endif
ProtoFFI.DLLFFIHandler.Register(ProtoFFI.FFILanguage.CSharp, new ProtoFFI.CSModuleHelper());
ProtoScriptRunner runner = new ProtoScriptRunner();
// Assuming current directory in test/debug mode is "...\Dynamo\bin\AnyCPU\Debug"
runner.LoadAndExecute(@"..\..\..\test\core\dsevaluation\DSFiles\test.ds", core);
long ms = sw.ElapsedMilliseconds;
sw.Stop();
Console.WriteLine(ms);
Console.ReadLine();
}
public CodeGen(Core coreObj, ProtoCore.CompileTime.Context callContext, ProtoCore.DSASM.CodeBlock parentBlock = null) : base(coreObj, parentBlock)
{
context = callContext;
codeBlock = BuildNewCodeBlock();
if (null == parentBlock)
{
// This is a top level block
core.CodeBlockList.Add(codeBlock);
}
else
{
// This is a nested block
parentBlock.children.Add(codeBlock);
codeBlock.parent = parentBlock;
}
blockScope = 0;
// Bouncing to this language codeblock from a function should immediatlet se the first instruction as the entry point
if (ProtoCore.DSASM.Constants.kGlobalScope != globalProcIndex)
{
isEntrySet = true;
codeBlock.instrStream.entrypoint = 0;
}
backpatchMap = new BackpatchMap();
nodeBuilder = new NodeBuilder(core);
}
internal static ProtoCore.Core DebugRunnerRunOnly(string code, out RuntimeCore runtimeCore)
{
ProtoCore.Core core;
DebugRunner fsr;
// Specify some of the requirements of IDE.
var options = new ProtoCore.Options();
options.ExecutionMode = ProtoCore.ExecutionMode.Serial;
options.GCTempVarsOnDebug = false;
string testPath = @"..\..\..\test\Engine\ProtoTest\ImportFiles\";
options.IncludeDirectories.Add(testPath);
core = new ProtoCore.Core(options);
core.Compilers.Add(ProtoCore.Language.Associative, new ProtoAssociative.Compiler(core));
core.Compilers.Add(ProtoCore.Language.Imperative, new ProtoImperative.Compiler(core));
fsr = new DebugRunner(core);
DLLFFIHandler.Register(FFILanguage.CSharp, new CSModuleHelper());
CLRModuleType.ClearTypes();
//Run
fsr.PreStart(code);
DebugRunner.VMState vms = null;
vms = fsr.Run();
runtimeCore = fsr.runtimeCore;
return(core);
}
internal static ProtoCore.Core TestRunnerRunOnly(string code, out RuntimeCore runtimeCore)
{
ProtoCore.Core core;
ProtoScript.Runners.ProtoScriptRunner fsr = new ProtoScriptRunner();
// Specify some of the requirements of IDE.
var options = new ProtoCore.Options();
options.ExecutionMode = ProtoCore.ExecutionMode.Serial;
string testPath = @"..\..\..\test\Engine\ProtoTest\ImportFiles\";
options.IncludeDirectories.Add(testPath);
core = new ProtoCore.Core(options);
core.Compilers.Add(ProtoCore.Language.Associative, new ProtoAssociative.Compiler(core));
core.Compilers.Add(ProtoCore.Language.Imperative, new ProtoImperative.Compiler(core));
fsr = new ProtoScriptRunner();
DLLFFIHandler.Register(FFILanguage.CSharp, new CSModuleHelper());
CLRModuleType.ClearTypes();
//Run
runtimeCore = fsr.Execute(code, core);
return(core);
}
internal static ProtoCore.Core TestRunnerRunOnly(string code, out RuntimeCore runtimeCore)
{
ProtoCore.Core core;
ProtoScript.Runners.ProtoScriptTestRunner fsr = new ProtoScriptTestRunner();
// Specify some of the requirements of IDE.
var options = new ProtoCore.Options();
options.ExecutionMode = ProtoCore.ExecutionMode.Serial;
options.SuppressBuildOutput = false;
string testPath = @"..\..\..\test\Engine\ProtoTest\ImportFiles\";
options.IncludeDirectories.Add(testPath);
core = new ProtoCore.Core(options);
core.Compilers.Add(ProtoCore.Language.kAssociative, new ProtoAssociative.Compiler(core));
core.Compilers.Add(ProtoCore.Language.kImperative, new ProtoImperative.Compiler(core));
fsr = new ProtoScriptTestRunner();
DLLFFIHandler.Register(FFILanguage.CSharp, new CSModuleHelper());
CLRModuleType.ClearTypes();
//Run
fsr.Execute(code, core, out runtimeCore);
return core;
}
internal static void CompareCores(Core c1, Core c2)
{
Assert.AreEqual(c1.DSExecutable.runtimeSymbols.Length, c2.DSExecutable.runtimeSymbols.Length);
for (int symTableIndex = 0; symTableIndex < c1.DSExecutable.runtimeSymbols.Length; symTableIndex++)
{
foreach (SymbolNode symNode in c1.DSExecutable.runtimeSymbols[symTableIndex].symbolList.Values)
{
ExecutionMirror runExecMirror = new ExecutionMirror(c1.CurrentExecutive.CurrentDSASMExec,
c1);
ExecutionMirror debugExecMirror =
new ExecutionMirror(c2.CurrentExecutive.CurrentDSASMExec, c2);
bool lookupOk = false;
StackValue runValue = new StackValue();
if (symNode.name.StartsWith("%") || symNode.functionIndex != Constants.kInvalidIndex)
continue; //Don't care about internal variables
try
{
runValue = runExecMirror.GetGlobalValue(symNode.name);
Console.WriteLine(symNode.name + ": " + runValue);
lookupOk = true;
}
catch (NotImplementedException)
{
}
catch (Exception ex)
{
if ((ex is ArgumentOutOfRangeException || ex is IndexOutOfRangeException) &&
(c1.RunningBlock != symNode.runtimeTableIndex))
{
// Quite possible that variables defined in the inner
// language block have been garbage collected and
// stack frame pointer has been adjusted when return
// to the outer block.
}
else
{
throw ex;
}
}
if (lookupOk)
{
StackValue debugValue = debugExecMirror.GetGlobalValue(symNode.name);
if (!StackUtils.CompareStackValues(debugValue, runValue, c2, c1))
{
Assert.Fail(string.Format("\tThe value of variable \"{0}\" doesn't match in run mode and in debug mode.\n", symNode.name));
}
}
}
}
}
internal static ProtoCore.Core TestRunnerRunOnly(string includePath, string code,
Dictionary <int, List <string> > map, string geometryFactory,
string persistentManager, out ExecutionMirror mirror)
{
ProtoCore.Core core;
ProtoScript.Runners.ProtoScriptTestRunner fsr = new ProtoScriptTestRunner();
ProtoScript.Config.RunConfiguration runnerConfig;
// Specify some of the requirements of IDE.
var options = new ProtoCore.Options();
options.ExecutionMode = ProtoCore.ExecutionMode.Serial;
options.SuppressBuildOutput = false;
options.WatchTestMode = true;
// Cyclic dependency threshold is lowered from the default (2000)
// as this causes the test framework to be painfully slow
options.kDynamicCycleThreshold = 5;
// Pass the absolute path so that imported filepaths can be resolved
// in "FileUtils.GetDSFullPathName()"
includePath = Path.GetDirectoryName(includePath);
options.IncludeDirectories.Add(includePath);
//StreamWriter sw = File.CreateText(executionLogFilePath);
TextOutputStream fs = new TextOutputStream(map);
core = new ProtoCore.Core(options);
core.Configurations.Add(ConfigurationKeys.GeometryXmlProperties, true);
//core.Configurations.Add(ConfigurationKeys.GeometryFactory, geometryFactory);
//core.Configurations.Add(ConfigurationKeys.PersistentManager, persistentManager);
// By specifying this option we inject a mock Executive ('InjectionExecutive')
// that prints stackvalues at every assignment statement
// by overriding the POP_handler instruction - pratapa
//core.ExecutiveProvider = new InjectionExecutiveProvider();
core.BuildStatus.MessageHandler = fs;
core.Compilers.Add(ProtoCore.Language.kAssociative, new ProtoAssociative.Compiler(core));
core.Compilers.Add(ProtoCore.Language.kImperative, new ProtoImperative.Compiler(core));
runnerConfig = new ProtoScript.Config.RunConfiguration();
runnerConfig.IsParrallel = false;
DLLFFIHandler.Register(FFILanguage.CSharp, new CSModuleHelper());
//Run
mirror = fsr.Execute(code, core);
//sw.Close();
return(core);
}
public LibraryServices(ProtoCore.Core libraryManagementCore)
{
LibraryManagementCore = libraryManagementCore;
PreloadLibraries();
PopulateBuiltIns();
PopulateOperators();
PopulatePreloadLibraries();
}
public void SetUp()
{
testCore = thisTest.SetupTestCore();
testRuntimeCore = new RuntimeCore(testCore.Heap);
testRuntimeCore.SetProperties(testCore.Options, null);
testExecutive = new TestExecutive(testRuntimeCore);
}
public bool RegisterExtensionApplicationType(Core core, SysType type)
{
if (!typeof(IExtensionApplication).IsAssignableFrom(type))
return false;
FFIExecutionSession session = GetSession(core, true);
session.AddExtensionAppType(type);
return true;
}
public CodeGen(Core coreObj, ProtoCore.DSASM.CodeBlock parentBlock = null)
: base(coreObj, parentBlock)
{
// dumpbytecode is optionally enabled
//
astNodes = new List<ImperativeNode>();
SetCompileOptions();
// Create a new symboltable for this block
// Set the new symbol table's parent
// Set the new table as a child of the parent table
// Comment Jun: Get the codeblock to use for this codegenerator
if (core.Options.IsDeltaExecution)
{
codeBlock = GetDeltaCompileCodeBlock();
//if (core.Options.IsDeltaCompile)
//{
// pc = codeBlock.instrStream.instrList.Count;
//}
//else
//{
// pc = core.deltaCompileStartPC;
//}
}
else
{
codeBlock = BuildNewCodeBlock();
}
//codeBlock = BuildNewCodeBlock();
if (null == parentBlock)
{
// This is a top level block
core.CodeBlockList.Add(codeBlock);
}
else
{
// This is a nested block
parentBlock.children.Add(codeBlock);
codeBlock.parent = parentBlock;
}
core.CompleteCodeBlockList.Add(codeBlock);
blockScope = 0;
// Bouncing to this language codeblock from a function should immediatlet se the first instruction as the entry point
if (ProtoCore.DSASM.Constants.kGlobalScope != globalProcIndex)
{
isEntrySet = true;
codeBlock.instrStream.entrypoint = 0;
}
backpatchMap = new BackpatchMap();
nodeBuilder = new NodeBuilder(core);
}
static void Main()
{
ProtoCore.Core core = new ProtoCore.Core(new ProtoCore.Options());
string filePath = @"C:\DSCode\autodeskresearch\branches\UIResearch\DesignScriptParser\DSParser\DSParser\scripts\test1.ds";
DesignScript.Parser.Scanner s = new DesignScript.Parser.Scanner(filePath);
DesignScript.Parser.Parser p = new DesignScript.Parser.Parser(s, core);
p.Parse();
DesignScript.Parser.Node c = p.root;
}
private static FunctionDotCallNode CreateFunctionCallNode(string className, string methodName, List<AssociativeNode> args, Core core)
{
FunctionCallNode fNode = new FunctionCallNode();
fNode.Function = new IdentifierNode(methodName);
fNode.FormalArguments = args;
IdentifierNode inode = new IdentifierNode(className);
return CoreUtils.GenerateCallDotNode(inode, fNode, core);
}
static void Main()
{
ProtoCore.Core core = new ProtoCore.Core(new ProtoCore.Options());
string filePath = @"C:\DSCode\autodeskresearch\branches\UIResearch\DesignScriptParser\DSParser\DSParser\scripts\test1.ds";
DesignScript.Parser.Scanner s = new DesignScript.Parser.Scanner(filePath);
DesignScript.Parser.Parser p = new DesignScript.Parser.Parser(s, core);
p.Parse();
DesignScript.Parser.Node c = p.root;
}
public LibraryServices(ProtoCore.Core libraryManagementCore, IPathManager pathManager)
{
LibraryManagementCore = libraryManagementCore;
this.pathManager = pathManager;
PreloadLibraries(pathManager.PreloadedLibraries);
PopulateBuiltIns();
PopulateOperators();
PopulatePreloadLibraries();
}
static void DevRun()
{
System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
sw.Start();
var opts = new Options();
opts.ExecutionMode = ExecutionMode.Serial;
ProtoCore.Core core = new Core(opts);
core.Executives.Add(ProtoCore.Language.kAssociative, new ProtoAssociative.Executive(core));
core.Executives.Add(ProtoCore.Language.kImperative, new ProtoImperative.Executive(core));
#if DEBUG
core.Options.DumpByteCode = true;
core.Options.Verbose = true;
#else
core.Options.DumpByteCode = false;
core.Options.Verbose = false;
#endif
#if __RUN_TESTFILE
ProtoFFI.DLLFFIHandler.Register(ProtoFFI.FFILanguage.CSharp, new ProtoFFI.CSModuleHelper());
ProtoScriptTestRunner runner = new ProtoScriptTestRunner();
ExecutionMirror mirror = runner.LoadAndExecute(@"D:\jun\AutodeskResearch\git\designscript\Scripts\jun.ds", core);
#else
// Insert test cases here
//ProtoTest.LiveRunner.MicroFeatureTests test = new ProtoTest.LiveRunner.MicroFeatureTests();
//test.Setup();
//test.TestPythonCodeExecution();
ProtoTest.Associative.MicroFeatureTests test = new ProtoTest.Associative.MicroFeatureTests();
test.Setup();
test.TestUpdateRedefinition01();
//IntegrationTests.IncrementingTraceTests test = new IntegrationTests.IncrementingTraceTests();
//test.Setup();
//test.IntermediateValueIncrementerIDTestUpdate1DReplicated();
//ProtoFFITests.CSFFIDispose test = new ProtoFFITests.CSFFIDispose();
//test.Setup();
//test.IntermediateValueIncrementerIDTestUpdate1DReplicated();
// test.Dispose_FFITarget_Overridden();
//ProtoTest.EventTests.PropertyChangedNotifyTest test = new ProtoTest.EventTests.PropertyChangedNotifyTest();
//test.Setup();
//test.RunPropertyChangedNegative();
#endif
long ms = sw.ElapsedMilliseconds;
sw.Stop();
Console.WriteLine(ms);
Console.ReadLine();
}
/// <summary>
/// Initializes a new instance of the <see cref="LibraryServices"/> class.
/// </summary>
/// <param name="libraryManagementCore">Core which is used for parsing code and loading libraries</param>
/// <param name="pathManager">Instance of IPathManager containing neccessary Dynamo paths</param>
public LibraryServices(ProtoCore.Core libraryManagementCore, IPathManager pathManager)
{
LibraryManagementCore = libraryManagementCore;
this.pathManager = pathManager;
PreloadLibraries(pathManager.PreloadedLibraries);
PopulateBuiltIns();
PopulateOperators();
PopulatePreloadLibraries();
LibraryLoadFailed += new EventHandler <LibraryLoadFailedEventArgs>(LibraryLoadFailureHandler);
}
private static FunctionDotCallNode CreateEntityNode(long hostInstancePtr, Core core)
{
FunctionCallNode fNode = new FunctionCallNode();
fNode.Function = new IdentifierNode("FromObject");
List<ProtoCore.AST.AssociativeAST.AssociativeNode> listArgs = new List<ProtoCore.AST.AssociativeAST.AssociativeNode>();
listArgs.Add(new ProtoCore.AST.AssociativeAST.IntNode(hostInstancePtr));
fNode.FormalArguments = listArgs;
string className = "Geometry";
IdentifierNode inode = new ProtoCore.AST.AssociativeAST.IdentifierNode(className);
return ProtoCore.Utils.CoreUtils.GenerateCallDotNode(inode, fNode, core);
}
public void Setup()
{
libraryCore = new ProtoCore.Core(new Options {
RootCustomPropertyFilterPathName = string.Empty
});
libraryCore.Compilers.Add(ProtoCore.Language.kAssociative, new ProtoAssociative.Compiler(libraryCore));
libraryCore.Compilers.Add(ProtoCore.Language.kImperative, new ProtoImperative.Compiler(libraryCore));
libraryCore.ParsingMode = ParseMode.AllowNonAssignment;
libraryServices = new LibraryServices(libraryCore, pathManager);
RegisterEvents();
}
/// <summary>
/// Initializes a new instance of the <see cref="LibraryServices"/> class.
/// </summary>
/// <param name="libraryManagementCore">Core which is used for parsing code and loading libraries</param>
/// <param name="pathManager">Instance of IPathManager containing neccessary Dynamo paths</param>
/// <param name="preferences">The preference settings of the Dynamo instance</param>
public LibraryServices(ProtoCore.Core libraryManagementCore, IPathManager pathManager, IPreferences preferences)
{
LibraryManagementCore = libraryManagementCore;
this.pathManager = pathManager;
preferenceSettings = preferences;
PreloadLibraries(pathManager.PreloadedLibraries);
PopulateBuiltIns();
PopulateOperators();
PopulatePreloadLibraries();
LibraryLoadFailed += new EventHandler <LibraryLoadFailedEventArgs>(LibraryLoadFailureHandler);
AppDomain.CurrentDomain.AssemblyResolve += ResolveAssembly;
}
public DependencyPass.DependencyTracker GetDemoTracker2(ProtoCore.Core core)
{
Associative.Scanner s = new Associative.Scanner(@"..\..\Scripts\expr.ds");
Associative.Parser p = new Associative.Parser(s, core);
p.Parse();
CodeBlockNode code = p.codeblock as CodeBlockNode;
DependencyTracker tempTracker = new DependencyTracker();
Dictionary <string, List <Node> > names = new Dictionary <string, List <Node> >();
code.ConsolidateNames(ref (names));
tempTracker.GenerateDependencyGraph(code.Body);
return(tempTracker);
}
/// <summary>
/// Convert the parameters passed to the types specified in this fep
/// </summary>
/// <param name="formalParameters"></param>
/// <returns></returns>
public List<StackValue> CoerceParameters(List<StackValue> formalParameters, Core core)
{
List<StackValue> fixedUpVersions = new List<StackValue>();
for (int i = 0; i < formalParameters.Count; i++)
{
StackValue formalParam = formalParameters[i];
Type targetType = FormalParams[i];
StackValue coercedParam = TypeSystem.Coerce(formalParam, targetType, core);
GCUtils.GCRetain(coercedParam, core);
fixedUpVersions.Add(coercedParam);
}
return fixedUpVersions;
}
public CodeGen(Core coreObj, ProtoCore.DSASM.CodeBlock parentBlock = null)
: base(coreObj, parentBlock)
{
// dumpbytecode is optionally enabled
//
astNodes = new List<ImperativeNode>();
SetCompileOptions();
// Create a new symboltable for this block
// Set the new symbol table's parent
// Set the new table as a child of the parent table
codeBlock = new ProtoCore.DSASM.CodeBlock(
ProtoCore.DSASM.CodeBlockType.kLanguage,
ProtoCore.Language.kImperative,
core.CodeBlockIndex,
new ProtoCore.DSASM.SymbolTable("imperative lang block", core.RuntimeTableIndex),
new ProtoCore.DSASM.ProcedureTable(core.RuntimeTableIndex), false, coreObj);
++core.CodeBlockIndex;
++core.RuntimeTableIndex;
if (null == parentBlock)
{
// This is a top level block
core.CodeBlockList.Add(codeBlock);
}
else
{
// This is a nested block
parentBlock.children.Add(codeBlock);
codeBlock.parent = parentBlock;
}
core.CompleteCodeBlockList.Add(codeBlock);
blockScope = 0;
// Bouncing to this language codeblock from a function should immediatlet se the first instruction as the entry point
if (ProtoCore.DSASM.Constants.kGlobalScope != globalProcIndex)
{
isEntrySet = true;
codeBlock.instrStream.entrypoint = 0;
}
backpatchMap = new BackpatchMap();
nodeBuilder = new NodeBuilder(core);
}
internal static ProtoCore.Core DebugRunnerStepOver(string code, out RuntimeCore runtimeCore)
{
//Internal setup
ProtoCore.Core core;
DebugRunner fsr;
ProtoScript.Config.RunConfiguration runnerConfig;
// Specify some of the requirements of IDE.
var options = new ProtoCore.Options();
options.ExecutionMode = ProtoCore.ExecutionMode.Serial;
options.SuppressBuildOutput = false;
options.GCTempVarsOnDebug = false;
string testPath = @"..\..\..\test\Engine\ProtoTest\ImportFiles\";
options.IncludeDirectories.Add(testPath);
core = new ProtoCore.Core(options);
core.Compilers.Add(ProtoCore.Language.kAssociative, new ProtoAssociative.Compiler(core));
core.Compilers.Add(ProtoCore.Language.kImperative, new ProtoImperative.Compiler(core));
runnerConfig = new ProtoScript.Config.RunConfiguration();
runnerConfig.IsParrallel = false;
fsr = new DebugRunner(core);
DLLFFIHandler.Register(FFILanguage.CSharp, new CSModuleHelper());
CLRModuleType.ClearTypes();
//Run
fsr.PreStart(code, runnerConfig);
DebugRunner.VMState vms = null;
while (!fsr.isEnded)
{
vms = fsr.StepOver();
}
runtimeCore = fsr.runtimeCore;
return(core);
}
static void Run(string filename, bool verbose)
{
if (!File.Exists(filename))
{
Console.WriteLine("Cannot find file " + filename);
return;
}
var opts = new Options();
opts.ExecutionMode = ExecutionMode.Serial;
ProtoCore.Core core = new Core(opts);
core.Executives.Add(ProtoCore.Language.kAssociative, new ProtoAssociative.Executive(core));
core.Executives.Add(ProtoCore.Language.kImperative, new ProtoImperative.Executive(core));
core.Options.DumpByteCode = verbose;
core.Options.Verbose = verbose;
ProtoFFI.DLLFFIHandler.Register(ProtoFFI.FFILanguage.CSharp, new ProtoFFI.CSModuleHelper());
ProtoScriptTestRunner runner = new ProtoScriptTestRunner();
ExecutionMirror mirror = runner.LoadAndExecute(filename, core);
}
public override void Setup()
{
base.Setup();
libraryCore = new ProtoCore.Core(new Options { RootCustomPropertyFilterPathName = string.Empty });
libraryCore.Compilers.Add(Language.kAssociative, new ProtoAssociative.Compiler(libraryCore));
libraryCore.Compilers.Add(Language.kImperative, new ProtoImperative.Compiler(libraryCore));
libraryCore.ParsingMode = ParseMode.AllowNonAssignment;
var pathResolver = new TestPathResolver();
pathResolver.AddPreloadLibraryPath("DSCoreNodes.dll");
var pathManager = new PathManager(new PathManagerParams
{
PathResolver = pathResolver
});
libraryServices = new LibraryServices(libraryCore, pathManager);
RegisterEvents();
}
public void TestCBNEngineTests()
{
String code =
@"
[Associative]
{
foo=5;
}
";
ExecutionMirror mirror = thisTest.RunScriptSource(code);
ProtoCore.Core core = thisTest.GetTestCore();
Guid guid = RunDSScriptInCBN(code);
ProtoCore.Core dynamoCore = ViewModel.Model.EngineController.LiveRunnerCore;
CompareCores(core, dynamoCore, guid);
}
internal void CompareCores(ProtoCore.Core c1, ProtoCore.Core c2, Guid guid)
{
for (int symTableIndex = 0; symTableIndex < c1.DSExecutable.runtimeSymbols.Length; symTableIndex++)
{
foreach (SymbolNode symNode in c1.DSExecutable.runtimeSymbols[symTableIndex].symbolList.Values)
{
ProtoCore.Mirror.RuntimeMirror langMirror = null;
ProtoCore.Mirror.RuntimeMirror dynamoMirror = null;
bool lookupOk = false;
if (CoreUtils.IsCompilerGenerated(symNode.name) || symNode.functionIndex != Constants.kInvalidIndex)
{
continue; //Don't care about internal variables
}
if (symNode.functionIndex == Constants.kGlobalScope && symNode.classScope == Constants.kInvalidIndex)
{
langMirror = new ProtoCore.Mirror.RuntimeMirror(symNode.name, 0, c1);
string name = symNode.name + "_" + guid.ToString();
name = name.Replace("-", string.Empty);
dynamoMirror = ViewModel.Model.EngineController.GetMirror(name);
if (langMirror != null || dynamoMirror != null)
{
lookupOk = true;
}
if (lookupOk)
{
if (!langMirror.GetData().Equals(dynamoMirror.GetData()))
{
Assert.Fail(string.Format("\tThe value of variable \"{0}\" doesn't match in language mode and in Dynamo CBN mode.\n", symNode.name));
}
}
}
}
}
}
private void CleanUpRunners()
{
Logger.LogInfo("DetachFromDebugger", "Detach");
// Clear up all watch related data members.
this.workerParams.CurrentVmState = null;
this.currentWatchedMirror = null;
this.currentWatchedStackValue = null;
if (null != scriptRunner)
{
scriptRunner = null;
}
if (null != debugRunner)
{
debugRunner.Shutdown();
debugRunner = null;
}
if (null != internalWorker)
{
// @TODO(Ben): Perhaps cancellation is needed?
internalWorker = null;
}
//Fix DG-1464973 Sprint25: rev 3444 : Multiple import issue - dispose core after execution
//Core Cleanup should happen only after execution has finished,
//DebugRunner is ShutDown.
if (null != this.core)
{
this.core.Cleanup();
this.core = null;
}
workerParams.ResetStates();
SetExecutionState(ExecutionStateChangedEventArgs.States.None);
}
static void DevRun()
{
System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
sw.Start();
var opts = new Options();
opts.ExecutionMode = ExecutionMode.Serial;
ProtoCore.Core core = new Core(opts);
core.Executives.Add(ProtoCore.Language.kAssociative, new ProtoAssociative.Executive(core));
core.Executives.Add(ProtoCore.Language.kImperative, new ProtoImperative.Executive(core));
#if DEBUG
core.Options.DumpByteCode = true;
core.Options.Verbose = true;
#else
core.Options.DumpByteCode = false;
core.Options.Verbose = false;
#endif
#if __RUN_TESTFILE
ProtoFFI.DLLFFIHandler.Register(ProtoFFI.FFILanguage.CSharp, new ProtoFFI.CSModuleHelper());
ProtoScriptTestRunner runner = new ProtoScriptTestRunner();
ExecutionMirror mirror = runner.LoadAndExecute(@"defectverify.ds", core);
#else
ProtoTest.GraphCompiler.MicroFeatureTests test = new ProtoTest.GraphCompiler.MicroFeatureTests();
test.Setup();
test.GraphILTest_Assign02();
#endif
long ms = sw.ElapsedMilliseconds;
sw.Stop();
Console.WriteLine(ms);
Console.ReadLine();
}
public AssociativeCodeGen(Core coreObj, ProtoCore.DSASM.CodeBlock parentBlock = null)
: base(coreObj, parentBlock)
{
classOffset = 0;
// either of these should set the console to flood
//
ignoreRankCheck = false;
astNodes = new List<AssociativeNode>();
setConstructorStartPC = false;
// Create a new symboltable for this block
// Set the new symbol table's parent
// Set the new table as a child of the parent table
codeBlock = new ProtoCore.DSASM.CodeBlock(
ProtoCore.DSASM.CodeBlockType.kLanguage,
ProtoCore.Language.kAssociative,
core.CodeBlockIndex,
new ProtoCore.DSASM.SymbolTable("associative lang block", core.RuntimeTableIndex),
new ProtoCore.DSASM.ProcedureTable(core.RuntimeTableIndex),
false,
core);
++core.CodeBlockIndex;
++core.RuntimeTableIndex;
core.CodeBlockList.Add(codeBlock);
if (null != parentBlock)
{
// This is a nested block
parentBlock.children.Add(codeBlock);
codeBlock.parent = parentBlock;
}
compilePass = ProtoCore.DSASM.AssociativeCompilePass.kClassName;
}
public override void Setup()
{
base.Setup();
libraryCore = new ProtoCore.Core(new Options());
libraryCore.Compilers.Add(Language.Associative, new ProtoAssociative.Compiler(libraryCore));
libraryCore.Compilers.Add(Language.Imperative, new ProtoImperative.Compiler(libraryCore));
libraryCore.ParsingMode = ParseMode.AllowNonAssignment;
var pathResolver = new TestPathResolver();
pathResolver.AddPreloadLibraryPath("DSCoreNodes.dll");
var pathManager = new PathManager(new PathManagerParams
{
PathResolver = pathResolver
});
var settings = new PreferenceSettings();
libraryServices = new LibraryServices(libraryCore, pathManager, settings);
RegisterEvents();
}
public override void Setup()
{
base.Setup();
libraryCore = new ProtoCore.Core(new Options {
RootCustomPropertyFilterPathName = string.Empty
});
libraryCore.Compilers.Add(Language.kAssociative, new ProtoAssociative.Compiler(libraryCore));
libraryCore.Compilers.Add(Language.kImperative, new ProtoImperative.Compiler(libraryCore));
libraryCore.ParsingMode = ParseMode.AllowNonAssignment;
var pathResolver = new TestPathResolver();
pathResolver.AddPreloadLibraryPath("DSCoreNodes.dll");
var pathManager = new PathManager(new PathManagerParams
{
PathResolver = pathResolver
});
libraryServices = new LibraryServices(libraryCore, pathManager);
RegisterEvents();
}
private void RevitServicesUpdater_ElementsDeleted(Document document, IEnumerable <ElementId> deleted)
{
if (!deleted.Any())
{
return;
}
var workspace = this.CurrentWorkspace;
ProtoCore.Core core = null;
var engine = this.EngineController;
if (engine != null && (engine.LiveRunnerCore != null))
{
core = engine.LiveRunnerCore;
}
if (core == null) // No execution yet as of this point.
{
return;
}
// Selecting all nodes that are either a DSFunction,
// a DSVarArgFunction or a CodeBlockNodeModel into a list.
var nodeGuids = workspace.Nodes.Where((n) =>
{
return(n is DSFunction ||
(n is DSVarArgFunction) ||
(n is CodeBlockNodeModel));
}).Select((n) => n.GUID);
var nodeTraceDataList = core.GetCallsitesForNodes(nodeGuids);// core.GetTraceDataForNodes(nodeGuids);
foreach (Guid guid in nodeTraceDataList.Keys)
{
foreach (CallSite cs in nodeTraceDataList[guid])
{
foreach (CallSite.SingleRunTraceData srtd in cs.TraceData)
{
List <ISerializable> traceData = srtd.RecursiveGetNestedData();
foreach (ISerializable thingy in traceData)
{
SerializableId sid = thingy as SerializableId;
foreach (ElementId eid in deleted)
{
if (sid != null)
{
if (sid.IntID == eid.IntegerValue)
{
NodeModel inm =
workspace.Nodes.Where((n) => n.GUID == guid).FirstOrDefault();
Validity.Assert(inm != null, "The bound node has disappeared");
inm.RequiresRecalc = true;
inm.ForceReExecuteOfNode = true;
//FOUND IT!
}
}
}
}
}
}
}
}
internal static void DebugRunnerStepIn(string includePath, string code, /*string logFile*/ Dictionary <int, List <string> > map, bool watchNestedMode = false)
{
//Internal setup
ProtoCore.Core core;
DebugRunner fsr;
ProtoScript.Config.RunConfiguration runnerConfig;
// Specify some of the requirements of IDE.
var options = new ProtoCore.Options();
options.ExecutionMode = ProtoCore.ExecutionMode.Serial;
options.SuppressBuildOutput = false;
options.GCTempVarsOnDebug = false;
// Cyclic dependency threshold is lowered from the default (2000)
// as this causes the test framework to be painfully slow
options.kDynamicCycleThreshold = 5;
// Pass the absolute path so that imported filepaths can be resolved
// in "FileUtils.GetDSFullPathName()"
if (!String.IsNullOrEmpty(includePath))
{
includePath = Path.GetDirectoryName(includePath);
options.IncludeDirectories.Add(includePath);
}
core = new ProtoCore.Core(options);
// Use the InjectionExecutive to overload POP and POPM
// as we still need the symbol names and line nos. in debug mode for comparisons
core.ExecutiveProvider = new InjectionExecutiveProvider();
core.Executives.Add(ProtoCore.Language.kAssociative, new ProtoAssociative.Executive(core));
core.Executives.Add(ProtoCore.Language.kImperative, new ProtoImperative.Executive(core));
runnerConfig = new ProtoScript.Config.RunConfiguration();
runnerConfig.IsParrallel = false;
fsr = new DebugRunner(core);
DLLFFIHandler.Register(FFILanguage.CSharp, new CSModuleHelper());
//Run
fsr.PreStart(code, runnerConfig);
//StreamReader log = new StreamReader(logFile);
//bool isPrevBreakAtPop = false;
int lineAtPrevBreak = -1;
string symbolName = null;
DebugRunner.VMState vms = null;
while (!fsr.isEnded)
{
vms = fsr.LastState;
OpCode opCode = OpCode.NONE;
DebugInfo debug = null;
if (vms != null)
{
// check if previous break is a POP
// if so, get the line no. and LHS
opCode = fsr.CurrentInstruction.opCode;
debug = fsr.CurrentInstruction.debug;
if (opCode == ProtoCore.DSASM.OpCode.POP)
{
//isPrevBreakAtPop = true;
lineAtPrevBreak = vms.ExecutionCursor.StartInclusive.LineNo;
}
}
DebugRunner.VMState currentVms = fsr.Step();
//if (isPrevBreakAtPop)
if (debug != null)
{
// Do not do the verification for imported DS files, for which the FilePath is non null
if (debug.Location.StartInclusive.SourceLocation.FilePath == null)
{
if (opCode == ProtoCore.DSASM.OpCode.POP)
{
VerifyWatch_Run(lineAtPrevBreak, core.DebugProps.CurrentSymbolName, core, map, watchNestedMode);
}
// if previous breakpoint was at a CALLR
else if (opCode == ProtoCore.DSASM.OpCode.CALLR)
{
if (core.DebugProps.IsPopmCall)
{
int ci = (int)currentVms.mirror.MirrorTarget.rmem.GetAtRelative(ProtoCore.DSASM.StackFrame.kFrameIndexClass).opdata;
VerifyWatch_Run(InjectionExecutive.callrLineNo, core.DebugProps.CurrentSymbolName, core, map, watchNestedMode, ci);
}
}
}
}
//isPrevBreakAtPop = false;
}
core.Cleanup();
}
public WatchTestFx()
{
var options = new ProtoCore.Options();
core = new ProtoCore.Core(options);
}
public Executive(ProtoCore.Core core)
: base(core)
{
}
public void SetLiveCore(ProtoCore.Core core)
{
liveRunnerCore = core;
}
public DependencyPass.DependencyTracker GetDemoTracker3(out ProtoCore.DSASM.SymbolTable symbols, string pathFilename, ProtoCore.Core core)
{
Associative.Scanner s = new Associative.Scanner(pathFilename);
Associative.Parser p = new Associative.Parser(s, core);
p.Parse();
CodeBlockNode code = p.codeblock as CodeBlockNode;
symbols = code.symbols;
DependencyTracker tempTracker = new DependencyTracker();
#if TEST_DIRECT
foreach (Node node in code.Body)
{
tempTracker.AllNodes.Add(node);
}
#else
Dictionary <string, List <Node> > names = new Dictionary <string, List <Node> >();
code.ConsolidateNames(ref (names));
tempTracker.GenerateDependencyGraph(code.Body);
#endif
return(tempTracker);
}
internal void SetLiveCore(ProtoCore.Core core)
{
liveRunnerCore = core;
}
/// <summary>
/// Initializes a new instance of the <see cref="LibraryServices"/> class.
/// </summary>
/// <param name="libraryManagementCore">Core which is used for parsing code and loading libraries</param>
/// <param name="pathManager">Instance of IPathManager containing neccessary Dynamo paths</param>
public LibraryServices(ProtoCore.Core libraryManagementCore, IPathManager pathManager)
: this(libraryManagementCore, pathManager, null)
{
}