public FLSetup(string testName, string kernelPath, string performance = "performance", Type[] checkPipeline = null,
bool useMultiThreading = false, int workSizeMultiplier = 2) : base(testName, performance)
{
KernelDatabase = new KernelDatabase(CLAPI.MainThread, kernelPath, DataVectorTypes.Uchar1);
InstructionSet = FLInstructionSet.CreateWithBuiltInTypes(KernelDatabase);
BufferCreator = BufferCreator.CreateWithBuiltInTypes();
CheckBuilder = null;
if (checkPipeline == null)
{
CheckBuilder = FLProgramCheckBuilder.CreateDefaultCheckBuilder(InstructionSet, BufferCreator);
}
else
{
CheckBuilder = new FLProgramCheckBuilder(InstructionSet, BufferCreator);
foreach (Type useCheck in checkPipeline)
{
CheckBuilder.AddProgramCheck((FLProgramCheck)Activator.CreateInstance(useCheck));
}
}
Parser = new FLParser(InstructionSet, BufferCreator,
new WorkItemRunnerSettings(useMultiThreading, workSizeMultiplier));
CheckBuilder.Attach(Parser, true);
Directory.CreateDirectory(RunResultPath);
Directory.CreateDirectory(DataOutputDirectory);
}
private List <SerializableExternalFLFunction> ParseScriptDefines(DefineStatement[] statements)
{
List <SerializableExternalFLFunction> ret = new List <SerializableExternalFLFunction>();
for (int i = 0; i < statements.Length; i++)
{
string name = statements[i].Name;
string relPath = FLParser.GetScriptPath(statements[i].SourceLine);
string p = relPath;
if (!IOManager.FileExists(p))
{
throw new FLInvalidDefineStatementException("Can not Find Script with path: " + p);
}
SerializableFLProgram ps = parser.Process(new FLParserInput(p, false));
ret.Add(
new SerializableExternalFLFunction(
name,
ps,
statements[i].Modifiers as FLExecutableElementModifiers
)
);
}
return(ret);
}
public FLDataContainer()
{
Instance = CLAPI.GetInstance();
InstructionSet = FLInstructionSet.CreateWithBuiltInTypes(Instance, "assets/kernel");
BufferCreator = BufferCreator.CreateWithBuiltInTypes();
Parser = new FLParser(InstructionSet, BufferCreator, WorkItemRunnerSettings.Default);
}
public static string RunParserInitBenchmark(string testAdd, int iterations,
string performanceFolder = "performance", bool useChecks = true, bool useMultiThreading = false,
int workSizeMultiplier = 2)
{
//FLSetup setup = new FLSetup("FL_ParserProcess_Performance"+ testAdd, "resources/kernel", performanceFolder,
// useChecks, useMultiThreading, workSizeMultiplier);
StringBuilder logOut = new StringBuilder($"Performance Tests: {DateTime.Now:HH:mm:ss}\n");
FLInstructionSet iset = null;
BufferCreator bc = null;
FLParser parser = null;
FLProgramCheckBuilder checkBuilder = null;
KernelDatabase db = new KernelDatabase(CLAPI.MainThread, "resources/kernel", DataVectorTypes.Uchar1);
string key = "ParserInitPerformance";
Logger.Log(LogType.Log, $"------------------------Run {key} Starting------------------------", 1);
PerformanceTester.PerformanceResult result = PerformanceTester.Tester.RunTest(key, iterations, null,
(int its) =>
{
iset = FLInstructionSet.CreateWithBuiltInTypes(db);
bc = BufferCreator.CreateWithBuiltInTypes();
checkBuilder = FLProgramCheckBuilder.CreateDefaultCheckBuilder(iset, bc);
parser = new FLParser(iset, bc);
}, null);
logOut.AppendLine("\t" + result);
Logger.Log(LogType.Log, $"------------------------Run {key} Finished------------------------", 1);
return(logOut.ToString());
}
public FLRunner(CLAPI instance, FLInstructionSet instructionSet, BufferCreator bufferCreator,
FLProgramCheckBuilder checkPipeline)
{
InstructionSet = instructionSet;
BufferCreator = bufferCreator;
Parser = new FLParser(InstructionSet, BufferCreator);
checkPipeline.Attach(Parser, true);
Instance = instance;
}
public FLDataContainer(
CLAPI instance, FLInstructionSet iset, BufferCreator creator, FLParser parser)
{
Instance = instance;
//KernelDB = db;
InstructionSet = iset;
BufferCreator = creator;
Parser = parser;
}
private List <StaticFunction> ParseFunctionTask(List <string> headers, int start, int count, List <string> source)
{
List <StaticFunction> ret = new List <StaticFunction>();
for (int i = start; i < start + count; i++)
{
ret.Add(new StaticFunction(headers[i], FLParser.GetFunctionBody(headers[i], source)));
}
return(ret);
}
private static FLDataContainer InitializeCLKernels(string kernelPath)
{
{
CLAPI instance = CLAPI.GetInstance();
Logger.Log(LogType.Log, "Discovering Files in Path: " + kernelPath, 1);
string[] files = IOManager.DirectoryExists(kernelPath)
? IOManager.GetFiles(kernelPath, "*.cl")
: new string[0];
if (files.Length == 0)
{
Logger.Log(LogType.Error, "Error: No Files found at path: " + kernelPath, 1);
}
KernelDatabase dataBase = new KernelDatabase(DataVectorTypes.Uchar1);
List <CLProgramBuildResult> results = new List <CLProgramBuildResult>();
bool throwEx = false;
int kernelCount = 0;
int fileCount = 0;
foreach (string file in files)
{
Logger.Log(
LogType.Log,
$"[{fileCount}/{files.Length}]Loading: {file} ({kernelCount})",
2
);
try
{
CLProgram prog = dataBase.AddProgram(instance, file, false, out CLProgramBuildResult res);
kernelCount += prog.ContainedKernels.Count;
throwEx |= !res;
results.Add(res);
}
catch (Exception e)
{
Logger.Log(LogType.Error, "ERROR: " + e.Message, 2);
}
fileCount++;
}
Logger.Log(LogType.Log, "Kernels Loaded: " + kernelCount, 1);
FLInstructionSet iset = FLInstructionSet.CreateWithBuiltInTypes(dataBase);
BufferCreator creator = BufferCreator.CreateWithBuiltInTypes();
FLParser parser = new FLParser(iset, creator, new WorkItemRunnerSettings(true, 2));
return(new FLDataContainer(instance, iset, creator, parser));
}
}
public FLScriptRunner(CLAPI instance, DataVectorTypes dataVectorTypes = DataVectorTypes.Uchar1,
string kernelFolder = "resources/kernel")
{
Db = new KernelDatabase(instance, kernelFolder, dataVectorTypes);
InstructionSet = FLInstructionSet.CreateWithBuiltInTypes(Db);
BufferCreator = BufferCreator.CreateWithBuiltInTypes();
ProgramChecks = FLProgramCheckBuilder.CreateDefaultCheckBuilder(InstructionSet, BufferCreator);
Parser = new FLParser(InstructionSet, BufferCreator);
ProgramChecks.Attach(Parser, true);
Instance = instance;
ProcessQueue = new Queue <FlScriptExecutionContext>();
}
public FLScriptRunner(CLAPI instance, KernelDatabase dataBase, BufferCreator creator,
FLInstructionSet instructionSet, FLProgramCheckBuilder checkBuilder, WorkItemRunnerSettings runnerSettings)
{
Db = dataBase;
InstructionSet = instructionSet;
BufferCreator = creator;
Parser = new FLParser(InstructionSet, BufferCreator, runnerSettings);
ProgramChecks = checkBuilder;
checkBuilder.Attach(Parser, true);
Instance = instance;
ProcessQueue = new Queue <FlScriptExecutionContext>();
}
protected override void InitializeScene()
{
creator = BufferCreator.CreateWithBuiltInTypes();
iset = FLInstructionSet.CreateWithBuiltInTypes(CLAPI.MainThread, "assets/kernel/");
checkPipeline = FLProgramCheckBuilder.CreateDefaultCheckBuilder(iset, creator);
parser = new FLParser(iset, creator);
checkPipeline.Attach(parser, true);
Add(DebugConsoleComponent.CreateConsole());
Matrix4 proj = Matrix4.CreatePerspectiveFieldOfView(
MathHelper.DegreesToRadians(75f), //Field of View Vertical
16f / 9f, //Aspect Ratio
0.1f, //Near Plane
1000f); //Far Plane
BasicCamera bc = new BasicCamera(proj, Vector3.Zero);
Add(bc); //Adding the BasicCamera(That is a gameobject under the hood) to the scene to receive events
SetCamera(bc); //Sets the Camera as the "active" camera that the scene will be rendered from.
GameObject box = new GameObject(-Vector3.UnitZ * 4, "Box"); //Creating a new Empty GameObject
LitMeshRendererComponent lmr = new LitMeshRendererComponent( //Creating a Renderer Component
DefaultFilepaths.DefaultLitShader, //The OpenGL Shader used(Unlit and Lit shaders are provided)
Prefabs.Cube, //The Mesh that is going to be used by the MeshRenderer
tex, //Diffuse Texture to put on the mesh
1); //Render Mask (UI = 1 << 30)
box.AddComponent(lmr); //Attaching the Renderer to the GameObject
box.AddComponent(new RotateSelfComponent()); //Adding a component that rotates the Object on the Y-Axis
Add(box); //Adding the Object to the Scene.
FLBuffer buffer =
new FLBuffer(TextureLoader.TextureToMemoryBuffer(CLAPI.MainThread, tex, "BufferForFLProgram"), 128,
128);
FLProgram program = parser.Process(new FLParserInput("assets/filter/red.fl")).Initialize(iset);
program.Run(CLAPI.MainThread, buffer, true);
FLBuffer result = program.GetActiveBuffer(false);
byte[] dat = CLAPI.ReadBuffer <byte>(CLAPI.MainThread, result.Buffer, (int)result.Buffer.Size);
//Create a texture from the output.
TextureLoader.Update(tex, dat, 128, 128);
result.Dispose();
}
public void OpenFL_Comments_Test()
{
TestSetup.SetupTestingSession();
string file =
"resources/filter/comments/test.fl";
FLParser parser = new FLParser();
Assembly asm = Assembly.GetAssembly(typeof(ASerializableBufferCreator));
parser.BufferCreator.AddBufferCreatorsInAssembly(asm);
SerializableFLProgram pr = parser.Process(new FLParserInput(file));
//FLFunction entryPoint = pr.EntryPoint; //Provoking an exception if main function is not found
}
public void OpenFL_DefineScriptFile_Wrong_Test()
{
TestSetup.SetupTestingSession();
string file = "resources/filter/defines/test_wrong_script_invalid_file.fl";
Assert.Catch <Byt3Exception>(() =>
{
FLParser parser = new FLParser();
Assembly asm = Assembly.GetAssembly(typeof(ASerializableBufferCreator));
parser.BufferCreator.AddBufferCreatorsInAssembly(asm);
SerializableFLProgram pr = parser.Process(new FLParserInput(file));
});
}
public override StaticInspectionResult Process(LoadSourceStageResult input)
{
string[] definedScripts = null;
string[] definedBuffers = null;
List <StaticFunction> functions = null;
Logger.Log(LogType.Log, "Statically Inspecting: " + input.Filename, 2);
Task <string[]> scriptTask = new Task <string[]>(() => FLParser.FindDefineScriptsStatements(input.Source));
Task <string[]> bufferTask = new Task <string[]>(() => FLParser.FindDefineStatements(input.Source));
if (parser.WorkItemRunnerSettings.UseMultithread)
{
scriptTask.Start();
bufferTask.Start();
}
else
{
scriptTask.RunSynchronously();
bufferTask.RunSynchronously();
}
string[] functionsHeaders = FLParser.FindFunctionHeaders(input.Source);
functions = WorkItemRunner.RunInWorkItems(functionsHeaders.ToList(),
(list, start, count) => ParseFunctionTask(list, start, count, input.Source),
parser.WorkItemRunnerSettings);
Task.WaitAll(scriptTask, bufferTask);
Logger.Log(LogType.Log, "Buffer And Script Task Finished.", 2);
definedScripts = scriptTask.Result;
definedBuffers = bufferTask.Result;
Logger.Log(LogType.Log, "Tasks Completed.", 2);
Logger.Log(LogType.Log, "Parsed Scripts: " + functions.Unpack(", "), 4);
return(new StaticInspectionResult(input.Filename, input.Source, functions, definedBuffers,
definedScripts));
}
public void OpenFL_WFCDefines_Wrong_Test()
{
TestSetup.SetupTestingSession();
string[] files = IOManager.GetFiles("resources/filter/defines/", "test_wrong_define_wfc_*.fl");
Assert.IsNotEmpty(files, "No Test FL Scripts found for " + nameof(OpenFL_WFCDefines_Wrong_Test));
foreach (string file in files)
{
Assert.Catch <AggregateException>(() =>
{
FLParser parser = new FLParser();
Assembly asm = Assembly.GetAssembly(typeof(ASerializableBufferCreator));
parser.BufferCreator.AddBufferCreatorsInAssembly(asm);
SerializableFLProgram pr = parser.Process(new FLParserInput(file));
});
}
}
public void OpenFL_DefineFile_Wrong_Test()
{
TestSetup.SetupTestingSession();
string file = "resources/filter/defines/test_wrong_define_invalid_file.fl";
Assert.Catch <Byt3Exception>(() =>
{
BufferCreator bc = new BufferCreator();
FLInstructionSet iset = new FLInstructionSet();
FLProgramCheckBuilder checkBuilder = new FLProgramCheckBuilder(iset, bc);
checkBuilder.AddProgramCheck(new FilePathValidator());
FLParser parser = new FLParser(iset, bc);
checkBuilder.Attach(parser, true);
Assembly asm = Assembly.GetAssembly(typeof(ASerializableBufferCreator));
parser.BufferCreator.AddBufferCreatorsInAssembly(asm);
SerializableFLProgram pr = parser.Process(new FLParserInput(file));
});
}
public void OpenFL_Defines_Test()
{
TestSetup.SetupTestingSession();
string file = "resources/filter/defines/test.fl";
FLParser parser = new FLParser();
Assembly asm = Assembly.GetAssembly(typeof(ASerializableBufferCreator));
parser.BufferCreator.AddBufferCreatorsInAssembly(asm);
SerializableFLProgram result = parser.Process(new FLParserInput(file));
Assert.True(result.DefinedBuffers.Count == 5);
Assert.True(result.DefinedBuffers.Count(x => x.Name == "in") == 1);
Assert.True(result.DefinedBuffers.Count(x => x.Name == "textureD") == 1);
Assert.True(result.DefinedBuffers.Count(x => x.Name == "textureC") == 1);
Assert.True(result.DefinedBuffers.Count(x => x.Name == "textureB") == 1);
Assert.True(result.DefinedBuffers.Count(x => x.Name == "textureA") == 1);
}
private void Build()
{
FLConsole.Settings.SetVerbosity();
string[] inputFiles = SetInputFilesCommand.InputFiles;
string[] outputFiles = SetOutputFilesCommand.OutputFiles;
BufferCreator creator = new BufferCreator();
FLConsole.Settings.BufferCreatorTypes.ForEach(x =>
creator.AddBufferCreator((ASerializableBufferCreator)Activator.CreateInstance(x)));
FLInstructionSet iset =
FLInstructionSet.CreateWithBuiltInTypes(CLAPI.MainThread, FLConsole.Settings.KernelFolder);
FLProgramCheckBuilder programCheckBuilder = new FLProgramCheckBuilder(iset, creator);
FLParser p = new FLParser(iset, creator,
new WorkItemRunnerSettings(FLConsole.Settings.MultiThread,
FLConsole.Settings.WorkSizeMultiplier));
programCheckBuilder.Attach(p, true);
Logger.Log(LogType.Log, $"Building {inputFiles.Length} Files", 1);
for (int i = 0; i < inputFiles.Length; i++)
{
string inp = inputFiles[i];
Logger.Log(LogType.Log, $"Building {inp}", 2);
string outp = outputFiles.Length > i
? outputFiles[i]
: $"./{Path.GetFileNameWithoutExtension(inp)}.flc";
SerializableFLProgram prog = p.Process(new FLParserInput(inp));
Stream dst = File.Create(outp);
FLSerializer.SaveProgram(dst, prog, iset, ExtraStepCommand.extras);
dst.Close();
Logger.Log(LogType.Log, $"Output: {outp}", 2);
}
Logger.Log(LogType.Log, $"Finished Building {inputFiles.Length} Files", 1);
}
private void Initialize()
{
CLAPI instance = CLAPI.GetInstance();
string path = FLScriptEditor.Settings.KernelPath;
StartupSequence.loaderForm.SetStatus("Discovering Files in Path: " + path);
string[] files = IOManager.DirectoryExists(path) ? IOManager.GetFiles(path, "*.cl") : new string[0];
if (files.Length == 0)
{
DialogResult res = StyledMessageBox.Show(
"Error",
"No Files found at path: " + path,
MessageBoxButtons.AbortRetryIgnore,
SystemIcons.Error
);
if (res == DialogResult.Retry)
{
Initialize();
return;
}
if (res == DialogResult.Abort)
{
StartupSequence.loaderForm.DialogResult = DialogResult.Abort;
StartupSequence.loaderForm.Close();
return;
}
if (res == DialogResult.Ignore)
{
StartupSequence.loaderForm.DialogResult = DialogResult.OK;
}
}
KernelDatabase dataBase = new KernelDatabase(DataVectorTypes.Uchar1);
List <CLProgramBuildResult> results = new List <CLProgramBuildResult>();
bool throwEx = false;
int kernelCount = 0;
int fileCount = 0;
if (FLScriptEditor.Settings.ExperimentalKernelLoading)
{
try
{
string source = TextProcessorAPI.PreprocessSource(files, new Dictionary <string, bool>());
CLProgram prog = dataBase.AddProgram(instance, source, "./", false, out CLProgramBuildResult res);
throwEx |= !res;
if (res)
{
kernelCount += prog.ContainedKernels.Count;
}
results.Add(res);
StartupSequence.loaderForm.SetStatus($"File Loaded(Kernels Loaded): ({kernelCount})");
}
catch (Exception e)
{
throw new SoftException(e);
}
}
else
{
foreach (string file in files)
{
StartupSequence.loaderForm.SetStatus(
$"[{fileCount}/{files.Length}]Loading: {file} ({kernelCount})"
);
try
{
CLProgram prog = dataBase.AddProgram(instance, file, false, out CLProgramBuildResult res);
kernelCount += prog.ContainedKernels.Count;
throwEx |= !res;
results.Add(res);
}
catch (Exception e)
{
StartupSequence.loaderForm.Log("ERROR: " + e.Message, Color.Red);
throw e; //Let the Exception Viewer Catch that
}
fileCount++;
}
}
StartupSequence.loaderForm.SetStatus("Loading Finished");
StartupSequence.loaderForm.Log("Loading Finished", Color.White);
StartupSequence.loaderForm.Log("Kernels Loaded: " + kernelCount, Color.White);
if (throwEx)
{
DialogResult res =
StyledMessageBox.Show(
"OpenCL Build Errors",
"There are errors in one or more OpenCL kernels. Do you want to open the OpenCL Build Excepion Viewer?",
MessageBoxButtons.YesNoCancel,
SystemIcons.Warning
);
if (res == DialogResult.Cancel)
{
StartupSequence.loaderForm.DialogResult = DialogResult.Abort;
StartupSequence.loaderForm.Close();
}
else if (res == DialogResult.Yes)
{
BuildExceptionViewer bvr = new BuildExceptionViewer(new CLBuildException(results));
if (bvr.ShowDialog() == DialogResult.Retry)
{
dataBase.Dispose();
Initialize();
}
}
}
FLInstructionSet iset = FLInstructionSet.CreateWithBuiltInTypes(dataBase);
BufferCreator creator = BufferCreator.CreateWithBuiltInTypes();
FLParser parser = new FLParser(iset, creator, new WorkItemRunnerSettings(true, 2));
StartupSequence.FlContainer = new FLDataContainer(instance, iset, creator, parser);
}
protected override void InitializeScene()
{
creator = BufferCreator.CreateWithBuiltInTypes();
iset = FLInstructionSet.CreateWithBuiltInTypes(CLAPI.MainThread, "assets/kernel/");
checkPipeline = FLProgramCheckBuilder.CreateDefaultCheckBuilder(iset, creator);
parser = new FLParser(iset, creator);
checkPipeline.Attach(parser, true);
Mesh plane = MeshLoader.FileToMesh("assets/models/plane.obj");
Texture texQuad = TextureLoader.ParameterToTexture(1024, 1024, "FLDisplayTextureQuad");
Texture texSphere = TextureLoader.ParameterToTexture(1024, 1024, "FLDisplayTextureSphere");
GameObject objSphere = new GameObject(new Vector3(1, 1, 0), "SphereDisplay");
LitMeshRendererComponent sphereLmr = new LitMeshRendererComponent(DefaultFilepaths.DefaultLitShader,
Prefabs.Sphere,
texSphere, 1);
objSphere.AddComponent(sphereLmr);
sphereLmr.Textures = new[]
{ sphereLmr.Textures[0], DefaultFilepaths.DefaultTexture };
objSphere.AddComponent(new RotatingComponent());
GameObject objQuad = new GameObject(new Vector3(-1, 1, 0), "QuadDisplay");
LitMeshRendererComponent quadLmr = new LitMeshRendererComponent(DefaultFilepaths.DefaultLitShader, plane,
texQuad, 1);
objQuad.AddComponent(quadLmr);
quadLmr.Textures = new[]
{ quadLmr.Textures[0], DefaultFilepaths.DefaultTexture };
objQuad.Rotate(new Vector3(1, 0, 0), MathHelper.DegreesToRadians(45));
GameObject sourceCube = new GameObject(new Vector3(0, 10, 10), "Light Source");
sourceCube.AddComponent(new LightComponent());
sourceCube.AddComponent(new RotateAroundComponent {
Slow = 0.15f
});
sourceCube.AddComponent(new LitMeshRendererComponent(DefaultFilepaths.DefaultLitShader, Prefabs.Cube,
TextureLoader.ColorToTexture(Color.White), 1));
GameObject uiText = new GameObject(new Vector3(0), "UIText");
uiText.AddComponent(new FlGeneratorComponent(new List <LitMeshRendererComponent>
{
sphereLmr, quadLmr
},
512,
512, true));
Add(sourceCube);
Add(uiText);
Add(DebugConsoleComponent.CreateConsole());
Add(objSphere);
Add(objQuad);
GameObject bgObj = new GameObject(Vector3.UnitY * -3, "BG")
{
Scale = new Vector3(25, 1, 25)
};
bgObj.AddComponent(new LitMeshRendererComponent(DefaultFilepaths.DefaultLitShader, Prefabs.Cube,
GenerateGroundTexture(), 1));
Add(bgObj);
BasicCamera mainCamera =
new BasicCamera(
Matrix4.CreatePerspectiveFieldOfView(MathHelper.DegreesToRadians(75f),
GameEngine.Instance.Width / (float)GameEngine.Instance.Height, 0.01f, 1000f), Vector3.Zero);
object mc = mainCamera;
EngineConfig.LoadConfig("assets/configs/camera_fldemo.xml", ref mc);
Add(mainCamera);
SetCamera(mainCamera);
GameObject camContainer = new GameObject("CamContainer");
BasicCamera inPicCam =
new BasicCamera(
Matrix4.CreatePerspectiveFieldOfView(MathHelper.DegreesToRadians(75f),
GameEngine.Instance.Width / (float)GameEngine.Instance.Height, 0.01f, 1000f), Vector3.Zero);
inPicCam.Rotate(new Vector3(1, 0, 0), MathHelper.DegreesToRadians(0));
inPicCam.Translate(new Vector3(0, 2, 4));
inPicCam.AddComponent(new RotateAroundComponent());
GameObject zeroPoint = new GameObject("Zero");
Add(zeroPoint);
LookAtComponent comp = new LookAtComponent();
comp.SetTarget(zeroPoint);
inPicCam.AddComponent(comp);
Add(inPicCam);
splitCam = new RenderTarget(inPicCam, 1, Color.FromArgb(0, 0, 0, 0))
{
MergeType = RenderTargetMergeType.Additive,
ViewPort = new Rectangle(0, 0, (int)(GameEngine.Instance.Width * 0.3f),
(int)(GameEngine.Instance.Height * 0.3f))
};
Add(camContainer);
GameEngine.Instance.AddRenderTarget(splitCam);
}
public ParseTreeStage(FLParser parserInstance)
{
parser = parserInstance;
}
public StaticInspectionStage(FLParser parserInstance)
{
parser = parserInstance;
}
public RemoveCommentStage(FLParser parserInstance)
{
parser = parserInstance;
}
public override StaticInspectionResult Process(LoadSourceStageResult input)
{
ImportOptions options = new ImportOptions();
Runner runner = new Runner();
runner._AddCommand(
SetSettingsCommand.CreateSettingsCommand(
"Import",
new[] { FLKeywords.SetParserOptionKey },
options
)
);
List <string> opts = FLParser.FindParserOptions(input.Source).ToList();
opts.Insert(0, FLKeywords.SetParserOptionKey);
runner._RunCommands(opts.ToArray());
if (options.OnlyAllowImport && input.MainFile)
{
throw new InvalidOperationException(
$"The Script {input.Filename} can not be loaded as Entry point. As the Option: Import.OnlyAllowImport is set to true in the script"
);
}
if (options.NoImport && !input.MainFile)
{
throw new InvalidOperationException(
$"The Script {input.Filename} can not be imported. As the Option: Import.NoImport is set to true in the script"
);
}
DefineStatement[] definedScripts = null;
DefineStatement[] definedBuffers = null;
List <StaticFunction> functions = null;
Logger.Log(LogType.Log, "Statically Inspecting: " + input.Filename, 1);
Task <DefineStatement[]> scriptTask =
new Task <DefineStatement[]>(() => FLParser.FindDefineScriptsStatements(input.Source));
Task <DefineStatement[]> bufferTask =
new Task <DefineStatement[]>(() => FLParser.FindDefineStatements(input.Source));
if (parser.WorkItemRunnerSettings.UseMultithread)
{
scriptTask.Start();
bufferTask.Start();
}
else
{
scriptTask.RunSynchronously();
bufferTask.RunSynchronously();
}
StaticFunctionHeader[] functionsHeaders = FLParser.FindFunctionHeaders(input.Source)
.Select(x => new StaticFunctionHeader(x)).ToArray();
functions = WorkItemRunner.RunInWorkItems(
functionsHeaders.ToList(),
(list, start, count) =>
ParseFunctionTask(list, start, count, input.Source),
parser.WorkItemRunnerSettings
);
Task.WaitAll(scriptTask, bufferTask);
Logger.Log(LogType.Log, "Buffer And Script Tasks Finished.", 1);
definedScripts = scriptTask.Result;
definedBuffers = bufferTask.Result;
Logger.Log(LogType.Log, "Tasks Completed.", 1);
Logger.Log(LogType.Log, "Parsed Scripts: " + functions.Unpack(", "), 4);
return(new StaticInspectionResult(
input.Filename,
input.Source,
functions,
definedBuffers,
definedScripts,
options,
input.AdditionalKernels
));
}
