internal static FileBuilder Create(string content, Type typeUsing = null, Type[] typeNamespaces = null)
{
var addons = AddonManager.Create();
addons.AddAssembly(AddonManager.StepBroCoreAssembly, true);
addons.AddAssembly(typeof(System.DateTime).Assembly, false);
addons.AddAssembly(typeof(System.Math).Assembly, false);
addons.AddAssembly(typeof(System.Console).Assembly, false);
addons.AddAssembly(typeof(System.Linq.Enumerable).Assembly, false);
var file = new ScriptFile();
file.AddNamespaceUsing(-1, addons.Lookup(null, "System"));
file.AddNamespaceUsing(-1, addons.Lookup(null, "System.Linq"));
file.AddNamespaceUsing(-1, addons.Lookup(null, typeof(StepBro.Core.DataReport).Namespace));
if (typeUsing != null)
{
addons.AddAssembly(typeUsing.Assembly, false);
file.AddNamespaceUsing(-1, addons.Lookup(null, typeUsing.FullName));
}
if (typeNamespaces != null)
{
foreach (var u in typeNamespaces)
{
addons.AddAssembly(u.Assembly, false);
file.AddNamespaceUsing(-1, addons.Lookup(null, u.Namespace));
}
}
file.UpdateRootIdentifiers();
return(new FileBuilder(new AntlrInputStream(content), addons, file));
}
public void TestLoadTestModule()
{
IAddonManager addons = AddonManager.Create();
var testFile = GetTestModulePath();
addons.LoadAssembly(testFile, false);
var typeReference = addons.TryGetType(null, "TestModule.TestClassWithOnlyProperties");
Assert.IsNotNull(typeReference);
typeReference = addons.TryGetType(null, "TestModule.SubNamespace.Deep.VeryDeep.MuchDeeper.TestClassInDeepNamespace");
Assert.IsNotNull(typeReference);
typeReference = addons.TryGetType(null, "TestModule.SubNamespace.Deep.VeryDeep.MuchDeeper.TestClassInDeepNamespace.SubClass");
Assert.IsNotNull(typeReference);
var usings = new UsingData[] { new UsingData(-1, addons.Lookup(null, "TestModule")) };
typeReference = addons.TryGetType(usings, "TestClassWithOnlyProperties");
Assert.IsNotNull(typeReference);
Assert.AreEqual("TestClassWithOnlyProperties", typeReference.Name);
typeReference = addons.TryGetType(usings, "SubNamespace.Deep.VeryDeep.MuchDeeper.TestClassInDeepNamespace.SubClass");
Assert.IsNotNull(typeReference);
Assert.AreEqual("SubClass", typeReference.Name);
usings = new UsingData[] { new UsingData(-1, addons.Lookup(null, "TestModule")), new UsingData(-1, addons.Lookup(null, "TestModule.SubNamespace.Deep")) };
typeReference = addons.TryGetType(usings, "VeryDeep.MuchDeeper.TestClassInDeepNamespace.SubClass");
Assert.IsNotNull(typeReference);
Assert.AreEqual("SubClass", typeReference.Name);
//var moduleClass = typeReference as ICodeModuleClass;
//Assert.IsNotNull(moduleClass);
}
internal static ScriptFile ParseFile(IAddonManager addonManager, string content)
{
if (addonManager == null)
{
addonManager = AddonManager.Create();
addonManager.AddAssembly(typeof(Math).Assembly, false);
addonManager.AddAssembly(typeof(Enumerable).Assembly, false);
}
addonManager.AddAssembly(AddonManager.StepBroCoreAssembly, true); // Add StepBro.Core always.
ITokenSource lexer = new Grammar.StepBroLexer(new AntlrInputStream(content));
ITokenStream tokens = new CommonTokenStream(lexer);
var parser = new SBP(tokens);
var file = new ScriptFile();
parser.RemoveErrorListeners();
parser.AddErrorListener(file.Errors as ErrorCollector);
parser.BuildParseTree = true;
var listener = new StepBroListener(file.Errors as ErrorCollector, addonManager, file);
var context = parser.compilationUnit();
var walker = new ParseTreeWalker();
walker.Walk(listener, context);
if (file.Errors.ErrorCount > 0)
{
throw new Exception("PARSING ERRORS: " + file.Errors[0].ToString());
}
//file?.InitializeFileVariables();
return(file);
}
internal static Tuple <Stack <SBExpressionData>, IErrorCollector> ParseSimpleArguments(string expression)
{
var addons = AddonManager.Create();
addons.AddAssembly(AddonManager.StepBroCoreAssembly, true);
addons.AddAssembly(typeof(System.Math).Assembly, false);
addons.AddAssembly(typeof(System.Linq.Enumerable).Assembly, false);
//if (module != null) addons.AddAssembly(module, false);
var file = new ScriptFile();
file.AddNamespaceUsing(-1, addons.Lookup(null, "System"));
file.AddNamespaceUsing(-1, addons.Lookup(null, "System.Linq"));
//foreach (var u in usings)
//{
// file.AddNamespaceUsing(addons.Lookup(null, u.FullName));
//}
var builder = new FileBuilder(new AntlrInputStream(expression), addons, file);
builder.Listener.PrepareForExpressionParsing("StepBroFileBuilder.ParseExpression");
var context = builder.Parser.arguments();
var walker = new ParseTreeWalker();
walker.Walk(builder.Listener, context);
return(new Tuple <Stack <SBExpressionData>, IErrorCollector>(builder.Listener.GetArguments(), builder.Errors));
}
internal static FileBuilder ParseProcedure(
IAddonManager addonManager,
string[] usings,
Type usingType,
params string[] content)
{
if (addonManager == null)
{
addonManager = AddonManager.Create();
addonManager.AddAssembly(typeof(Math).Assembly, false);
addonManager.AddAssembly(typeof(Enumerable).Assembly, false);
}
addonManager.AddAssembly(AddonManager.StepBroCoreAssembly, true); // Add StepBro.Core always.
if (usingType != null)
{
addonManager.AddAssembly(usingType.Assembly, false);
}
var contentBuilder = new StringBuilder();
foreach (var s in content)
{
contentBuilder.AppendLine(s);
}
var file = new ScriptFile();
file.AddNamespaceUsing(-1, addonManager.Lookup(null, "System"));
file.AddNamespaceUsing(-1, addonManager.Lookup(null, "System.Linq"));
file.AddNamespaceUsing(-1, addonManager.Lookup(null, typeof(StepBro.Core.DataReport).Namespace));
if (usings != null)
{
foreach (var u in usings)
{
file.AddNamespaceUsing(-1, addonManager.Lookup(null, u));
}
}
if (usingType != null)
{
file.AddNamespaceUsing(-1, addonManager.Lookup(null, usingType.Namespace));
}
var builder = new FileBuilder(new AntlrInputStream(contentBuilder.ToString()), addonManager, file);
builder.Listener.PrepareForExpressionParsing("StepBroFileBuilder.ParseExpression");
var context = builder.Parser.procedureDeclaration();
var walker = new ParseTreeWalker();
walker.Walk(builder.Listener, context);
if (file.Errors.ErrorCount > 0)
{
throw new Exception("PARSING ERRORS");
}
return(builder);
}
[Ignore] // Enable again when some extension methods actually are added.
public void TestExtensionMethods()
{
var usings = new string[] { "StepBro.Core.Execution" };
IAddonManager addons = AddonManager.Create();
addons.AddAssembly(AddonManager.StepBroCoreAssembly, false);
var methods = addons.ListExtensionMethods(
typeof(IProcedureReference)).Where(mi => mi.Name == "DynamicInvoke").ToList();
Assert.AreEqual(1, methods.Count);
Assert.AreEqual("DynamicInvoke", methods[0].Name);
}
public void TestPeakCANModuleLoad()
{
IAddonManager addons = AddonManager.Create();
var baseDir = GetBasePath();
var canFile = System.IO.Path.Combine(baseDir, "modules\\StepBro.CAN.dll");
addons.LoadAssembly(canFile, true);
var pcanFile = System.IO.Path.Combine(baseDir, "modules\\StepBro.PeakCANPlugin.dll");
addons.LoadAssembly(pcanFile, true);
}
public void TestExtensionMethodBrowsing()
{
var usings = new string[] { "System", "System.Linq" };
IAddonManager addons = AddonManager.Create();
addons.AddAssembly(typeof(System.Linq.Enumerable).Assembly, false);
var methods = new List <System.Reflection.MethodInfo>(
addons.ListExtensionMethods(
typeof(IEnumerable <int>)).Where(mi => mi.Name == "Select"));
Assert.IsTrue(methods.Select(mi => mi.Name).Contains("Select"));
methods = new List <System.Reflection.MethodInfo>(
addons.ListExtensionMethods(
typeof(List <int>)).Where(mi => mi.Name == "Select"));
Assert.IsTrue(methods.Select(mi => mi.Name).Contains("Select"));
}
public static FileBuilder Parse <T>(
string returnValueExpression = "0",
string statements = "",
bool varGeneration = true,
bool varDummyClass = false)
{
string typeName = "";
if (typeof(T) == typeof(long))
{
typeName = "int";
}
else if (typeof(T) == typeof(double))
{
typeName = "decimal";
}
else if (typeof(T) == typeof(bool))
{
typeName = "bool";
}
else if (typeof(T) == typeof(string))
{
typeName = "string";
}
else if (typeof(T) == typeof(TimeSpan))
{
typeName = "timespan";
}
else if (typeof(T) == typeof(DateTime))
{
typeName = "datetime";
}
else if (typeof(T) == typeof(Verdict))
{
typeName = "verdict";
}
else if (typeof(T) == typeof(DummyDataClass))
{
typeName = "DummyDataClass";
}
else if (typeof(T) == typeof(DataReport))
{
typeName = "DataReport";
}
else
{
throw new NotImplementedException();
}
StringBuilder source = new StringBuilder();
source.AppendLine(typeName + " ExpressionProcedure(){");
if (varGeneration || varDummyClass)
{
AddLocalVariables(source, varDummyClass);
}
source.AppendLine(statements);
source.AppendLine(typeName + " result = " + returnValueExpression + ";");
source.AppendLine("return result;");
source.AppendLine("}");
IAddonManager addons = AddonManager.Create();
addons.AddAssembly(typeof(Enumerable).Assembly, false);
addons.AddAssembly(typeof(ExpressionParser).Assembly, false);
return(FileBuilder.ParseProcedure(
addons,
new string[] { typeof(DataReport).Namespace, typeof(DummyClass).FullName, typeof(DummyClass).Namespace },
null,
source.ToString()));
}
