public DefaultGenerators(Ioc ioc)
{
ExpressionConstant = new ExpressionConstantCodeGenerator(ioc);
GuidConstant = new GuidConstantCodeGenerator(ioc);
ResultConstant = new ResultConstantCodeGenerator(ioc);
ResultRegistration = new ResultRegistrationCodeGenerator(ioc);
Property = new PropertyCodeGenerator(ioc);
Enum = new EnumCodeGenerator(ioc);
ExplicitOffsetField = new FieldCodeGenerator(ioc, true);
AutoLayoutField = new FieldCodeGenerator(ioc, false);
Struct = new StructCodeGenerator(ioc);
NativeStruct = new NativeStructCodeGenerator(ioc);
NativeInvocation = new NativeInvocationCodeGenerator(ioc);
Callable = new CallableCodeGenerator(ioc);
Method = new MethodCodeGenerator(ioc);
Function = new FunctionCodeGenerator(ioc);
FunctionImport = new FunctionImportCodeGenerator(ioc);
Interface = new InterfaceCodeGenerator(ioc);
Group = new GroupCodeGenerator(ioc);
ShadowCallable = new ShadowCallbackGenerator(ioc);
ReverseCallableProlog = new ReverseCallablePrologCodeGenerator(ioc);
Vtbl = new VtblGenerator(ioc);
Marshalling = new MarshallingRegistry(ioc);
Config = ioc.GeneratorConfig;
}
internal static Dictionary <Guid, Type> GetDataTypes(IReadOnlyCollection <DataTypeDescriptor> dataTypeDescriptors)
{
var result = new Dictionary <Guid, Type>();
var toCompile = new List <DataTypeDescriptor>();
foreach (var dataTypeDescriptor in dataTypeDescriptors)
{
string typeFullName = dataTypeDescriptor.GetFullInterfaceName();
Type type = _LoadedDataTypes.FirstOrDefault(f => f.FullName == typeFullName);
if (type == null)
{
bool compilationNeeded;
type = InterfaceCodeManager.TryGetType(dataTypeDescriptor, false, out compilationNeeded);
if (compilationNeeded)
{
toCompile.Add(dataTypeDescriptor);
}
}
if (type != null)
{
result[dataTypeDescriptor.DataTypeId] = type;
}
}
if (toCompile.Any())
{
var codeGenerationBuilder = new CodeGenerationBuilder("DataTypeTypesManager:compiling missing interfaces");
foreach (var dataTypeDescriptor in toCompile)
{
InterfaceCodeGenerator.AddAssemblyReferences(codeGenerationBuilder, dataTypeDescriptor);
InterfaceCodeGenerator.AddInterfaceTypeCode(codeGenerationBuilder, dataTypeDescriptor);
}
var types = CodeGenerationManager.CompileRuntimeTempTypes(codeGenerationBuilder);
var typesMap = types.ToDictionary(type => type.FullName);
foreach (var dataTypeDescriptor in toCompile)
{
var type = typesMap[dataTypeDescriptor.GetFullInterfaceName()];
result[dataTypeDescriptor.DataTypeId] = type;
}
}
return(result);
}
private static CompatibilityCheckResult CheckAgainsAppCode(DataTypeDescriptor dataTypeDescriptorToTest, bool includeDataTypeDescriptor)
{
List <string> filesToCompile = GetAppCodeFiles().ToList();
if (filesToCompile.Count == 0)
{
return(new CompatibilityCheckResult());
}
var csCompiler = new CSharpCodeProvider();
List <Assembly> referencedAssemblies = new List <Assembly>();
var codeTypeDeclarations = new Dictionary <string, List <CodeTypeDeclaration> >();
foreach (var dataTypeDescriptor in DataMetaDataFacade.GeneratedTypeDataTypeDescriptors)
{
if (!includeDataTypeDescriptor && dataTypeDescriptor.DataTypeId == dataTypeDescriptorToTest.DataTypeId)
{
continue;
}
DataTypeDescriptor dataTypeDescriptorToUse = dataTypeDescriptor;
if (includeDataTypeDescriptor && dataTypeDescriptor.DataTypeId == dataTypeDescriptorToTest.DataTypeId)
{
dataTypeDescriptorToUse = dataTypeDescriptorToTest;
}
referencedAssemblies.AddRange(InterfaceCodeGenerator.GetReferencedAssemblies(dataTypeDescriptorToUse));
CodeTypeDeclaration codeTypeDeclaration = InterfaceCodeGenerator.CreateCodeTypeDeclaration(dataTypeDescriptorToUse);
List <CodeTypeDeclaration> declarations;
if (!codeTypeDeclarations.TryGetValue(dataTypeDescriptorToUse.Namespace, out declarations))
{
declarations = new List <CodeTypeDeclaration>();
codeTypeDeclarations.Add(dataTypeDescriptorToUse.Namespace, declarations);
}
declarations.Add(codeTypeDeclaration);
string tempFilePath = GetTempFileName(dataTypeDescriptorToUse);
filesToCompile.Add(tempFilePath);
using (FileStream file = File.Create(tempFilePath))
{
using (var sw = new StreamWriter(file))
{
var codeNamespace = new CodeNamespace(dataTypeDescriptorToUse.Namespace);
codeNamespace.Types.Add(codeTypeDeclaration);
csCompiler.GenerateCodeFromNamespace(codeNamespace, sw, new CodeGeneratorOptions());
}
var sb = new StringBuilder();
using (var sw = new StringWriter(sb))
{
csCompiler.GenerateCodeFromMember(codeTypeDeclaration, sw, new CodeGeneratorOptions());
}
}
}
filesToCompile.Sort();
var compilerParameters = new CompilerParameters
{
GenerateExecutable = false,
GenerateInMemory = true
};
compilerParameters.ReferencedAssemblies.AddRangeIfNotContained(referencedAssemblies.Select(f => f.Location).ToArray());
compilerParameters.ReferencedAssemblies.AddRangeIfNotContained(CodeGenerationManager.CompiledAssemblies.Select(f => f.Location).ToArray());
compilerParameters.AddLoadedAssemblies(false);
compilerParameters.AddAssemblyLocationsFromBin();
compilerParameters.AddCommonAssemblies();
compilerParameters.RemoveGeneratedAssemblies();
var codeCompileUnit = new CodeCompileUnit();
foreach (var kvp in codeTypeDeclarations)
{
var codeNamespace = new CodeNamespace(kvp.Key);
codeNamespace.Types.AddRange(kvp.Value.ToArray());
codeCompileUnit.Namespaces.Add(codeNamespace);
}
var compiler = new CSharpCodeProvider();
var compileResult = compiler.CompileAssemblyFromFile(compilerParameters, filesToCompile.ToArray());
if (compileResult.Errors.Count == 0)
{
return(new CompatibilityCheckResult());
}
// Checking for a missing assembly error, if it is present, that means that App_Code check isn't applicable due to circular reference
foreach (CompilerError error in compileResult.Errors)
{
if (error.ErrorNumber == "CS0012" && error.ErrorText.Contains("Composite.Generated"))
{
return(new CompatibilityCheckResult());
}
}
return(new CompatibilityCheckResult(compileResult));
}
