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); } }