public CodegenExpression Make(
CodegenMethod parent,
ModuleExpressionDeclaredInitializeSymbol symbols,
CodegenClassScope classScope)
{
var method = parent.MakeChild(typeof(ExpressionDeclItem), GetType(), classScope);
method.Block
.DeclareVar<byte[]>(
"bytes",
Constant(OptionalSodaBytes.Invoke()));
var supplierLambda = new CodegenExpressionLambda(method.Block);
supplierLambda.Block.BlockReturn(Ref("bytes"));
var supplierSodaBytes = NewInstance<Supplier<byte[]>>(supplierLambda);
method.Block
.DeclareVar<ExpressionDeclItem>(
"item",
NewInstance<ExpressionDeclItem>(
Constant(Name),
Constant(ParametersNames),
Constant(IsAlias)))
.SetProperty(Ref("item"), "OptionalSodaBytes", supplierSodaBytes)
.SetProperty(Ref("item"), "ModuleName", Constant(ModuleName))
.SetProperty(Ref("item"), "Visibility", Constant(Visibility))
.MethodReturn(Ref("item"));
return LocalMethod(method);
}
private static CodegenMethod RegisterExprDeclaredCodegen(
KeyValuePair<string, ExpressionDeclItem> expression,
CodegenMethod parent,
CodegenClassScope classScope,
ModuleExpressionDeclaredInitializeSymbol symbols)
{
var method = parent.MakeChild(typeof(void), typeof(EPCompilerImpl), classScope);
var item = expression.Value;
var bytes = SerializerUtil.ObjectToByteArr(item.OptionalSoda);
item.OptionalSodaBytes = () => bytes;
method.Block
.DeclareVar<ExpressionDeclItem>("detail", expression.Value.Make(method, symbols, classScope))
.Expression(
ExprDotMethodChain(symbols.GetAddInitSvc(method))
.Get(EPModuleExprDeclaredInitServicesConstants.GETEXPRDECLAREDCOLLECTOR)
.Add("RegisterExprDeclared", Constant(expression.Key), Ref("detail")));
return method;
}
private static string CompileModule(
string optionalModuleName,
IDictionary<ModuleProperty, object> moduleProperties,
IList<string> statementClassNames,
string moduleIdentPostfix,
ModuleCompileTimeServices compileTimeServices,
out Assembly assembly)
{
// write code to create an implementation of StatementResource
var statementFieldsClassName = CodeGenerationIDGenerator.GenerateClassNameSimple(
typeof(StatementFields),
moduleIdentPostfix);
var namespaceScope = new CodegenNamespaceScope(
compileTimeServices.Namespace,
statementFieldsClassName,
compileTimeServices.IsInstrumented());
var moduleClassName = CodeGenerationIDGenerator.GenerateClassNameSimple(
typeof(ModuleProvider),
moduleIdentPostfix);
var classScope = new CodegenClassScope(true, namespaceScope, moduleClassName);
var methods = new CodegenClassMethods();
var properties = new CodegenClassProperties();
// provide module name
var moduleNameProp = CodegenProperty.MakePropertyNode(
typeof(string),
typeof(EPCompilerImpl),
CodegenSymbolProviderEmpty.INSTANCE,
classScope);
moduleNameProp.GetterBlock.BlockReturn(Constant(optionalModuleName));
// provide module properties
var modulePropertiesProp = CodegenProperty.MakePropertyNode(
typeof(IDictionary<ModuleProperty, object>),
typeof(EPCompilerImpl),
CodegenSymbolProviderEmpty.INSTANCE,
classScope);
MakeModuleProperties(moduleProperties, modulePropertiesProp);
// provide module dependencies
var moduleDependenciesProp = CodegenProperty.MakePropertyNode(
typeof(ModuleDependenciesRuntime),
typeof(EPCompilerImpl),
CodegenSymbolProviderEmpty.INSTANCE,
classScope);
compileTimeServices.ModuleDependencies.Inject(moduleDependenciesProp.GetterBlock);
// register types
var initializeEventTypesMethod = MakeInitEventTypes(classScope, compileTimeServices);
// register named windows
var symbolsNamedWindowInit = new ModuleNamedWindowInitializeSymbol();
var initializeNamedWindowsMethod = CodegenMethod
.MakeMethod(typeof(void), typeof(EPCompilerImpl), symbolsNamedWindowInit, classScope)
.AddParam(
typeof(EPModuleNamedWindowInitServices),
ModuleNamedWindowInitializeSymbol.REF_INITSVC.Ref);
foreach (var namedWindow in compileTimeServices.NamedWindowCompileTimeRegistry.NamedWindows) {
var addNamedWindow = RegisterNamedWindowCodegen(
namedWindow,
initializeNamedWindowsMethod,
classScope,
symbolsNamedWindowInit);
initializeNamedWindowsMethod.Block.Expression(LocalMethod(addNamedWindow));
}
// register tables
var symbolsTableInit = new ModuleTableInitializeSymbol();
var initializeTablesMethod = CodegenMethod
.MakeMethod(typeof(void), typeof(EPCompilerImpl), symbolsTableInit, classScope)
.AddParam(typeof(EPModuleTableInitServices), ModuleTableInitializeSymbol.REF_INITSVC.Ref);
foreach (var table in compileTimeServices.TableCompileTimeRegistry.Tables) {
var addTable = RegisterTableCodegen(table, initializeTablesMethod, classScope, symbolsTableInit);
initializeTablesMethod.Block.Expression(LocalMethod(addTable));
}
// register indexes
var symbolsIndexInit = new ModuleIndexesInitializeSymbol();
var initializeIndexesMethod = CodegenMethod
.MakeMethod(typeof(void), typeof(EPCompilerImpl), symbolsIndexInit, classScope)
.AddParam(typeof(EPModuleIndexInitServices), EPModuleIndexInitServicesConstants.REF.Ref);
foreach (KeyValuePair<IndexCompileTimeKey, IndexDetailForge> index in compileTimeServices
.IndexCompileTimeRegistry.Indexes) {
var addIndex = RegisterIndexCodegen(index, initializeIndexesMethod, classScope, symbolsIndexInit);
initializeIndexesMethod.Block.Expression(LocalMethod(addIndex));
}
// register contexts
var symbolsContextInit = new ModuleContextInitializeSymbol();
var initializeContextsMethod = CodegenMethod
.MakeMethod(typeof(void), typeof(EPCompilerImpl), symbolsContextInit, classScope)
.AddParam(
typeof(EPModuleContextInitServices),
ModuleContextInitializeSymbol.REF_INITSVC.Ref);
foreach (var context in compileTimeServices.ContextCompileTimeRegistry.Contexts) {
var addContext = RegisterContextCodegen(
context,
initializeContextsMethod,
classScope,
symbolsContextInit);
initializeContextsMethod.Block.Expression(LocalMethod(addContext));
}
// register variables
var symbolsVariablesInit = new ModuleVariableInitializeSymbol();
var initializeVariablesMethod = CodegenMethod
.MakeMethod(typeof(void), typeof(EPCompilerImpl), symbolsVariablesInit, classScope)
.AddParam(
typeof(EPModuleVariableInitServices),
ModuleVariableInitializeSymbol.REF_INITSVC.Ref);
foreach (var variable in compileTimeServices.VariableCompileTimeRegistry.Variables) {
var addVariable = RegisterVariableCodegen(
variable,
initializeVariablesMethod,
classScope,
symbolsVariablesInit);
initializeVariablesMethod.Block.Expression(LocalMethod(addVariable));
}
// register expressions
var symbolsExprDeclaredInit = new ModuleExpressionDeclaredInitializeSymbol();
var initializeExprDeclaredMethod = CodegenMethod
.MakeMethod(typeof(void), typeof(EPCompilerImpl), symbolsExprDeclaredInit, classScope)
.AddParam(
typeof(EPModuleExprDeclaredInitServices),
ModuleExpressionDeclaredInitializeSymbol.REF_INITSVC.Ref);
foreach (var expression in compileTimeServices.ExprDeclaredCompileTimeRegistry.Expressions) {
var addExpression = RegisterExprDeclaredCodegen(
expression,
initializeExprDeclaredMethod,
classScope,
symbolsExprDeclaredInit);
initializeExprDeclaredMethod.Block.Expression(LocalMethod(addExpression));
}
// register scripts
var symbolsScriptInit = new ModuleScriptInitializeSymbol();
var initializeScriptsMethod = CodegenMethod
.MakeMethod(typeof(void), typeof(EPCompilerImpl), symbolsScriptInit, classScope)
.AddParam(typeof(EPModuleScriptInitServices), ModuleScriptInitializeSymbol.REF_INITSVC.Ref);
foreach (var expression in compileTimeServices.ScriptCompileTimeRegistry.Scripts) {
var addScript = RegisterScriptCodegen(
expression,
initializeScriptsMethod,
classScope,
symbolsScriptInit);
initializeScriptsMethod.Block.Expression(LocalMethod(addScript));
}
// register provided classes
var symbolsClassProvidedInit = new ModuleClassProvidedInitializeSymbol();
var initializeClassProvidedMethod = CodegenMethod
.MakeParentNode(typeof(void), typeof(EPCompilerImpl), symbolsClassProvidedInit, classScope)
.AddParam(typeof(EPModuleClassProvidedInitServices), ModuleClassProvidedInitializeSymbol.REF_INITSVC.Ref);
foreach (var currClazz in compileTimeServices.ClassProvidedCompileTimeRegistry.Classes) {
var addClassProvided = RegisterClassProvidedCodegen(
currClazz,
initializeClassProvidedMethod,
classScope,
symbolsClassProvidedInit);
initializeClassProvidedMethod.Block.Expression(LocalMethod(addClassProvided));
}
// instantiate factories for statements
var statementsProp = CodegenProperty.MakePropertyNode(
typeof(IList<StatementProvider>),
typeof(EPCompilerImpl),
CodegenSymbolProviderEmpty.INSTANCE,
classScope);
statementsProp.GetterBlock.DeclareVar<IList<StatementProvider>>(
"statements",
NewInstance(typeof(List<StatementProvider>), Constant(statementClassNames.Count)));
foreach (var statementClassName in statementClassNames) {
statementsProp.GetterBlock.ExprDotMethod(
Ref("statements"),
"Add",
NewInstanceInner(statementClassName));
}
statementsProp.GetterBlock.BlockReturn(Ref("statements"));
// build stack
CodegenStackGenerator.RecursiveBuildStack(
moduleNameProp,
"ModuleName",
methods,
properties);
CodegenStackGenerator.RecursiveBuildStack(
modulePropertiesProp,
"ModuleProperties",
methods,
properties);
CodegenStackGenerator.RecursiveBuildStack(
moduleDependenciesProp,
"ModuleDependencies",
methods,
properties);
CodegenStackGenerator.RecursiveBuildStack(
initializeEventTypesMethod,
"InitializeEventTypes",
methods,
properties);
CodegenStackGenerator.RecursiveBuildStack(
initializeNamedWindowsMethod,
"InitializeNamedWindows",
methods,
properties);
CodegenStackGenerator.RecursiveBuildStack(
initializeTablesMethod,
"InitializeTables",
methods,
properties);
CodegenStackGenerator.RecursiveBuildStack(
initializeIndexesMethod,
"InitializeIndexes",
methods,
properties);
CodegenStackGenerator.RecursiveBuildStack(
initializeContextsMethod,
"InitializeContexts",
methods,
properties);
CodegenStackGenerator.RecursiveBuildStack(
initializeVariablesMethod,
"InitializeVariables",
methods,
properties);
CodegenStackGenerator.RecursiveBuildStack(
initializeExprDeclaredMethod,
"InitializeExprDeclareds",
methods,
properties);
CodegenStackGenerator.RecursiveBuildStack(
initializeScriptsMethod,
"InitializeScripts",
methods,
properties);
CodegenStackGenerator.RecursiveBuildStack(
initializeClassProvidedMethod,
"InitializeClassProvided",
methods,
properties);
CodegenStackGenerator.RecursiveBuildStack(
statementsProp,
"Statements",
methods,
properties);
var clazz = new CodegenClass(
CodegenClassType.MODULEPROVIDER,
typeof(ModuleProvider),
moduleClassName,
classScope,
new EmptyList<CodegenTypedParam>(),
null,
methods,
properties,
new EmptyList<CodegenInnerClass>());
var container = compileTimeServices.Container;
var compiler = container
.RoslynCompiler()
.WithCodeLogging(compileTimeServices.Configuration.Compiler.Logging.IsEnableCode)
.WithCodeAuditDirectory(compileTimeServices.Configuration.Compiler.Logging.AuditDirectory)
.WithCodegenClasses(new[] {clazz});
assembly = compiler.Compile();
return CodeGenerationIDGenerator.GenerateClassNameWithNamespace(
compileTimeServices.Namespace,
typeof(ModuleProvider),
moduleIdentPostfix);
}
