public IDictionary <string, string> Generate(CodeGenerationInfo generationInfo)
{
Dictionary <string, string> codes = new Dictionary <string, string>();
CodeDomProvider codeDomProvider = new CodeDom.NativeCCodeProvider();
CodeGeneratorOptions options = new CodeGeneratorOptions();
options.BlankLinesBetweenMembers = generationInfo.BlankLinesBetweenMembers;
options.BracingStyle = "C";
options.ElseOnClosing = false;
options.IndentString = IndentedTextWriter.DefaultTabString;
options["CustomGeneratorOptionStringExampleID"] = "BuildFlags: /A /B /C /D /E";
ColumnInfoExtensions.TypeNamespace = generationInfo.Namespace;
var cremaTypes = GenerateTypes(codeDomProvider, options, generationInfo);
var cremaTables = GenerateTables(codeDomProvider, options, generationInfo);
string cremaTypesHeader, cremaTypesCpp;
string cremaTablesHeader, cremaTablesCpp;
SplitCode(cremaTypes, "crema_datatypes.h", out cremaTypesHeader, out cremaTypesCpp);
SplitCode(cremaTables, "crema_tables.h", out cremaTablesHeader, out cremaTablesCpp);
codes.Add("crema_datatypes.h", cremaTypesHeader);
codes.Add("crema_datatypes.cpp", cremaTypesCpp);
codes.Add("crema_tables.h", cremaTablesHeader);
codes.Add("crema_tables.cpp", cremaTablesCpp);
return(codes);
}
public static void Create(CodeNamespace codeNamespace, CodeGenerationInfo generationInfo)
{
CreateCremaRow(codeNamespace);
CreateCremaTable(codeNamespace);
CreateCremaData(codeNamespace);
CremaTypeEnumCreator.CreateTypes(codeNamespace, generationInfo);
CreateTables(codeNamespace, generationInfo);
}
public static void CreateTables(CodeNamespace codeNamespace, CodeGenerationInfo generationInfo)
{
foreach (var item in generationInfo.GetTables())
{
CreateTable(codeNamespace, item, generationInfo);
}
CreateDataSet(codeNamespace, generationInfo);
}
public void Generate(string outputPath, GenerationSet metaData, CodeGenerationSettings settings)
{
var generationInfo = new CodeGenerationInfo(metaData, settings);
var codes = this.Generate(generationInfo);
foreach (var item in codes)
{
string codePath = FileUtility.Prepare(outputPath, item.Key);
using (StreamWriter sw = new StreamWriter(codePath, false, Encoding.UTF8))
{
sw.WriteLine(item.Value);
this.PrintResult(codePath);
}
}
}
public static void CreateDataSet(CodeNamespace codeNamespace, CodeGenerationInfo generationInfo)
{
var classType = new CodeTypeDeclaration();
codeNamespace.Types.Add(classType);
classType.Attributes = MemberAttributes.Private;
classType.Name = generationInfo.ClassName;
classType.IsClass = true;
classType.TypeAttributes |= System.Reflection.TypeAttributes.Sealed;
classType.BaseTypes.Add("CremaData");
CreateDataSetNameField(classType);
CreateDataSetRevisionField(classType);
CreateDataSetFields(classType, generationInfo.GetTables(true));
CreateDataSetMethodCreateFromFile(classType, generationInfo);
//CreateDataSetMethodCreateFromDataSet(classType, generationInfo);
CreateDataSetMethodReadFromFile(classType, generationInfo);
}
public static void Create(CodeNamespace codeNamespace, TableInfo tableInfo, CodeGenerationInfo generationInfo)
{
var classType = new CodeTypeDeclaration();
codeNamespace.Types.Add(classType);
classType.IsStruct = true;
classType.Name = string.Join("_", "row", tableInfo.Name.Replace(".", "_"));
CreateColumnFields(classType, tableInfo, generationInfo);
CreateInitializeMethod(classType, tableInfo, generationInfo);
//CreateTableField(classType, tableInfo);
//CreateChildFields(classType, tableInfo, generationInfo);
//CreateStaticChildEmptyFields(classType, tableInfo, generationInfo);
//CreateParentField(classType, tableInfo);
//CreateConstructor(classType, tableInfo, generationInfo);
//CreateColumnProperties(classType, tableInfo, generationInfo);
//CreateSetChildsMethod(classType, tableInfo, generationInfo);
//CreateTableProperty(classType, tableInfo);
//CreateChildProperties(classType, tableInfo, generationInfo);
}
private static void CreateSetChildsMethod(CodeTypeDeclaration classType, TableInfo tableInfo, CodeGenerationInfo generationInfo)
{
foreach (var item in generationInfo.GetChilds(tableInfo))
{
var cmm = new CodeMemberMethod();
cmm.Attributes = MemberAttributes.FamilyAndAssembly | MemberAttributes.Static;
cmm.Name = tableInfo.TableName + "Set" + item.TableName;
cmm.Parameters.Add(tableInfo.GetRowCodeType(CodeType.Pointer), "target");
var arrayType = new CodeTypeReference(item.GetRowCodeType(CodeType.Pointer), 1);
arrayType.SetCodeType(CodeType.Const | CodeType.Reference);
cmm.Parameters.Add(arrayType, "childs");
{
var methodRefExp = new CodeMethodReferenceExpression(null, "SetParent");
//methodRefExp.TypeArguments.Add(tableInfo.GetRowCodeType());
//methodRefExp.TypeArguments.Add(item.GetRowCodeType());
var methodInvokeExp = new CodeMethodInvokeExpression(methodRefExp, new CodeVariableReferenceExpression("target"), new CodeVariableReferenceExpression("childs"));
cmm.Statements.AddExpression(methodInvokeExp);
}
{
var target = new CodeVariablePointerExpression("target");
var childs = new CodeVariableReferenceExpression("childs");
var targetField = item.GetFieldExpression(target);
var targetInstance = new CodeObjectCreateExpression(item.GetCodeType(CodeType.None), childs);
cmm.Statements.AddAssign(targetField, targetInstance);
}
classType.Members.Add(cmm);
}
}
private static void CreateDataSetMethodReadFromFile(CodeTypeDeclaration classType, CodeGenerationInfo generationInfo)
{
var cmm = new CodeMemberMethod
{
Attributes = MemberAttributes.Family,
Name = "readFromFile"
};
cmm.Parameters.Add(typeof(string), "filename");
cmm.Parameters.Add(typeof(bool), "verifyRevision");
classType.Members.Add(cmm);
}
private static void CreateDataSetMethodCreateFromFile(CodeTypeDeclaration classType, CodeGenerationInfo generationInfo)
{
var cmm = new CodeMemberMethod
{
Attributes = MemberAttributes.Public | MemberAttributes.Static,
Name = "createFromFile"
};
cmm.Parameters.Add(typeof(string), "filename");
cmm.Parameters.Add(typeof(bool), "verifyRevision");
cmm.ReturnType = new CodeTypeReference(generationInfo.ClassName);
classType.Members.Add(cmm);
}
private static void CreateTableFields(CodeTypeDeclaration classType, TableInfo tableInfo, CodeGenerationInfo generationInfo)
{
foreach (var item in generationInfo.GetChilds(tableInfo))
{
var cmf = new CodeMemberField
{
Attributes = MemberAttributes.Public,
Name = item.GetPropertyName(),
Type = item.GetCodeType()
};
classType.Members.Add(cmf);
}
}
public static void CreateRowDecl(CodeNamespace codeNamespace, TableInfo tableInfo, CodeGenerationInfo generationInfo)
{
var classType = new CodeTypeDeclaration
{
Attributes = MemberAttributes.Public | MemberAttributes.Abstract,
Name = tableInfo.GetRowClassName(),
IsClass = true
};
classType.TypeAttributes |= System.Reflection.TypeAttributes.Sealed;
classType.BaseTypes.Add("CremaRow");
CreateTableField(classType, tableInfo);
CreateRowFieldsDecl(classType, tableInfo);
CreateChildFields(classType, tableInfo, generationInfo);
CreateParentField(classType, tableInfo);
codeNamespace.Types.Add(classType);
}
private static void CreateStaticChildEmptyFields(CodeTypeDeclaration classType, TableInfo tableInfo, CodeGenerationInfo generationInfo)
{
foreach (var item in generationInfo.GetChilds(tableInfo))
{
var cmf = new CodeMemberField();
cmf.Attributes = MemberAttributes.Private | MemberAttributes.Static;
cmf.Name = item.GetFieldName() + "Empty";
cmf.Type = item.GetCodeType(CodeType.None);
//cmf.InitExpression = new CodeObjectCreateExpression(item.GetCodeType(CodeType.None));
classType.Members.Add(cmf);
}
}
void GenerateCode(JSFunctionCode funcCode, ILGen.BaseILGenerator ilGen, bool enableSpeculation)
{
var cgInfo = new CodeGenerationInfo(this, funcCode, ilGen);
///This is where we are giong to make different decistions aboud different Phases and passes
if (JSRuntime.Instance.Configuration.EnableLightCompiler)
{
CodeGeneratorLight.Execute(cgInfo);
}
else
{
if (JSRuntime.Instance.Configuration.EnableFunctionInlining)
{
FunctionInliner.Execute(cgInfo);
}
if (EnableTypeInference)
{
TypeInferer.Execute(cgInfo);
}
if (enableSpeculation && !IsBlackListed)
{
CodeGen.CodeGeneratorWithInlineCache.Execute(this);
try {
CodeGeneratorWithSpecialization.Execute(cgInfo);
}
catch (JSDeoptFailedException e) {
IsBlackListed = true;
ilGen = CreateStub(funcCode, false);
cgInfo = new CodeGenerationInfo(this, funcCode, ilGen);
funcCode.Profiler = null;
if (EnableTypeInference)
{
TypeInferer.Execute(cgInfo);
}
CodeGenerator.Execute(cgInfo);
}
}
else
{
if (this.EnableProfiling && !IsBlackListed)
{
CodeGeneratorWithProfiling.Execute(cgInfo);
}
else
{
CodeGenerator.Execute(cgInfo);
}
}
var method = ilGen.EndJittedMethod(this, funcCode);
if (enableSpeculation && !IsBlackListed)
{
funcCode.SpecializedMethod = method;
}
else
{
funcCode.GenericMethod = method;
}
}
}
private static void CreateDataSetMethodCreateFromDataSet(CodeTypeDeclaration classType, CodeGenerationInfo generationInfo)
{
var cmm = new CodeMemberMethod();
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
cmm.Name = "createFromDataSet";
cmm.Parameters.Add("reader", "IDataSet", "dataSet");
cmm.Parameters.Add(typeof(bool), "verifyRevision");
cmm.ReturnType = new CodeTypeReference(generationInfo.ClassName);
classType.Members.Add(cmm);
}
private static void CreateConstructor(CodeTypeDeclaration classType, TableInfo tableInfo, CodeGenerationInfo generationInfo)
{
var cc = new CodeConstructor();
cc.Attributes = MemberAttributes.Public;
cc.Parameters.Add("reader", "irow&", "row");
cc.Parameters.Add(tableInfo.GetCodeType(CodeType.Pointer), "table");
cc.AddConstructorStatement(string.Format("{0}(row)", CodeGenerationInfo.CremaRowName));
//cc.AddConstructorStatement("Table(*table)");
//foreach (var item in tableInfo.Columns)
//{
// CodeBinaryOperatorExpression cbor = new CodeBinaryOperatorExpression();
// cbor.Left = new CodeVariableReferenceExpression("propertyName");
// cbor.Operator = CodeBinaryOperatorType.ValueEquality;
// cbor.Right = new CodePrimitiveExpression(item.Name);
// CodeConditionStatement ccs = new CodeConditionStatement(item.GetHasValueMethodExpression());
// CodeAssignStatement cas = new CodeAssignStatement();
// cas.Left = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), item.Name);
// cas.Right = item.GetGetValueMethodExpression();
// ccs.TrueStatements.Add(cas);
// cc.Statements.Add(ccs);
//}
//var query = from item in tableInfo.Columns
// where item.IsKey
// select item;
////method.AddStatement(string.Format("cremarow::initialize(row, iniutil::generate_hash({0}, {1}));", query.Count(), string.Join(", ", query)));
//CodeMethodInvokeExpression generate_hashExp = new CodeMethodInvokeExpression(new CodeTypeReferenceExpression("iniutil"), "generate_hash");
//foreach (var item in query)
//{
// CodeFieldReferenceExpression fieldExp = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), item.Name);
// if (item.IsCustomType() == false)
// generate_hashExp.Parameters.Add(fieldExp);
// else
// generate_hashExp.Parameters.Add(new CodeCastExpression(new CodeTypeReference(typeof(int)), fieldExp));
//}
// assign table
{
var tableField = new CodeFieldReferenceExpression(thisRef, "Table");
var tableVar = new CodeVariableReferenceExpression("table");
cc.Statements.AddAssign(tableField, tableVar);
}
// assign fields
{
int index = 0;
foreach (var item in tableInfo.Columns)
{
var cas = new CodeAssignStatement();
cas.Left = item.GetFieldExpression();
cas.Right = item.GetGetValueMethodExpression(index, false);
if (item.IsKey == false)
{
var ccs = new CodeConditionStatement(item.GetHasValueMethodExpression(index, false));
ccs.TrueStatements.Add(cas);
cc.Statements.Add(ccs);
}
else
{
cc.Statements.Add(cas);
}
index++;
}
}
//CodeMethodInvokeExpression methodExp = new CodeMethodInvokeExpression(new CodeTypeReferenceExpression("cremarow"), "initialize");
//methodExp.Parameters.Add(new CodeVariableReferenceExpression("row"));
//methodExp.Parameters.Add(generate_hashExp);
//cc.Statements.Add(new CodeExpressionStatement(methodExp));
//var query = from item in columns
// where item.IsKey
// select item.Name;
//method.AddStatement(string.Format("cremarow::initialize(row, iniutil::generate_hash({0}, {1}));", query.Count(), string.Join(", ", query)));
foreach (var item in generationInfo.GetChilds(tableInfo))
{
// check null and return defaultField
{
var state = new CodeConditionStatement();
var condition = new CodeBinaryOperatorExpression(item.GetFieldExpression(), CodeBinaryOperatorType.IdentityEquality, new CodePrimitiveExpression(null));
state.Condition = condition;
var codeTypeRef = new CodeTypeReferenceExpression(tableInfo.GetRowCodeType(CodeType.None));
var staticField = new CodeFieldReferenceExpression(codeTypeRef, item.GetFieldName() + "Empty");
state.TrueStatements.AddAssignReference(item.GetFieldExpression(), staticField);
cc.Statements.Add(state);
}
// return field;
//{
// var fieldExp = item.GetFieldExpression();
// cmp.GetStatements.AddMethodReturn(fieldExp, CodeType.None);
//}
//classType.Members.Add(cmp);
}
// invoke SetKey method
{
var methodRefExp = new CodeMethodReferenceExpression(new CodeThisReferenceExpression(), "SetKey");
var methodInvokeExp = new CodeMethodInvokeExpression(methodRefExp);
foreach (var item in tableInfo.Columns)
{
if (item.IsKey == true)
{
methodInvokeExp.Parameters.Add(item.GetFieldExpression());
}
}
cc.Statements.Add(methodInvokeExp);
}
classType.Members.Add(cc);
}
private static void CreateInitializeMethod(CodeTypeDeclaration classType, TableInfo tableInfo, CodeGenerationInfo generationInfo)
{
var cc = new CodeMemberMethod();
cc.Name = "initialize";
cc.Attributes = MemberAttributes.Public;
cc.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference("inirow&"), "row"));
// assign fields
{
int index = 0;
foreach (var item in tableInfo.Columns)
{
var cas = new CodeAssignStatement();
cas.Left = item.GetFieldExpression();
cas.Right = item.GetGetValueMethodExpression(index, false);
if (item.IsKey == false)
{
var ccs = new CodeConditionStatement(item.GetHasValueMethodExpression(index, false));
ccs.TrueStatements.Add(cas);
cc.Statements.Add(ccs);
}
else
{
cc.Statements.Add(cas);
}
index++;
}
}
classType.Members.Add(cc);
}
private string GenerateTables(CodeDomProvider codeDomProvider, CodeGeneratorOptions options, CodeGenerationInfo generationInfo)
{
StringBuilder sb = new StringBuilder();
using (StringWriter sw = new StringWriter(sb))
{
var codeGenerator = codeDomProvider.CreateGenerator(sw);
CodeCompileUnit compileUnit = new CodeCompileUnit();
//compileUnit.AddCustomInclude("reader/include/crema/inidata");
compileUnit.AddInclude("crema/inidata");
compileUnit.AddCustomInclude("crema_datatypes");
//compileUnit.AddCustomInclude("crema_base");
CodeNamespace codeNamespace = new CodeNamespace(generationInfo.Namespace);
codeNamespace.Imports.Add(new CodeNamespaceImport(generationInfo.ReaderNamespace));
foreach (var item in generationInfo.GetTables())
{
H3RowClassCreator.Create(codeNamespace, item, generationInfo);
}
compileUnit.Namespaces.Add(codeNamespace);
codeGenerator.GenerateCodeFromCompileUnit(compileUnit, sw, options);
}
return(sb.ToString());
}
private static void CreateColumnProperties(CodeTypeDeclaration classType, TableInfo tableInfo, CodeGenerationInfo generationInfo)
{
foreach (var item in tableInfo.Columns)
{
var cmp = new CodeMemberProperty();
cmp.Attributes = MemberAttributes.Public | MemberAttributes.Final;
cmp.Name = item.Name;
cmp.Type = item.GetPropertyType();
if (generationInfo.NoComment == false)
{
cmp.Comments.AddSummary(item.Comment);
}
if (generationInfo.NoChanges == false)
{
cmp.Comments.Add(CremaSchema.Creator, item.CreationInfo.ID);
cmp.Comments.Add(CremaSchema.CreatedDateTime, item.CreationInfo.DateTime);
cmp.Comments.Add(CremaSchema.Modifier, item.ModificationInfo.ID);
cmp.Comments.Add(CremaSchema.ModifiedDateTime, item.ModificationInfo.DateTime);
}
cmp.HasGet = true;
cmp.HasSet = false;
// return field;
{
var field = item.GetFieldExpression();
cmp.GetStatements.AddMethodReturn(field);
}
classType.Members.Add(cmp);
}
}
private string GenerateTypes(CodeDomProvider codeDomProvider, CodeGeneratorOptions options, CodeGenerationInfo generationInfo)
{
StringBuilder sb = new StringBuilder();
using (StringWriter sw = new StringWriter(sb))
{
var codeGenerator = codeDomProvider.CreateGenerator(sw);
CodeCompileUnit compileUnit = new CodeCompileUnit();
CodeNamespace codeNamespace = new CodeNamespace(generationInfo.Namespace);
codeNamespace.Imports.Add(new CodeNamespaceImport(generationInfo.ReaderNamespace));
CremaTypeEnumCreator.NoCpp = true;
CremaTypeEnumCreator.Create(codeNamespace, generationInfo);
compileUnit.Namespaces.Add(codeNamespace);
codeGenerator.GenerateCodeFromCompileUnit(compileUnit, sw, options);
}
return(sb.ToString());
}
private static void CreateChildFields(CodeTypeDeclaration classType, TableInfo tableInfo, CodeGenerationInfo generationInfo)
{
foreach (var item in generationInfo.GetChilds(tableInfo))
{
var cmf = new CodeMemberField();
cmf.Attributes = MemberAttributes.Public;
cmf.Name = item.GetFieldName();
cmf.Type = item.GetCodeType(CodeType.Pointer | CodeType.Const);
classType.Members.Add(cmf);
}
}
public static void CreateTable(CodeNamespace codeNamespace, TableInfo tableInfo, CodeGenerationInfo generationInfo)
{
var classType = new CodeTypeDeclaration();
foreach (var item in generationInfo.GetChilds(tableInfo))
{
CreateTable(codeNamespace, item, generationInfo);
}
CremaDeclCreator.CreateRowDecl(codeNamespace, tableInfo, generationInfo);
classType.Attributes = MemberAttributes.Public;
classType.Name = tableInfo.GetClassName();
classType.IsClass = true;
classType.TypeAttributes |= System.Reflection.TypeAttributes.Sealed;
classType.BaseTypes.Add(new CodeTypeReference("CremaTable", tableInfo.GetRowCodeType()));
if (generationInfo.OmitComment == false)
{
classType.Comments.AddSummary(tableInfo.Comment);
}
if (generationInfo.OmitSignatureDate == false)
{
classType.Comments.Add(CremaCodeGenerator.Creator, tableInfo.CreationInfo.ID);
classType.Comments.Add(CremaCodeGenerator.CreatedDateTime, tableInfo.CreationInfo.DateTime);
classType.Comments.Add(CremaCodeGenerator.Modifier, tableInfo.ModificationInfo.ID);
classType.Comments.Add(CremaCodeGenerator.ModifiedDateTime, tableInfo.ModificationInfo.DateTime);
classType.Comments.Add(CremaCodeGenerator.ContentsModifier, tableInfo.ContentsInfo.ID);
classType.Comments.Add(CremaCodeGenerator.ContentsModifiedDateTime, tableInfo.ContentsInfo.DateTime);
}
CreateTableFields(classType, tableInfo, generationInfo);
//CreateProperties(classType, tableInfo);
//CreateConstructor(classType, tableInfo);
CreateTableFindMethodDecl(classType, tableInfo);
//CreateCreateRowInstanceMethod(classType, tableInfo);
codeNamespace.Types.Add(classType);
}
private static void CreateColumnFields(CodeTypeDeclaration classType, TableInfo tableInfo, CodeGenerationInfo generationInfo)
{
foreach (var item in tableInfo.Columns)
{
var cmf = new CodeMemberField();
cmf.Attributes = MemberAttributes.Public;
cmf.Name = item.Name;
cmf.Type = item.GetCodeType(CodeType.None);
if (generationInfo.NoComment == false)
{
cmf.Comments.AddSummary(item.Comment);
}
if (generationInfo.NoChanges == false)
{
cmf.Comments.Add(CremaSchema.Creator, item.CreationInfo.ID);
cmf.Comments.Add(CremaSchema.CreatedDateTime, item.CreationInfo.DateTime);
cmf.Comments.Add(CremaSchema.Modifier, item.ModificationInfo.ID);
cmf.Comments.Add(CremaSchema.ModifiedDateTime, item.ModificationInfo.DateTime);
}
classType.Members.Add(cmf);
}
}
