/// <summary> /// Initializes a new instance of the <see cref="CodeGeneratorContext"/> class. /// </summary> /// <param name="metadataSet">The metadata set.</param> /// <param name="codeGeneratorOptions">The code generator options.</param> public CodeGeneratorContext(MetadataSet metadataSet, CodeGeneratorOptions codeGeneratorOptions) { MetadataSet = metadataSet; CodeDomProvider = CodeDomProvider.CreateProvider(codeGeneratorOptions.CodeLanguage.ToString()); CodeCompileUnit = new CodeCompileUnit(); CodeGeneratorOptions = codeGeneratorOptions; }
static void Main(string[] args) { int namespaces = 10; int classesPerNamespace = 10; int methodsPerClass = 10; CodeCompileUnit codeCompileUnit = new CodeCompileUnit(); for (int i = 0; i < namespaces; ++i) { CodeNamespace codeNamespace = new CodeNamespace(); codeCompileUnit.Namespaces.Add(codeNamespace); codeNamespace.Name = "Namespace" + i; for (int j = 0; j < classesPerNamespace; ++j) { CodeTypeDeclaration codeTypeDeclaration = new CodeTypeDeclaration(); codeNamespace.Types.Add(codeTypeDeclaration); codeTypeDeclaration.Name = "Class" + j; codeTypeDeclaration.TypeAttributes = TypeAttributes.Public; codeTypeDeclaration.Comments.Add( new CodeCommentStatement( "<summary>This is a summary.</summary>", true ) ); for (int k = 0; k < methodsPerClass; ++k) { CodeMemberMethod codeMemberMethod = new CodeMemberMethod(); codeTypeDeclaration.Members.Add(codeMemberMethod); codeMemberMethod.Name = "Method" + k; codeMemberMethod.Attributes = MemberAttributes.Public; codeMemberMethod.Comments.Add( new CodeCommentStatement( "<summary>This is a summary.</summary>", true ) ); } } } CodeDomProvider codeDomProvider = new CSharpCodeProvider(); ICodeGenerator codeGenerator = codeDomProvider.CreateGenerator(); CodeGeneratorOptions codeGeneratorOptions = new CodeGeneratorOptions(); codeGenerator.GenerateCodeFromCompileUnit(codeCompileUnit, Console.Out, codeGeneratorOptions); }
private static string GenerateCode(string expression) { var source = new StringBuilder(); var sw = new StringWriter(source); var options = new CodeGeneratorOptions(); var myNamespace = new CodeNamespace("ExpressionEvaluator"); myNamespace.Imports.Add(new CodeNamespaceImport("System")); var classDeclaration = new CodeTypeDeclaration { IsClass = true, Name = "Calculator", Attributes = MemberAttributes.Public }; var myMethod = new CodeMemberMethod { Name = "Calculate", ReturnType = new CodeTypeReference(typeof(double)), Attributes = MemberAttributes.Public }; myMethod.Statements.Add(new CodeMethodReturnStatement(new CodeSnippetExpression(expression))); classDeclaration.Members.Add(myMethod); myNamespace.Types.Add(classDeclaration); provider.GenerateCodeFromNamespace(myNamespace, sw, options); sw.Flush(); sw.Close(); return source.ToString(); }
// Methods public virtual void GenerateCodeFromMember(System.CodeDom.CodeTypeMember member, System.IO.TextWriter writer, CodeGeneratorOptions options) { }
internal void GenerateCodeFromExpression(CodeExpression expression, TextWriter writer, CodeGeneratorOptions options) { if (expression == null) { throw new ArgumentNullException("expression"); } if (writer == null) { throw new ArgumentNullException("writer"); } switch (Language) { case Language.CSharp: new CSharpCodeProvider().GenerateCodeFromExpression(expression, writer, options); return; default: throw new InvalidOperationException(string.Format("Cannot handle '{0}'.", this.Language)); } }
private static String ConstructGeneratorCode(TemplateItem ti, Boolean lineNumbers, String namespaceName, CodeDomProvider provider) { // 准备类名和命名空间 var codeNamespace = new CodeNamespace(namespaceName); // 加入引用的命名空间 foreach (var str in ti.Imports) { if (!String.IsNullOrEmpty(str)) { codeNamespace.Imports.Add(new CodeNamespaceImport(str)); } } var typeDec = new CodeTypeDeclaration(ti.ClassName); typeDec.IsClass = true; codeNamespace.Types.Add(typeDec); // 基类 if (!String.IsNullOrEmpty(ti.BaseClassName)) { typeDec.BaseTypes.Add(new CodeTypeReference(ti.BaseClassName)); } else if (!String.IsNullOrEmpty(BaseClassName)) { typeDec.BaseTypes.Add(new CodeTypeReference(BaseClassName)); } else { typeDec.BaseTypes.Add(new CodeTypeReference(typeof(TemplateBase))); } if (lineNumbers && !String.IsNullOrEmpty(ti.Name)) { typeDec.LinePragma = new CodeLinePragma(ti.Name, 1); } // Render方法 CreateRenderMethod(ti.Blocks, lineNumbers, typeDec); // 代码生成选项 var options = new CodeGeneratorOptions(); options.VerbatimOrder = true; options.BlankLinesBetweenMembers = false; options.BracingStyle = "C"; // 其它类成员代码块 var firstMemberFound = false; foreach (var block in ti.Blocks) { firstMemberFound = GenerateMemberForBlock(block, typeDec, lineNumbers, provider, options, firstMemberFound); } // 模版变量 if (ti.Vars != null && ti.Vars.Count > 0) { // 构建静态构造函数,初始化静态属性Vars CreateCctorMethod(typeDec, ti.Vars); //public Int32 VarName //{ // get { return (Int32)GetData("VarName"); } // set { Data["VarName"] = value; } //} foreach (var v in ti.Vars) { //var vtype = TypeX.Create(v.Value); var codeName = v.Value.GetName(true); var sb = new StringBuilder(); sb.AppendLine(); sb.AppendFormat("public {0} {1}", codeName, v.Key); sb.AppendLine("{"); sb.AppendFormat(" get {{ return GetData<{0}>(\"{1}\"); }}", codeName, v.Key); sb.AppendLine(); sb.AppendFormat(" set {{ Data[\"{0}\"] = value; }}", v.Key); sb.AppendLine(); sb.AppendLine("}"); typeDec.Members.Add(new CodeSnippetTypeMember(sb.ToString())); } } // 输出 using (var writer = new StringWriter()) { provider.GenerateCodeFromNamespace(codeNamespace, new IndentedTextWriter(writer), options); return(writer.ToString()); } }
private static void Json2Class(string fileName, string json, List <object> statements) { string structName = ""; structName = Path.GetFileName(fileName).ToLower().Replace(".xlsx", ""); //首字母大写 structName = structName.Substring(0, 1).ToUpper() + structName.Substring(1); //输出目录控制 string outputFile = Path.Combine(Application.dataPath, "Code/Game@hotfix/Table"); if (Directory.Exists(outputFile) == false) { Directory.CreateDirectory(outputFile); } //输出目录 outputFile = Path.Combine(outputFile, Path.GetFileName(fileName).Replace(".xlsx", ".cs")); //生成类服务 CodeCompileUnit compunit = new CodeCompileUnit(); CodeNamespace sample = new CodeNamespace("Game.Data"); compunit.Namespaces.Add(sample); //引用命名空间 sample.Imports.Add(new CodeNamespaceImport("System")); sample.Imports.Add(new CodeNamespaceImport("System.Collections.Generic")); sample.Imports.Add(new CodeNamespaceImport("Game.Data")); sample.Imports.Add(new CodeNamespaceImport("SQLite4Unity3d")); //在命名空间下添加一个类 CodeTypeDeclaration wrapProxyClass = new CodeTypeDeclaration(structName); wrapProxyClass.IsClass = true; wrapProxyClass.IsEnum = false; wrapProxyClass.IsInterface = false; wrapProxyClass.IsPartial = false; wrapProxyClass.IsStruct = false; //把这个类添加到命名空间 sample.Types.Add(wrapProxyClass); CodeAttributeDeclaration attr = new CodeAttributeDeclaration("Serializable"); wrapProxyClass.CustomAttributes.Add(attr); // var jsonData = JsonMapper.ToObject(json)[0]; int i = 0; foreach (var key in jsonData.Keys) { //字段 string memberContent = @" public [type] [Name] {get;set;}"; CodeSnippetTypeMember member = new CodeSnippetTypeMember(); if (key.ToLower() == "id" && key != "Id") { Debug.LogErrorFormat("<color=yellow>表格{0}字段必须为Id[大小写],请修改后生成</color>", structName); break; } else if (key == "Id") { //增加一个sqlite主键 //member.CustomAttributes.Add(new CodeAttributeDeclaration("PrimaryKey")); memberContent = @" [PrimaryKey] public [type] [Name] {get;set;}"; } var value = jsonData[key]; string type = null; if (value.IsArray) { var str = value.ToJson(); if (str.IndexOf("\"") > 0) { type = "List<string>"; } else { type = "List<double>"; } } else if (value.IsInt) { type = "int"; } else if (value.IsDouble || value.IsLong) { type = "double"; } else if (value.IsBoolean) { type = "bool"; } else if (value.IsString) { type = "string"; } //注释 member.Comments.Add(new CodeCommentStatement(statements[i].ToString())); member.Text = memberContent.Replace("[type]", type).Replace("[Name]", key); wrapProxyClass.Members.Add(member); i++; } //生成代码 CodeDomProvider provider = CodeDomProvider.CreateProvider("CSharp"); CodeGeneratorOptions options = new CodeGeneratorOptions(); options.BracingStyle = "C"; options.BlankLinesBetweenMembers = true; using (System.IO.StreamWriter sw = new System.IO.StreamWriter(outputFile)) { provider.GenerateCodeFromCompileUnit(compunit, sw, options); } }
public void EmitCode(string pathPrefix, string nsName = null, string classname = null) { this.CodeUnit1 = new CodeCompileUnit(); this.CodeUnit2 = new CodeCompileUnit(); if (string.IsNullOrEmpty(nsName)) { nsName = "TuiApp"; } if (string.IsNullOrEmpty(classname)) { classname = "TuiAppLayout"; } var codeNs1 = new CodeNamespace(nsName); var codeNs2 = new CodeNamespace(nsName); codeNs2.Comments.Clear(); codeNs2.Comments.Add(new CodeCommentStatement("This file will be auto-generated if missing with")); codeNs2.Comments.Add(new CodeCommentStatement("sample code, otherwise it will be left untouched")); CodeUnit1.Namespaces.Add(codeNs1); codeNs1.Imports.Add(new CodeNamespaceImport("System")); codeNs1.Imports.Add(new CodeNamespaceImport("Mono.Terminal")); codeNs1.Imports.Add(new CodeNamespaceImport("Terminal.Gui")); CodeUnit2.Namespaces.Add(codeNs2); codeNs2.Imports.Add(new CodeNamespaceImport("System")); codeNs2.Imports.Add(new CodeNamespaceImport("Mono.Terminal")); codeNs2.Imports.Add(new CodeNamespaceImport("Terminal.Gui")); this.CodeClass1 = new CodeTypeDeclaration(classname) { IsPartial = true, }; codeNs1.Types.Add(CodeClass1); this.CodeClass2 = new CodeTypeDeclaration(classname) { IsPartial = true, }; codeNs2.Types.Add(CodeClass2); var menuVars = new CodeStatementCollection(); var eventHandlers = new List <string>(); void InitTuiElement(string type, TuiElement te, IEnumerable <CodeExpression> args) { te.LocalName = te.LocalName ?? LocalName(type, te.Name); var teInitExpr = new CodeObjectCreateExpression(type); if (args != null) { foreach (var a in args) { teInitExpr.Parameters.Add(a); } } if (!string.IsNullOrEmpty(te.Name)) { CodeClass1.Members.Add( new CodeMemberField(type, te.Name)); menuVars.Add(new CodeAssignStatement( new CodeFieldReferenceExpression( new CodeThisReferenceExpression(), te.Name), teInitExpr)); } else { menuVars.Add(new CodeVariableDeclarationStatement( type, te.LocalName, teInitExpr)); } } foreach (var mb in _menuBars) { if (mb.Items == null) { continue; } foreach (var mbi in mb.Items) { if (mbi.Items == null) { continue; } foreach (var mi in mbi.Items) { var help = mi.Help == null ? "null" : $@"""{mi.Help}"""; InitTuiElement("MenuItem", mi, new CodeExpression[] { new CodeSnippetExpression($@"""{mi.Title}"""), new CodeSnippetExpression(help), new CodeSnippetExpression("null") }); } } foreach (var mbi in mb.Items) { // We have to build an array of MI even if its empty // because MBI only has one constructor signature var arr = new CodeArrayCreateExpression("MenuItem"); if (mbi.Items != null) { foreach (var mi in mbi.Items) { arr.Initializers.Add( new CodeVariableReferenceExpression(mi.LocalName)); } } InitTuiElement("MenuBarItem", mbi, new CodeExpression[] { new CodeSnippetExpression($@"""{mbi.Title}"""), arr }); } } foreach (var v in _menuBars.Concat(_views)) { if (!string.IsNullOrEmpty(v.Name)) { CodeClass1.Members.Add(new CodeMemberField(v.Type, v.Name)); } } this.CodeInitMethod = new CodeMemberMethod() { Name = "InitLayout", Attributes = MemberAttributes.Private, }; CodeClass1.Members.Add(CodeInitMethod); CodeInitMethod.Statements.AddRange(menuVars); // View/MB constructors with args foreach (var v in _menuBars.Concat(_views)) { var args = v.Args?.Count > 0 ? string.Join(", ", v.Args.Select(x => x.Emit())) : string.Empty; CodeExpression initExpr = new CodeSnippetExpression( $"new {v.Type}({args})"); if (v is TuiMenuBar mb) { var arr = new CodeArrayCreateExpression("MenuBarItem"); foreach (var mbi in mb.Items) { arr.Initializers.Add( new CodeVariableReferenceExpression(mbi.LocalName)); } initExpr = new CodeObjectCreateExpression(v.Type, arr); } if (string.IsNullOrEmpty(v.Name)) { CodeInitMethod.Statements.Add(new CodeVariableDeclarationStatement( v.Type, v.LocalName, initExpr)); } else { CodeInitMethod.Statements.Add(new CodeAssignStatement( new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), v.Name), initExpr)); } } foreach (var v in _menuBars.Concat(_views)) { var stt = new CodeStatementCollection(); if (v.Children?.Count > 0) { foreach (var c in v.Children) { var mre = new CodeMethodReferenceExpression( new CodeVariableReferenceExpression(v.LocalName), "Add"); var mie = new CodeMethodInvokeExpression(mre, new CodeVariableReferenceExpression(c.LocalName)); stt.Add(mie); } } if (v.Props?.Count > 0) { foreach (var p in v.Props) { var cas = new CodeAssignStatement( new CodePropertyReferenceExpression( new CodeVariableReferenceExpression(v.LocalName), p.Key), new CodeSnippetExpression(p.Value.Emit()) ); stt.Add(cas); } } AddEvents(stt, v); if (stt.Count > 0) { CodeInitMethod.Statements.Add(new CodeCommentStatement(v.Name ?? $"({v.LocalName})")); CodeInitMethod.Statements.AddRange(stt); } } foreach (var mb in _menuBars) { var stt = new CodeStatementCollection(); if (mb.Items == null) { continue; } foreach (var mbi in mb.Items) { if (mbi.Items == null) { continue; } foreach (var mi in mbi.Items) { AddEvents(stt, mi); } } if (stt.Count > 0) { CodeInitMethod.Statements.Add(new CodeCommentStatement(mb.Name ?? $"({mb.LocalName})")); CodeInitMethod.Statements.AddRange(stt); } } void AddEvents(CodeStatementCollection stt, TuiElement te) { if (te.Events?.Count > 0) { foreach (var e in te.Events) { var eh = e.Value?.ToString(); if (eh == null) { eh = $"{te.LocalName}_{e.Key}"; } // eh = $"{te.Name ?? te.LocalName.Replace(".", "_")}_{e.Key}"; var cas = new CodeAssignStatement( new CodePropertyReferenceExpression( new CodeVariableReferenceExpression(te.LocalName), e.Key), new CodeSnippetExpression($"() => {eh}()") ); stt.Add(cas); if (!eventHandlers.Contains(eh)) { // Adding Partial Method is a hack: // https://stackoverflow.com/a/2164838/5428506 CodeClass1.Members.Add(new CodeMemberField { Name = eh + "()", Attributes = MemberAttributes.ScopeMask, Type = new CodeTypeReference("partial void"), }); eventHandlers.Add(eh); } } } } var codeCons = new CodeConstructor() { Attributes = MemberAttributes.Public, }; CodeClass2.Members.Add(codeCons); codeCons.Statements.Add(new CodeMethodInvokeExpression( new CodeMethodReferenceExpression( new CodeThisReferenceExpression(), "InitLayout"))); var file1 = pathPrefix + ".tui.cs"; var file2 = pathPrefix + ".cs"; var prov = CodeDomProvider.CreateProvider("CSharp");; var opts = new CodeGeneratorOptions { BracingStyle = "C", }; Directory.CreateDirectory(Path.GetDirectoryName(file1)); using (var fs = File.Open(file1, FileMode.Create)) using (var sw = new StreamWriter(fs)) { prov.GenerateCodeFromCompileUnit(CodeUnit1, sw, opts); } if (!File.Exists(file2)) { Directory.CreateDirectory(Path.GetDirectoryName(file2)); string body; using (var sw = new StringWriter()) { prov.GenerateCodeFromCompileUnit(CodeUnit2, sw, opts); body = sw.ToString(); } body = Regex.Replace(body, @"//-+\s+// <auto-generated>[\S\s]+</auto-generated>\s+//-+", "", RegexOptions.Multiline); File.WriteAllText(file2, body); } }
public static unsafe int Main(string[] args) { string baseDirectory = AppDomain.CurrentDomain.BaseDirectory; string pluginDirectory; if (baseDirectory.EndsWith("bin")) { // Windows pluginDirectory = Path.GetFullPath(Path.Combine(baseDirectory, "..\\lib\\plugins")); } else { // *nix pluginDirectory = Path.Combine(baseDirectory, "plugins"); } List<string> codeFiles = new List<string>(); List<CodeCompileUnit> codeSnippets = new List<CodeCompileUnit>(); List<Assembly> references = new List<Assembly>(); List<string> imports = new List<string>(); StringBuilder compilerOptions = new StringBuilder(); bool codeOnly = false; string codeFile = string.Empty; string assemblyFile = "out.dll"; int warnLevel = 0; string smokeLib = null; string defaultNamespace = "Qyoto"; string globalClass = "Global"; string destination = string.Empty; string docs = string.Empty; List<Assembly> plugins = new List<Assembly>(); foreach (string arg in args) { if (arg == "-help" || arg == "--help" || arg == "-h") { PrintHelp(); return 0; } if (arg == "-verbose") { Debug.Listeners.Add(new ConsoleTraceListener(true)); continue; } if (arg == "-code-only") { codeOnly = true; continue; } if (arg.StartsWith("-code-file:")) { codeFile = arg.Substring(11); continue; } if (arg.StartsWith("-out:")) { assemblyFile = arg.Substring(5); continue; } if (arg.StartsWith("-warn:")) { warnLevel = int.Parse(arg.Substring(6)); continue; } if (arg.StartsWith("-r:")) { references.Add(Assembly.LoadFrom(arg.Substring(3))); continue; } if (arg.StartsWith("-reference:")) { references.Add(Assembly.LoadFrom(arg.Substring(11))); continue; } if (arg.StartsWith("-global-class:")) { globalClass = arg.Substring(14); continue; } if (arg.StartsWith("-namespace:")) { defaultNamespace = arg.Substring(11); continue; } if (arg.StartsWith("-dest:")) { destination = arg.Substring("-dest:".Length); continue; } if (arg.StartsWith("-import:")) { imports.AddRange(arg.Substring(8).Split(',')); continue; } if (arg.StartsWith("-docs:")) { docs = arg.Substring("-docs:".Length); continue; } if (arg.StartsWith("-plugins:")) { foreach (string str in arg.Substring(9).Split(',')) { Assembly a; try { a = Assembly.LoadFrom(str); } catch (FileNotFoundException) { a = Assembly.LoadFrom(Path.Combine(pluginDirectory, str)); } plugins.Add(a); } continue; } if (arg.StartsWith("-")) { compilerOptions.Append(" /"); compilerOptions.Append(arg.Substring(1)); continue; } if (smokeLib == null) { smokeLib = arg; continue; } codeFiles.Add(arg); FileStream fs = new FileStream(arg, FileMode.Open); StreamReader sr = new StreamReader(fs); codeSnippets.Add(new CodeSnippetCompileUnit(sr.ReadToEnd())); sr.Close(); fs.Close(); } if (!string.IsNullOrEmpty(docs)) { compilerOptions.Append(" /doc:" + Path.ChangeExtension(Path.GetFileName(assemblyFile), ".xml")); } compilerOptions.Append(" -debug"); if (smokeLib == null) { PrintHelp(); return 1; } Smoke* smoke = InitSmoke(smokeLib); if (smoke == (Smoke*) 0) { return SmokeLoadingFailure; } List<ICustomTranslator> customTranslators = (from plugin in plugins from type in plugin.GetTypes() from iface in type.GetInterfaces() where iface == typeof(ICustomTranslator) select (ICustomTranslator) Activator.CreateInstance(type)).ToList(); GeneratorData data = new GeneratorData(smoke, defaultNamespace, imports, references, destination, docs); data.GlobalSpaceClassName = globalClass; Translator translator = new Translator(data, customTranslators); foreach (IHookProvider provider in from type in plugins.SelectMany(plugin => plugin.GetTypes()) where type.GetInterfaces().Any(iface => iface == typeof(IHookProvider)) select (IHookProvider) Activator.CreateInstance(type)) { provider.Translator = translator; provider.Data = data; provider.RegisterHooks(); } ClassesGenerator classgen = new ClassesGenerator(data, translator); Console.Error.WriteLine("Generating CodeCompileUnit..."); classgen.Run(); DestroySmoke((IntPtr) smoke); Dictionary<string, string> providerOptions = new Dictionary<string, string>(); providerOptions.Add("CompilerVersion", "v4.0"); CodeDomProvider csharp = new CSharpCodeProvider(providerOptions); if (codeFile != string.Empty) { FileStream fs = new FileStream(codeFile, FileMode.Create); StreamWriter sw = new StreamWriter(fs); Console.Error.WriteLine("Generating code..."); CodeGeneratorOptions cgo = new CodeGeneratorOptions(); csharp.GenerateCodeFromCompileUnit(data.CompileUnit, sw, cgo); sw.Close(); fs.Close(); codeFiles.Add(codeFile); } if (codeOnly) { if (codeFile == string.Empty) { Console.Error.WriteLine("Missing output filename. Use the -code-file:<file> option."); return MissingOptionError; } return NoError; } codeSnippets.Add(data.CompileUnit); Console.Error.WriteLine("Compiling assembly..."); CompilerParameters cp = new CompilerParameters(); cp.GenerateExecutable = false; cp.TreatWarningsAsErrors = false; cp.OutputAssembly = assemblyFile; cp.GenerateInMemory = false; cp.WarningLevel = warnLevel; cp.CompilerOptions = compilerOptions.ToString(); cp.ReferencedAssemblies.Add(typeof(Regex).Assembly.Location); cp.ReferencedAssemblies.Add(typeof(ExtensionAttribute).Assembly.Location); foreach (Assembly assembly in references) { cp.ReferencedAssemblies.Add(assembly.Location); } CompilerResults cr; if(codeFile == null) { cr = csharp.CompileAssemblyFromDom(cp, codeSnippets.ToArray()); } else { cr = csharp.CompileAssemblyFromFile(cp, codeFiles.ToArray()); } bool errorsOccured = false; foreach (CompilerError error in cr.Errors) { if (!error.IsWarning) errorsOccured = true; Console.Error.WriteLine(error); } if (errorsOccured) { Console.Error.WriteLine("Errors occured. No assembly was generated."); return CompilationError; } Console.Error.WriteLine("Done."); return NoError; }
public void GenerateCodeFromCompileUnit(CodeCompileUnit e, TextWriter w, CodeGeneratorOptions o) { throw new ArgumentOutOfRangeException("3"); }
private void WriteFile(string file, CodeTypeDeclaration resources, string language, bool isFSharp, bool isCSharp) { CodeDomProvider provider = isFSharp ? new FSharp.Compiler.CodeDom.FSharpCodeProvider() : CodeDomProvider.CreateProvider(language); string code = null; using (var o = new StringWriter()) { var options = new CodeGeneratorOptions() { BracingStyle = "C", IndentString = "\t", }; var ns = string.IsNullOrEmpty(Namespace) ? new CodeNamespace() : new CodeNamespace(Namespace); if (resources != null) { ns.Types.Add(resources); } var unit = new CodeCompileUnit(); unit.Namespaces.Add(ns); var resgenatt = new CodeAttributeDeclaration(new CodeTypeReference("Android.Runtime.ResourceDesignerAttribute", CodeTypeReferenceOptions.GlobalReference)); resgenatt.Arguments.Add(new CodeAttributeArgument(new CodePrimitiveExpression(Namespace.Length > 0 ? Namespace + ".Resource" : "Resource"))); resgenatt.Arguments.Add(new CodeAttributeArgument("IsApplication", new CodePrimitiveExpression(IsApplication))); unit.AssemblyCustomAttributes.Add(resgenatt); // Add Pragma to disable warnings about no Xml documentation if (isCSharp) { provider.GenerateCodeFromCompileUnit(new CodeSnippetCompileUnit("#pragma warning disable 1591"), o, options); } provider.CreateGenerator(o).GenerateCodeFromCompileUnit(unit, o, options); // Add Pragma to re-enable warnings about no Xml documentation if (isCSharp) { provider.GenerateCodeFromCompileUnit(new CodeSnippetCompileUnit("#pragma warning restore 1591"), o, options); } code = o.ToString(); // post-processing for F# if (isFSharp) { code = code.Replace("\r\n", "\n"); while (true) { int skipLen = " = class".Length; int idx = code.IndexOf(" = class"); if (idx < 0) { break; } int end = code.IndexOf(" end"); string head = code.Substring(0, idx); string mid = end < 0 ? code.Substring(idx) : code.Substring(idx + skipLen, end - idx - skipLen); string last = end < 0 ? null : code.Substring(end + " end".Length); code = head + @" () = static do Android.Runtime.ResourceIdManager.UpdateIdValues()" + mid + "\n" + last; } } } var temp_o = Path.Combine(Path.GetDirectoryName(file), "__" + Path.GetFileName(file) + ".new"); using (TextWriter o = File.CreateText(temp_o)) o.Write(code); MonoAndroidHelper.CopyIfChanged(temp_o, file); try { File.Delete(temp_o); } catch (Exception) { } }
void ICodeGenerator.GenerateCodeFromCompileUnit(CodeCompileUnit e, TextWriter w, CodeGeneratorOptions o) { for (int i = 0; i < e.ReferencedAssemblies.Count; i++) { w.WriteLine(e.ReferencedAssemblies[i]); } for (int i = 0; i < e.Namespaces.Count; i++) { (this as ICodeGenerator).GenerateCodeFromNamespace(e.Namespaces[i], w, o); w.WriteLine(); } }
/// <summary> /// Main driving routine for building a class /// </summary> public void BuildFunctionClass(string expression, string strReturnType, string dllName) { //if( expression == "29487*[AREA]" ) //{ //} _dllName = dllName; bool bCalculate = true; m_bCalculate = bCalculate; m_expression = expression; // expression = RefineEvaluationString(expression); // expression = expression.ToUpper(); // need a string to put the code into _source = new StringBuilder(); StringWriter sw = new StringWriter(_source); //Declare your provider and generator CSharpCodeProvider codeProvider = new CSharpCodeProvider(); ICodeGenerator generator = codeProvider.CreateGenerator(sw); CodeGeneratorOptions codeOpts = new CodeGeneratorOptions(); CodeNamespace myNamespace = new CodeNamespace("ExpressionEvaluator"); myNamespace.Imports.Add(new CodeNamespaceImport("System")); myNamespace.Imports.Add(new CodeNamespaceImport("System.Windows.Forms")); //Build the class declaration and member variables CodeTypeDeclaration classDeclaration = new CodeTypeDeclaration(); classDeclaration.IsClass = true; classDeclaration.Name = "Calculator"; classDeclaration.Attributes = MemberAttributes.Public; switch (strReturnType) { case "String": classDeclaration.Members.Add(FieldVariable("answer", typeof(String), MemberAttributes.Private)); break; case "double": classDeclaration.Members.Add(FieldVariable("answer", typeof(double), MemberAttributes.Private)); break; case "Boolean": classDeclaration.Members.Add(FieldVariable("answer", typeof(Boolean), MemberAttributes.Private)); break; default: return; //break; } //default constructor CodeConstructor defaultConstructor = new CodeConstructor(); defaultConstructor.Attributes = MemberAttributes.Public; defaultConstructor.Comments.Add(new CodeCommentStatement("Default Constructor for class", true)); // defaultConstructor.Statements.Add(new CodeSnippetStatement("//TODO: implement default constructor")); classDeclaration.Members.Add(defaultConstructor); switch (strReturnType) { case "String": classDeclaration.Members.Add(this.MakeProperty("Answer", "answer", typeof(String))); break; case "double": classDeclaration.Members.Add(this.MakeProperty("Answer", "answer", typeof(double))); break; case "Boolean": classDeclaration.Members.Add(this.MakeProperty("Answer", "answer", typeof(Boolean))); break; default: return; //break; } //Our Calculate Method CodeMemberMethod myMethod = new CodeMemberMethod(); myMethod.Name = "Calculate"; switch (strReturnType) { case "String": myMethod.ReturnType = new CodeTypeReference(typeof(String)); break; case "double": myMethod.ReturnType = new CodeTypeReference(typeof(double)); break; case "Boolean": myMethod.ReturnType = new CodeTypeReference(typeof(Boolean)); break; default: return; //break; } myMethod.Comments.Add(new CodeCommentStatement("Calculate an expression", true)); myMethod.Attributes = MemberAttributes.Public; myMethod.Parameters.AddRange(GetParametersFromBracketedItems(expression)); int nLastSemiColon = expression.LastIndexOf(";"); if (nLastSemiColon > 0) { expression = expression.Substring(0, nLastSemiColon); } expression = expression.Replace("[", ""); expression = expression.Replace("@", ""); expression = expression.Replace("]", ""); myMethod.Statements.Add(new CodeSnippetExpression(expression)); classDeclaration.Members.Add(myMethod); //write code myNamespace.Types.Add(classDeclaration); generator.GenerateCodeFromNamespace(myNamespace, sw, codeOpts); sw.Flush(); sw.Close(); }
public static void WriteClass(TextWriter writer, string ns) { var buildDataTable = EditorRuntimeAssetDataCollector.BuildDataTable(); var allAssetDataGroups = buildDataTable.AllAssetDataGroups; var assetBundleInfos = new List <AssetBundleInfo>(); allAssetDataGroups.ForEach(assetDataGroup => { var assetDatas = assetDataGroup.AssetBundleDatas; assetDatas.ForEach(abUnit => { assetBundleInfos.Add(new AssetBundleInfo(abUnit.abName) { assets = assetDataGroup.AssetDatas .Where(assetData => assetData.OwnerBundleName == abUnit.abName) .Select(assetData => assetData.AssetName) .ToArray() }); }); }); var compileUnit = new CodeCompileUnit(); var codeNamespace = new CodeNamespace(ns); compileUnit.Namespaces.Add(codeNamespace); foreach (var assetBundleInfo in assetBundleInfos) { var className = assetBundleInfo.Name; var bundleName = className.Substring(0, 1).ToLower() + className.Substring(1); int firstNumber; if (int.TryParse(bundleName[0].ToString(), out firstNumber)) { continue; } className = className.Substring(0, 1).ToUpper() + className.Substring(1).Replace("/", "_").Replace("@", "_").Replace("!", "_"); var codeType = new CodeTypeDeclaration(className); codeNamespace.Types.Add(codeType); var bundleNameField = new CodeMemberField { Attributes = MemberAttributes.Public | MemberAttributes.Const, Name = "BundleName", Type = new CodeTypeReference(typeof(System.String)) }; codeType.Members.Add(bundleNameField); bundleNameField.InitExpression = new CodePrimitiveExpression(bundleName.ToLowerInvariant()); var checkRepeatDict = new Dictionary <string, string>(); foreach (var asset in assetBundleInfo.assets) { var assetField = new CodeMemberField { Attributes = MemberAttributes.Public | MemberAttributes.Const }; var content = Path.GetFileNameWithoutExtension(asset); assetField.Name = content.ToUpperInvariant().Replace("@", "_").Replace("!", "_"); assetField.Type = new CodeTypeReference(typeof(System.String)); if (!assetField.Name.StartsWith("[") && !assetField.Name.StartsWith(" [") && !checkRepeatDict.ContainsKey(assetField.Name)) { checkRepeatDict.Add(assetField.Name, asset); codeType.Members.Add(assetField); } assetField.InitExpression = new CodePrimitiveExpression(content); } checkRepeatDict.Clear(); } var provider = new CSharpCodeProvider(); var options = new CodeGeneratorOptions { BlankLinesBetweenMembers = false, BracingStyle = "C" }; provider.GenerateCodeFromCompileUnit(compileUnit, writer, options); }
public void BuildClass(string expression, bool bCalculate, string dllName) { if (expression == "" || expression == null) { return; } _originalInput = expression.Replace("[$", "[").Replace("[@", "[");; _dllName = dllName; m_bCalculate = bCalculate; m_expression = expression; expression = RefineEvaluationString(expression); Regex expressionWhiteSpaceMechanic = new Regex(@"\s"); if (!bCalculate) //Calculating equations only use numbers. No need for any manipulation. The expression is already to be compiled. { //This can't happen because it ToUpper() the string literals //expression = expression.ToUpper(); expression = expression.Replace("||", "OR"); expression = expression.Replace("!=", "<>"); expression = expression.Replace("==", "="); expression = expression.Replace("|", "'"); expression = expression.Replace(">=", ">>"); //This is so we can replace = with double == expression = expression.Replace("<=", "<<"); //This is so we can replace = with double == //we keep missing non-space whitespace... expression = expressionWhiteSpaceMechanic.Replace(expression, " "); expression = expression.Replace(" AND ", " && "); expression = expression.Replace(" OR ", " || "); expression = expression.Replace("=", "=="); expression = expression.Replace("<>", "!="); expression = expression.Replace("<<", "<="); expression = expression.Replace(">>", ">="); int nOpen = -1; bool bStringVariable = false; bool bDateVariable = false; for (int i = 0; i < expression.Length; i++) { if (expression.Substring(i, 1) == "[") { if (expression.Substring(i + 1, 1) == "@") { bStringVariable = true; bDateVariable = false; } else if (expression.Substring(i + 1, 1) == "$") { bStringVariable = false; bDateVariable = true; } else { bStringVariable = false; bDateVariable = false; } } if (expression.Substring(i, 1) == "'" && nOpen < 0) { nOpen = i; continue; } if (expression.Substring(i, 1) == "'" && nOpen > -1) { //Get the value between open and (i) // String strValueWithQuotes = expression.Substring(nOpen, i - nOpen + 1); String strValue = expression.Substring(nOpen + 1, i - nOpen - 1); if (bStringVariable) { strValue = strValueWithQuotes.Replace("'", "\""); } else if (bDateVariable) { strValue = strValueWithQuotes.Replace("'", "\""); strValue = " Convert.ToDateTime(" + strValue + ") "; } else { try { float fValue = float.Parse(strValue); } catch { strValue = strValueWithQuotes.Replace("'", "\""); } } expression = expression.Remove(nOpen, i - nOpen + 1).Insert(nOpen, strValue); //expression = expression.Replace(strValueWithQuotes, strValue); nOpen = -1; i = 0; } } } // need a string to put the code into _source = new StringBuilder(); StringWriter sw = new StringWriter(_source); //Declare your provider and generator CSharpCodeProvider codeProvider = new CSharpCodeProvider(); ICodeGenerator generator = codeProvider.CreateGenerator(sw); CodeGeneratorOptions codeOpts = new CodeGeneratorOptions(); CodeNamespace myNamespace = new CodeNamespace("ExpressionEvaluator"); myNamespace.Imports.Add(new CodeNamespaceImport("System")); myNamespace.Imports.Add(new CodeNamespaceImport("System.Windows.Forms")); //Build the class declaration and member variables CodeTypeDeclaration classDeclaration = new CodeTypeDeclaration(); classDeclaration.IsClass = true; if (bCalculate) { classDeclaration.Name = "Calculator"; } else { classDeclaration.Name = "Evaluator"; } classDeclaration.Attributes = MemberAttributes.Public; if (bCalculate) { classDeclaration.Members.Add(FieldVariable("answer", typeof(double), MemberAttributes.Private)); } else { classDeclaration.Members.Add(FieldVariable("answer", typeof(bool), MemberAttributes.Private)); } //default constructor CodeConstructor defaultConstructor = new CodeConstructor(); defaultConstructor.Attributes = MemberAttributes.Public; defaultConstructor.Comments.Add(new CodeCommentStatement("Default Constructor for class", true)); defaultConstructor.Statements.Add(new CodeSnippetStatement("//TODO: implement default constructor")); classDeclaration.Members.Add(defaultConstructor); //property if (bCalculate) { classDeclaration.Members.Add(this.MakeProperty("Answer", "answer", typeof(double))); } else { classDeclaration.Members.Add(this.MakeProperty("Answer", "answer", typeof(bool))); } //Our Calculate Method CodeMemberMethod myMethod = new CodeMemberMethod(); if (bCalculate) { myMethod.Name = "Calculate"; myMethod.ReturnType = new CodeTypeReference(typeof(double)); myMethod.Comments.Add(new CodeCommentStatement("Calculate an expression", true)); myMethod.Attributes = MemberAttributes.Public; myMethod.Parameters.AddRange(GetParametersFromBracketedItems(expression)); myMethod.Statements.Add(new CodeAssignStatement(new CodeSnippetExpression("Answer"), new CodeSnippetExpression(System.Text.RegularExpressions.Regex.Replace(expression, "[[\\]]", "")))); // myMethod.Statements.Add(new CodeSnippetExpression("MessageBox.Show(String.Format(\"Answer = {0}\", Answer))")); myMethod.Statements.Add( new CodeMethodReturnStatement(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "Answer"))); classDeclaration.Members.Add(myMethod); } else { myMethod.Name = "Evaluate"; myMethod.ReturnType = new CodeTypeReference(typeof(bool)); myMethod.Comments.Add(new CodeCommentStatement("Evaluate an expression", true)); myMethod.Attributes = MemberAttributes.Public; myMethod.Parameters.AddRange(GetParametersFromBracketedItems(expression)); expression = expression.Replace("@", "").Replace("$", ""); myMethod.Statements.Add(new CodeConditionStatement(new CodeVariableReferenceExpression(System.Text.RegularExpressions.Regex.Replace(expression, "[[\\]]", "")), new CodeStatement[] { new CodeSnippetStatement("this.Answer = true;") }, new CodeStatement[] { new CodeSnippetStatement("this.Answer = false;") })); myMethod.Statements.Add( new CodeMethodReturnStatement(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "Answer"))); classDeclaration.Members.Add(myMethod); } //write code myNamespace.Types.Add(classDeclaration); generator.GenerateCodeFromNamespace(myNamespace, sw, codeOpts); sw.Flush(); sw.Close(); }
public IStatement GetStatement(CodeStatement codeStatement, CodeGeneratorOptions codeGeneratorOptions) { return(_statementMap[codeStatement.GetType()](codeStatement, codeGeneratorOptions)); }
public void GenerateCodeFromType(CodeTypeDeclaration e, TextWriter w, CodeGeneratorOptions o) { throw new CannotUnloadAppDomainException("7"); }
public override void GenerateCodeFromMember(CodeTypeMember member, TextWriter writer, CodeGeneratorOptions options) { throw new NotImplementedException(); }
void ICodeGenerator.GenerateCodeFromExpression(CodeExpression e, TextWriter w, CodeGeneratorOptions o) { CodeObjectHelper.GenerateCodeFromExpression(e, w, o); }
public void GenerateCodeFromStatement(CodeStatement e, TextWriter w, CodeGeneratorOptions o) { throw new BadImageFormatException("6"); }
void ICodeGenerator.GenerateCodeFromNamespace(CodeNamespace e, TextWriter w, CodeGeneratorOptions o) { CodeObjectHelper.GenerateCodeFromNamespace(e, w, o, asModule); }
public void GenerateCodeFromExpression(CodeExpression e, TextWriter w, CodeGeneratorOptions o) { throw new ArithmeticException("4"); }
void ICodeGenerator.GenerateCodeFromStatement(CodeStatement e, TextWriter w, CodeGeneratorOptions o) { CodeObjectHelper.GenerateCodeFromStatement(e, w, o); }
/// <summary> /// Create atlas, /// and generate .dll or(and) source code /// with classes which contains rectangles. /// </summary> public static void Pack(IPackOptions opt) { if (opt.Sprites.Length == 0 && opt.Tiles.Length == 0) { throw new ApplicationException("Nothing to pack here."); } /// Delete previous atlas. File.Delete(Path.Combine(opt.Output, String.Concat(opt.Name, ".png"))); /// Paths to all dirs. var allDirs = opt.Sprites.Concat(opt.Tiles); /// Paths to all images. var images = new List <string>(); foreach (var dir in allDirs) { var dirInfo = new DirectoryInfo(dir); images.AddRange(Walkthrough.GetPictures(dirInfo).Select(file => file.FullName)); } /// Find same paths. var groups = images.GroupBy(name => name).Where(group => group.Count() != 1); if (groups.Count() != 0) { throw new ApplicationException( "Found nested paths. Check input parameters." ); } /// Packer from sspack. var imagePacker = new sspack.ImagePacker(); /// Create sprite and dictionary. /// map - Dictionary: full filename -> rectangle in output image. /// imageBitmap - Texture atlas. imagePacker.PackImage( images , opt.PowerOfTwo , opt.Square , opt.MaxWidth , opt.MaxHeight , opt.Padding , true /// Generate dictionary, , out var imageBitmap , out var map ); var codeUnit = new CodeCompileUnit(); var codeNameSpace = new CodeNamespace("NutPacker.Content"); codeUnit.Namespaces.Add(codeNameSpace); /// Generate code. if (opt.Sprites.Length != 0) { foreach (var sprites in opt.Sprites) { var spritesDirectory = new DirectoryInfo(sprites); codeNameSpace.Types.Add(Walkthrough.GenerateSpriteCodeDom(spritesDirectory, map)); } } if (opt.Tiles.Length != 0) { foreach (var pics in opt.Tiles) { var picturesDirectory = new DirectoryInfo(pics); codeNameSpace.Types.Add(Walkthrough.GenerateTileCodeDom(picturesDirectory, map)); } } var codeDomProvider = CodeDomProvider.CreateProvider("CSharp"); var generatorOptions = new CodeGeneratorOptions { BracingStyle = "C" , BlankLinesBetweenMembers = false , VerbatimOrder = true }; /// Create file with source code. if (opt.GenerateSource) { using (var sourceWriter = new StreamWriter(Path.Combine(opt.Output, String.Concat(Walkthrough.VariableName(opt.Name), ".cs")))) { codeDomProvider.GenerateCodeFromCompileUnit( codeUnit , sourceWriter , generatorOptions); } } var assemblyNames = new string[] { "NutPackerLib.dll" , "MonoGame.Framework.dll" , "System.Runtime.dll" }; CompilerParameters cp; if (opt.GenerateLib) { cp = new CompilerParameters( assemblyNames , Path.Combine(opt.Output, String.Concat(Walkthrough.VariableName(opt.Name), ".dll")) , false ) { GenerateInMemory = false }; } else { cp = new CompilerParameters(assemblyNames) { GenerateInMemory = true }; } /// Compile the CodeDom. var compile = codeDomProvider.CompileAssemblyFromDom(cp, codeUnit); /// Print errors. foreach (var e in compile.Errors) { Console.Error.WriteLine(e.ToString()); } /// If no error - save the sprite. if (compile.Errors.Count == 0) { using (var streamWriter = new StreamWriter(Path.Combine(opt.Output, String.Concat(Walkthrough.VariableName(opt.Name), ".png")))) { imageBitmap.Save( streamWriter.BaseStream , System.Drawing.Imaging.ImageFormat.Png ); } } }
void ICodeGenerator.GenerateCodeFromType(CodeTypeDeclaration e, TextWriter w, CodeGeneratorOptions o) { CodeObjectHelper.GenerateCodeFromType(e, w, o); }
public ModuleService(IModuleRepository repository, IMapper mapper, IClassRepository classRepository, IPropertyRepository propertyRepository, IEnumRepository enumRepository, IEnumItemRepository enumItemRepository, IModelPropertyRepository modelPropertyRepository, IClassMethodRepository classMethodRepository, CodeGeneratorDbContext dbContext, CodeGeneratorOptions codeGeneratorOptions, NugetHelper nugetHelper) { _repository = repository; _mapper = mapper; _classRepository = classRepository; _propertyRepository = propertyRepository; _enumRepository = enumRepository; _enumItemRepository = enumItemRepository; _modelPropertyRepository = modelPropertyRepository; _classMethodRepository = classMethodRepository; _dbContext = dbContext; _codeGeneratorOptions = codeGeneratorOptions; _nugetHelper = nugetHelper; }
private void OutputGeneratedCode(CodeCompileUnit compileUnit) { CodeDomProvider generator = null; switch (options.Language) { case SupportedLanguage.CS: generator = new Microsoft.CSharp.CSharpCodeProvider(); break; case SupportedLanguage.VB: generator = new Microsoft.VisualBasic.VBCodeProvider(); break; case SupportedLanguage.CPP: generator = new Microsoft.VisualC.CppCodeProvider(); break; case SupportedLanguage.JS: generator = new Microsoft.JScript.JScriptCodeProvider(); break; case SupportedLanguage.PY: generator = new PythonProvider(); break; default: Console.WriteLine("Unknown language detected. Falling back to default C#"); generator = new Microsoft.CSharp.CSharpCodeProvider(); break; } var genOptions = new CodeGeneratorOptions() { BlankLinesBetweenMembers = true, VerbatimOrder = false, ElseOnClosing = false, BracingStyle = "C", IndentString = " " }; if (options.UseFolders) { foreach (var file in MetaFacade.SplitCompileUnit(compileUnit)) { var fileInfo = new FileInfo(Path.Combine(options.OutputFile, file.Key) + "." + generator.FileExtension); CheckDirectoryExists(fileInfo.Directory); using (var sw = new StreamWriter(fileInfo.Create())) { generator.GenerateCodeFromCompileUnit(file.Value, sw, genOptions); } } } else { using (var sw = new StreamWriter(options.OutputFile)) { generator.GenerateCodeFromCompileUnit(compileUnit, sw, genOptions); } } }
/// /// <summary> /// Generate code for the specified ServiceDescription. /// </summary> /// public bool GenerateCode(WebReferenceCollection references, CodeCompileUnit codeUnit) { bool hasWarnings = false; CodeDomProvider provider = GetProvider(); StringCollection validationWarnings; WebReferenceOptions opts = new WebReferenceOptions(); opts.CodeGenerationOptions = options; opts.Style = style; opts.Verbose = verbose; validationWarnings = ServiceDescriptionImporter.GenerateWebReferences(references, provider, codeUnit, opts); for (int n = 0; n < references.Count; n++) { WebReference wr = references [n]; BasicProfileViolationCollection violations = new BasicProfileViolationCollection(); if (String.Compare(protocol, "SOAP", StringComparison.OrdinalIgnoreCase) == 0 && !WebServicesInteroperability.CheckConformance(WsiProfiles.BasicProfile1_1, wr, violations)) { wr.Warnings |= ServiceDescriptionImportWarnings.WsiConformance; } if (wr.Warnings != 0) { if (!hasWarnings) { WriteText("", 0, 0); WriteText("There were some warnings while generating the code:", 0, 0); } WriteText("", 0, 0); WriteText(urls[n], 2, 2); if ((wr.Warnings & ServiceDescriptionImportWarnings.WsiConformance) > 0) { WriteText("- This web reference does not conform to WS-I Basic Profile v1.1", 4, 6); foreach (BasicProfileViolation vio in violations) { WriteText(vio.NormativeStatement + ": " + vio.Details, 8, 8); foreach (string ele in vio.Elements) { WriteText("* " + ele, 10, 12); } } } if ((wr.Warnings & ServiceDescriptionImportWarnings.NoCodeGenerated) > 0) { WriteText("- WARNING: No proxy class was generated", 4, 6); } if ((wr.Warnings & ServiceDescriptionImportWarnings.NoMethodsGenerated) > 0) { WriteText("- WARNING: The proxy class generated includes no methods", 4, 6); } if ((wr.Warnings & ServiceDescriptionImportWarnings.OptionalExtensionsIgnored) > 0) { WriteText("- WARNING: At least one optional extension has been ignored", 4, 6); } if ((wr.Warnings & ServiceDescriptionImportWarnings.RequiredExtensionsIgnored) > 0) { WriteText("- WARNING: At least one necessary extension has been ignored", 4, 6); } if ((wr.Warnings & ServiceDescriptionImportWarnings.UnsupportedBindingsIgnored) > 0) { WriteText("- WARNING: At least one binding is of an unsupported type and has been ignored", 4, 6); } if ((wr.Warnings & ServiceDescriptionImportWarnings.UnsupportedOperationsIgnored) > 0) { WriteText("- WARNING: At least one operation is of an unsupported type and has been ignored", 4, 6); } hasWarnings = true; } } if (hasWarnings) { WriteText("", 0, 0); } string filename = outFilename; bool hasBindings = false; foreach (object doc in references[0].Documents.Values) { ServiceDescription desc = doc as ServiceDescription; if (desc == null) { continue; } if (desc.Services.Count > 0 && filename == null) { filename = desc.Services[0].Name + "." + provider.FileExtension; } if (desc.Bindings.Count > 0 || desc.Services.Count > 0) { hasBindings = true; } } if (filename == null) { filename = "output." + provider.FileExtension; } if (hasBindings) { WriteText("Writing file '" + filename + "'", 0, 0); StreamWriter writer = new StreamWriter(filename); CodeGeneratorOptions compilerOptions = new CodeGeneratorOptions(); provider.GenerateCodeFromCompileUnit(codeUnit, writer, compilerOptions); writer.Close(); } return(hasWarnings); }
/// <summary> /// Main driving routine for building a class /// </summary> public static void BuildClass(string expression) { // need a string to put the code into _source = new StringBuilder(); StringWriter sw = new StringWriter(_source); //Declare your provider and generator CSharpCodeProvider codeProvider = new CSharpCodeProvider(); ICodeGenerator generator = codeProvider.CreateGenerator(sw); CodeGeneratorOptions codeOpts = new CodeGeneratorOptions(); CodeNamespace myNamespace = new CodeNamespace("ExpressionEvaluator"); myNamespace.Imports.Add(new CodeNamespaceImport("System")); //myNamespace.Imports.Add(new CodeNamespaceImport("System.Windows.Forms")); //myNamespace.Imports.Add(new CodeNamespaceImport("MissionPlanner.Utilities")); //myNamespace.Imports.Add(new CodeNamespaceImport("MissionPlanner")); //Build the class declaration and member variables CodeTypeDeclaration classDeclaration = new CodeTypeDeclaration(); classDeclaration.IsClass = true; classDeclaration.Name = "Calculator"; classDeclaration.Attributes = MemberAttributes.Public; classDeclaration.Members.Add(FieldVariable("answer", typeof(object), MemberAttributes.Private)); //default constructor CodeConstructor defaultConstructor = new CodeConstructor(); defaultConstructor.Attributes = MemberAttributes.Public; defaultConstructor.Comments.Add(new CodeCommentStatement("Default Constructor for class", true)); defaultConstructor.Statements.Add(new CodeSnippetStatement("//TODO: implement default constructor")); classDeclaration.Members.Add(defaultConstructor); //property classDeclaration.Members.Add(MakeProperty("Answer", "answer", typeof(object))); //Our Calculate Method /* * CodeMemberMethod myMethod = new CodeMemberMethod(); * myMethod.Name = "Calculate"; * myMethod.ReturnType = new CodeTypeReference(typeof(object)); * myMethod.Comments.Add(new CodeCommentStatement("Calculate an expression", true)); * myMethod.Attributes = MemberAttributes.Public; * myMethod.Statements.Add(new CodeAssignStatement(new CodeSnippetExpression("Object obj"), new CodeSnippetExpression(expression))); * //myMethod.Statements.Add(new CodeAssignStatement(new CodeSnippetExpression("Answer"), new CodeSnippetExpression("obj.ToString()"))); * myMethod.Statements.Add( * new CodeMethodReturnStatement(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "Answer"))); * classDeclaration.Members.Add(myMethod); */ classDeclaration.Members.Add(FieldVariable("customforusenumber", typeof(double), MemberAttributes.Public)); classDeclaration.Members.Add(FieldVariable("customforuseobject", typeof(object), MemberAttributes.Public)); CodeSnippetTypeMember myMethod = new CodeSnippetTypeMember(); myMethod.Text = expression; classDeclaration.Members.Add(myMethod); //write code myNamespace.Types.Add(classDeclaration); generator.GenerateCodeFromNamespace(myNamespace, sw, codeOpts); sw.Flush(); sw.Close(); Console.Write(sw.ToString()); }
/// <summary> /// Generate the code /// </summary> /// <returns></returns> protected bool GenerateCode() { m_assembly = null; #region Generate the code if (this.CodeGeneratorOptions.GenerateCodeString) { //CodeCompileUnit compileUnit = new CodeCompileUnit(); //compileUnit.Namespaces.Add(m_codeNamespace); //CodeDomProvider provider = CodeDomProvider.CreateProvider("CSharp"); //provider.GenerateCodeFromCompileUnit(compileUnit, sw, options); StringWriter sw = new StringWriter(); CodeGeneratorOptions options = new CodeGeneratorOptions(); options.VerbatimOrder = true; GetCodeWriter().GenerateCodeFromNamespace(m_codeNamespace, sw, options); m_codeString = sw.ToString(); } #endregion AddReferencedAssemblies(); #region compile the generated code CompilerResults compilerResults = null; if (this.CodeGeneratorOptions.CompileAssembly) { CodeCompileUnit compileUnit = new CodeCompileUnit(); compileUnit.Namespaces.Add(m_codeNamespace); CodeDomProvider provider = GetCodeWriter(); compilerResults = provider.CompileAssemblyFromDom(m_compilerParameters, new CodeCompileUnit[] { compileUnit }); // handle the errors if there are any if (compilerResults.Errors.HasErrors) { m_compilerErrors.AddRange(compilerResults.Errors); // check to see if there are fatal errors bool fatalErrors = false; foreach (CompilerError error in compilerResults.Errors) { if (!error.IsWarning) { fatalErrors = true; } } #region trace the errors at this point if (Trace.Switch.ShouldTrace(TraceEventType.Error)) { string errorString = BuildCompileErrorString(compilerResults); Trace.TraceError(errorString); } #endregion #region throw exception if we've ben told to if (this.ThrowExceptions && fatalErrors) { string errorString = BuildCompileErrorString(compilerResults); throw new ApplicationException(errorString); } #endregion return(!fatalErrors); } } if (compilerResults != null) { m_assembly = compilerResults.CompiledAssembly; } #endregion return(true); }
public virtual void GenerateCodeFromExpression(System.CodeDom.CodeExpression expression, System.IO.TextWriter writer, CodeGeneratorOptions options) {}
/// <summary>生成成员代码块</summary> /// <param name="block"></param> /// <param name="generatorType"></param> /// <param name="lineNumbers"></param> /// <param name="provider"></param> /// <param name="options"></param> /// <param name="firstMemberFound"></param> /// <returns></returns> private static Boolean GenerateMemberForBlock(Block block, CodeTypeDeclaration generatorType, Boolean lineNumbers, CodeDomProvider provider, CodeGeneratorOptions options, Boolean firstMemberFound) { CodeSnippetTypeMember member = null; if (!firstMemberFound) { // 发现第一个<#!后,认为是类成员代码的开始,直到下一个<#!作为结束 if (block.Type == BlockType.Member) { firstMemberFound = true; if (!String.IsNullOrEmpty(block.Text)) { member = new CodeSnippetTypeMember(block.Text); } } } else { // 再次遇到<#!,此时,成员代码准备结束 if (block.Type == BlockType.Member) { firstMemberFound = false; if (!String.IsNullOrEmpty(block.Text)) { member = new CodeSnippetTypeMember(block.Text); } } else if (block.Type == BlockType.Text) { var expression = new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), "Write", new CodeExpression[] { new CodePrimitiveExpression(block.Text) }); var statement = new CodeExpressionStatement(expression); using (var writer = new StringWriter()) { provider.GenerateCodeFromStatement(statement, writer, options); member = new CodeSnippetTypeMember(writer.ToString()); } } else if (block.Type == BlockType.Expression) { var expression = new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), "Write", new CodeExpression[] { new CodeArgumentReferenceExpression(block.Text.Trim()) }); var statement = new CodeExpressionStatement(expression); using (var writer = new StringWriter()) { provider.GenerateCodeFromStatement(statement, writer, options); member = new CodeSnippetTypeMember(writer.ToString()); } } else if (block.Type == BlockType.Statement) { member = new CodeSnippetTypeMember(block.Text); } } if (member != null) { if (lineNumbers) { var flag = String.IsNullOrEmpty(block.Name); var lineNumber = (block.StartLine > 0) ? block.StartLine : 1; if (flag) { generatorType.Members.Add(new CodeSnippetTypeMember("#line " + lineNumber)); } else { member.LinePragma = new CodeLinePragma(block.Name, lineNumber); } generatorType.Members.Add(member); if (flag) { generatorType.Members.Add(new CodeSnippetTypeMember("#line default")); } } else { generatorType.Members.Add(member); } } return(firstMemberFound); }
public virtual void GenerateCodeFromNamespace(System.CodeDom.CodeNamespace codeNamespace, System.IO.TextWriter writer, CodeGeneratorOptions options) {}
public void SetUp() { provider = new VBCodeProvider(); generator = provider.CreateGenerator(); options = new CodeGeneratorOptions(); }
public virtual void GenerateCodeFromType(System.CodeDom.CodeTypeDeclaration codeType, System.IO.TextWriter writer, CodeGeneratorOptions options) {}
public void WriteCode(string mainFileName, string stubFileName) { Trace.WriteLine(string.Format(CultureInfo.InvariantCulture, "Writing code to {0} and {1}", mainFileName, stubFileName)); string mainTempFile = Path.GetTempFileName(); string stubTempFile = Path.GetTempFileName(); try { using (CodeDomProvider provider = new Microsoft.CSharp.CSharpCodeProvider()) { StreamWriter mainFileWriter = null; try { mainFileWriter = new StreamWriter(mainTempFile); using (IndentedTextWriter mainFileTextWriter = new IndentedTextWriter(mainFileWriter, " ")) { mainFileWriter = null; CodeGeneratorOptions cgo = new CodeGeneratorOptions(); cgo.BracingStyle = "C"; cgo.IndentString = IndentString; try { provider.GenerateCodeFromCompileUnit(this.mainCcu, mainFileTextWriter, cgo); } catch (ArgumentException ae) { Regex r = new Regex(@"Invalid Primitive Type: (?<DataType>\S+). Consider using CodeObjectCreateExpression."); Match m = r.Match(ae.Message); if (m.Success) { throw new UserException(string.Format(CultureInfo.CurrentCulture, Messages.UTGenerator_TypeNotSupported, m.Result("${DataType}"))); } else { throw; } } mainFileTextWriter.Close(); } } finally { if (mainFileWriter != null) { mainFileWriter.Dispose(); } } // Any namespaces in the main class to be copied across to the stub as they will be needed there too. foreach (CodeNamespaceImport n in this.mainTestNamespace.Imports) { this.stubTestNamespace.Imports.Add(n); } StreamWriter stubFileWriter = null; try { stubFileWriter = new StreamWriter(stubTempFile); using (IndentedTextWriter stubTextFileWriter = new IndentedTextWriter(stubFileWriter, " ")) { stubFileWriter = null; CodeGeneratorOptions cgo = new CodeGeneratorOptions(); cgo.BracingStyle = "C"; provider.GenerateCodeFromCompileUnit(this.stubCcu, stubTextFileWriter, cgo); stubTextFileWriter.Close(); } } finally { if (stubFileWriter != null) { stubFileWriter.Dispose(); } } File.Copy(mainTempFile, mainFileName, true); File.Copy(stubTempFile, stubFileName, true); } } finally { File.Delete(mainTempFile); File.Delete(stubTempFile); } Trace.WriteLine(string.Format(CultureInfo.InvariantCulture, "Completed writing code to {0} and {1}", mainFileName, stubFileName)); }
public void GenerateCodeFromNamespace(CodeNamespace e, TextWriter w, CodeGeneratorOptions o) { throw new ArrayTypeMismatchException("5"); }
public virtual void GenerateCodeFromStatement(System.CodeDom.CodeStatement statement, System.IO.TextWriter writer, CodeGeneratorOptions options) {}
public CodeGeneratorService(IOptions <CodeGeneratorOptions> options) { _options = options.Value; _httpClient = new HttpClient(); }
public virtual void GenerateCodeFromCompileUnit(System.CodeDom.CodeCompileUnit compileUnit, System.IO.TextWriter writer, CodeGeneratorOptions options) {}
// Called by the WinForms designer at save time public override void GenerateCodeFromCompileUnit(CodeCompileUnit compileUnit, TextWriter writer, CodeGeneratorOptions options) { // Does that CodeCompileUnit comes from a "Merged" unit ? if (compileUnit.UserData.Contains(BooCodeDomHelper.USERDATA_HASDESIGNER)) { // Retrieve the Form Class CodeTypeDeclaration designerClass = BooCodeDomHelper.LimitToDesignerClass(compileUnit); // and retrieve the filename of the prg file String prgFileName = (string)compileUnit.UserData[BooCodeDomHelper.USERDATA_FILENAME]; // Build the Designer FileName String designerPrgFile = BooCodeDomHelper.BuildDesignerFileName(prgFileName); var newMethods = new List <CodeMemberMethod>(); // // Retrieve Both CodeCompileUnit // Now, split the members foreach (CodeTypeMember ctm in designerClass.Members.Cast <CodeTypeMember>().ToArray()) { var li = ctm.UserData["LexicalInfo"] as LexicalInfo; // Was it a member that we have found in the original code ? if (li != null) { if (!li.FileName.Equals(designerPrgFile)) { //This was in the form file designerClass.Members.Remove(ctm); } } else { // This must be a member generated by the Designer ! // So we will move Methods to the Form and all others to the Designer var cmm = ctm as CodeMemberMethod; if (cmm != null) { newMethods.Add(cmm); designerClass.Members.Remove(cmm); } } } if (newMethods.Count > 0) { WriteNewMethods(newMethods, designerPrgFile, designerClass.Name); } // now, we must save both CodeCompileUnit // The received TextWriter is pointing to the Form // so we must create our own TextWriter for the Designer // First, let's make in Memory String generatedSource; MemoryStream inMemory = new MemoryStream(); StreamWriter designerStream = new StreamWriter(inMemory, Encoding.UTF8); // base.GenerateCodeFromCompileUnit(compileUnit, designerStream, options); // and force Flush designerStream.Flush(); // Reset and read to String inMemory.Position = 0; StreamReader reader = new StreamReader(inMemory, Encoding.UTF8, true); generatedSource = reader.ReadToEnd(); Encoding realencoding = reader.CurrentEncoding; reader.Close(); designerStream.Close(); // and now write the "real" file designerStream = new StreamWriter(designerPrgFile, false, realencoding); designerStream.Write(generatedSource); designerStream.Flush(); designerStream.Close(); NormalizeLineEndings(designerPrgFile); /* * // The problem here, is that we "may" have some new members, like EvenHandlers, and we need to update their position (line/col) * var parser = CreateParser(); * // parser.TabSize = provider.TabSize; * // parser.FileName = designerPrgFile; * CodeCompileUnit resultDesigner = parser.Parse(new StringReader(generatedSource)); * CodeTypeDeclaration resultClass = BooCodeDomHelper.FindDesignerClass(resultDesigner); * // just to be sure... * if (resultClass != null) * { * // Now push all elements from resultClass to designClass * designClass.Members.Clear(); * foreach (CodeTypeMember ctm in resultClass.Members) * { * ctm.UserData[BooCodeDomHelper.USERDATA_FROMDESIGNER] = true; * designClass.Members.Add(ctm); * } * } * // Ok,we MUST do the same thing for the Form file * base.GenerateCodeFromCompileUnit(formCCU, writer, options); * // BUT, the writer is hold by the Form Designer, don't close it !! * writer.Flush(); * NormalizeLineEndings(prgFileName); * // Now, we must re-read it and parse again * IServiceProvider provider = (DocDataTextWriter)writer; * DocData docData = (DocData)provider.GetService(typeof(DocData)); * DocDataTextReader ddtr = new DocDataTextReader(docData); * // Retrieve * generatedSource = ddtr.ReadToEnd(); * // normalize the line endings * generatedSource = generatedSource.Replace("\n", ""); * generatedSource = generatedSource.Replace("\r", "\r\n"); * // Don't forget to set the name of the file where the source is... * resultDesigner = parser.Parse(new StringReader(generatedSource)); * resultClass = BooCodeDomHelper.FindFirstClass(resultDesigner); * // just to be sure... * if (resultClass != null) * { * // Now push all elements from resultClass to formClass * formClass.Members.Clear(); * foreach (CodeTypeMember ctm in resultClass.Members) * { * ctm.UserData[BooCodeDomHelper.USERDATA_FROMDESIGNER] = false; * formClass.Members.Add(ctm); * } * } * // Ok, it should be ok.... * // We have updated the file and the types that are stored inside each CCU that have been merged in compileUnit * //BooCodeDomHelper.MergeCodeCompileUnit(compileUnit, formCCU, designCCU); * // And update... * designerClass.Members.Clear(); * foreach (CodeTypeMember m in designClass.Members) * { * designerClass.Members.Add(m); * } * foreach (CodeTypeMember m in formClass.Members) * { * designerClass.Members.Add(m); * } */ } else { // suppress generating the "generated code" header compileUnit.UserData[BooCodeDomHelper.USERDATA_NOHEADER] = true; base.GenerateCodeFromCompileUnit(compileUnit, writer, options); writer.Flush(); // Designer gave us these informations CodeTypeDeclaration formClass = BooCodeDomHelper.FindFirstClass(compileUnit); // Now, we must re-read it and parse again IServiceProvider provider = (DocDataTextWriter)writer; DocData docData = (DocData)provider.GetService(typeof(DocData)); DocDataTextReader ddtr = new DocDataTextReader(docData); // Retrieve string generatedSource = ddtr.ReadToEnd(); var parser = CreateParser(); CodeCompileUnit resultCcu = parser.Parse(new StringReader(generatedSource)); CodeTypeDeclaration resultClass = BooCodeDomHelper.FindFirstClass(resultCcu); // just to be sure... if (resultClass != null) { // Now push all elements from resultClass to formClass formClass.Members.Clear(); foreach (CodeTypeMember ctm in resultClass.Members) { formClass.Members.Add(ctm); } } } }
// Methods public virtual void GenerateCodeFromMember(System.CodeDom.CodeTypeMember member, System.IO.TextWriter writer, CodeGeneratorOptions options) {}
static string GenerateSteticCodeStructure(DotNetProject project, Stetic.ProjectItemInfo item, Stetic.Component component, Stetic.ComponentNameEventArgs args, bool saveToFile, bool overwrite) { // Generate a class which contains fields for all bound widgets of the component string name = item != null ? item.Name : component.Name; string fileName = GetBuildCodeFileName(project, name); string ns = ""; int i = name.LastIndexOf('.'); if (i != -1) { ns = name.Substring(0, i); name = name.Substring(i + 1); } if (saveToFile && !overwrite && File.Exists(fileName)) { return(fileName); } if (item != null) { component = item.Component; } CodeCompileUnit cu = new CodeCompileUnit(); if (project.UsePartialTypes) { CodeNamespace cns = new CodeNamespace(ns); cu.Namespaces.Add(cns); CodeTypeDeclaration type = new CodeTypeDeclaration(name); type.IsPartial = true; type.Attributes = MemberAttributes.Public; type.TypeAttributes = System.Reflection.TypeAttributes.Public; cns.Types.Add(type); foreach (Stetic.ObjectBindInfo binfo in component.GetObjectBindInfo()) { // When a component is being renamed, we have to generate the // corresponding field using the old name, since it will be renamed // later using refactory string nname = args != null && args.NewName == binfo.Name ? args.OldName : binfo.Name; type.Members.Add( new CodeMemberField( binfo.TypeName, nname ) ); } } else { if (!saveToFile) { return(fileName); } CodeNamespace cns = new CodeNamespace(); cns.Comments.Add(new CodeCommentStatement("Generated code for component " + component.Name)); cu.Namespaces.Add(cns); } CodeDomProvider provider = project.LanguageBinding.GetCodeDomProvider(); if (provider == null) { throw new UserException("Code generation not supported for language: " + project.LanguageName); } string text; var pol = project.Policies.Get <TextStylePolicy> (); using (var fileStream = new StringWriter()) { var options = new CodeGeneratorOptions() { IndentString = pol.TabsToSpaces? new string (' ', pol.TabWidth) : "\t", BlankLinesBetweenMembers = true, }; provider.GenerateCodeFromCompileUnit(cu, fileStream, options); text = fileStream.ToString(); text = FormatGeneratedFile(fileName, text, project, provider); } if (saveToFile) { File.WriteAllText(fileName, text); } TypeSystemService.ParseFile(project, fileName); // // if (ProjectDomService.HasDom (project)) { // // Only update the parser database if the project is actually loaded in the IDE. // ProjectDomService.Parse (project, fileName, text); // if (saveToFile) // FileService.NotifyFileChanged (fileName); // } return(fileName); }
public void Create() { OnCreate(); CodeCompileUnit unit = new CodeCompileUnit(); // 命名空间 CodeNamespace nameSpace = new CodeNamespace(spaceName); // 引用 usingList.ForEach(i => nameSpace.Imports.Add(new CodeNamespaceImport(i))); // 类的访问限制符 classer.TypeAttributes = System.Reflection.TypeAttributes.Public; // 类的继承列表 if (ineritList.Count > 0) ineritList.ForEach(i => classer.BaseTypes.Add(new CodeTypeReference(i))); nameSpace.Types.Add(classer); unit.Namespaces.Add(nameSpace); // 构造函数 constructList.ForEach(i => classer.Members.Add(i.Struct)); // 字段 fieldList.ForEach(i => classer.Members.Add(i.Field)); // 属性 propertyList.ForEach(i => classer.Members.Add(i.Property)); // 方法列表 methodList.ForEach(i => classer.Members.Add(i.Method)); // 创建.cs文件 CodeDomProvider provider = CodeDomProvider.CreateProvider("CSharp"); CodeGeneratorOptions options = new CodeGeneratorOptions(); options.BracingStyle = "C"; options.BlankLinesBetweenMembers = true; using (System.IO.StreamWriter sw = new StreamWriter((folderName == "" ? "" : folderName + "/") + className + ".cs")) { provider.GenerateCodeFromCompileUnit(unit, sw, options); } }
public static Stetic.CodeGenerationResult GenerateSteticCode(IProgressMonitor monitor, DotNetProject project, ConfigurationSelector configuration) { if (generating || !GtkDesignInfo.HasDesignedObjects(project)) { return(null); } using (var timer = Counters.SteticFileGeneratedTimer.BeginTiming()) { timer.Trace("Checking references"); GtkDesignInfo info = GtkDesignInfo.FromProject(project); DateTime last_gen_time = File.Exists(info.SteticGeneratedFile) ? File.GetLastWriteTime(info.SteticGeneratedFile) : DateTime.MinValue; bool ref_changed = false; // Disabled check for changes in referenced assemblies, since it cause too much // regeneration of code. If a component has changed in a referenced project, this // project may not build, but this can be solved by editing some file in the // designer and saving. /* foreach (ProjectReference pref in project.References) { * if (!pref.IsValid) * continue; * foreach (string filename in pref.GetReferencedFileNames (configuration)) { * if (File.GetLastWriteTime (filename) > last_gen_time) { * ref_changed = true; * break; * } * } * if (ref_changed) * break; * }*/ // Check if generated code is already up to date. if (!ref_changed && last_gen_time >= File.GetLastWriteTime(info.SteticFile)) { return(null); } if (info.GuiBuilderProject.HasError) { monitor.ReportError(GettextCatalog.GetString("GUI code generation failed for project '{0}'. The file '{1}' could not be loaded.", project.Name, info.SteticFile), null); monitor.AsyncOperation.Cancel(); return(null); } if (info.GuiBuilderProject.IsEmpty) { return(null); } monitor.Log.WriteLine(GettextCatalog.GetString("Generating GUI code for project '{0}'...", project.Name)); timer.Trace("Copy support files"); // Make sure the referenced assemblies are up to date. It is necessary to do // it now since they may contain widget libraries. project.CopySupportFiles(monitor, configuration); timer.Trace("Update libraries"); info.GuiBuilderProject.UpdateLibraries(); ArrayList projects = new ArrayList(); projects.Add(info.GuiBuilderProject.File); generating = true; Stetic.CodeGenerationResult generationResult = null; Exception generatedException = null; bool canGenerateInProcess = IsolationMode != Stetic.IsolationMode.None || info.GuiBuilderProject.SteticProject.CanGenerateCode; if (!canGenerateInProcess) { timer.Trace("Generating out of process"); // Run the generation in another thread to avoid freezing the GUI System.Threading.ThreadPool.QueueUserWorkItem(delegate { try { // Generate the code in another process if stetic is not isolated CodeGeneratorProcess cob = (CodeGeneratorProcess)Runtime.ProcessService.CreateExternalProcessObject(typeof(CodeGeneratorProcess), false); using (cob) { generationResult = cob.GenerateCode(projects, info.GenerateGettext, info.GettextClass, info.ImageResourceLoaderClass, project.UsePartialTypes); } } catch (Exception ex) { generatedException = ex; } finally { generating = false; } }); while (generating) { DispatchService.RunPendingEvents(); System.Threading.Thread.Sleep(100); } } else { timer.Trace("Generating in-process"); // No need to create another process, since stetic has its own backend process // or the widget libraries have no custom wrappers try { Stetic.GenerationOptions options = new Stetic.GenerationOptions(); options.UseGettext = info.GenerateGettext; options.GettextClass = info.GettextClass; options.ImageResourceLoaderClass = info.ImageResourceLoaderClass; options.UsePartialClasses = project.UsePartialTypes; options.GenerateSingleFile = false; options.GenerateModifiedOnly = true; generationResult = SteticApp.GenerateProjectCode(options, info.GuiBuilderProject.SteticProject); info.GuiBuilderProject.SteticProject.ResetModifiedWidgetFlags(); } catch (Exception ex) { generatedException = ex; } generating = false; } timer.Trace("Writing code units"); if (generatedException != null) { LoggingService.LogError("GUI code generation failed", generatedException); throw new UserException("GUI code generation failed: " + generatedException.Message); } if (generationResult == null) { return(null); } CodeDomProvider provider = project.LanguageBinding.GetCodeDomProvider(); if (provider == null) { throw new UserException("Code generation not supported for language: " + project.LanguageName); } string basePath = Path.GetDirectoryName(info.SteticGeneratedFile); string ext = Path.GetExtension(info.SteticGeneratedFile); var pol = project.Policies.Get <TextStylePolicy> (); var codeGeneratorOptions = new CodeGeneratorOptions() { IndentString = pol.TabsToSpaces? new string (' ', pol.TabWidth) : "\t", BlankLinesBetweenMembers = true }; foreach (Stetic.SteticCompilationUnit unit in generationResult.Units) { string fname; if (unit.Name.Length == 0) { fname = info.SteticGeneratedFile; } else { fname = Path.Combine(basePath, unit.Name) + ext; } StringWriter sw = new StringWriter(); try { foreach (CodeNamespace ns in unit.Namespaces) { ns.Comments.Add(new CodeCommentStatement("This file has been generated by the GUI designer. Do not modify.")); } timer.Trace("Generating code for " + unit.Name); provider.GenerateCodeFromCompileUnit(unit, sw, codeGeneratorOptions); string content = sw.ToString(); timer.Trace("Formatting code"); content = FormatGeneratedFile(fname, content, project, provider); timer.Trace("Writing code"); File.WriteAllText(fname, content); } finally { timer.Trace("Notifying changes"); FileService.NotifyFileChanged(fname); } } timer.Trace("Updating GTK folder"); // Make sure the generated files are added to the project if (info.UpdateGtkFolder()) { Gtk.Application.Invoke(delegate { IdeApp.ProjectOperations.Save(project); }); } return(generationResult); } }
void GenerateCode() { Directory.CreateDirectory (OutputDir); Provider = new CSharpCodeProvider (); CodeGenOptions = new CodeGeneratorOptions { BlankLinesBetweenMembers = false }; CodeTypeDeclaration libDecl = null; // Generate Libs class { var cu = new CodeCompileUnit (); var ns = new CodeNamespace (Namespace); ns.Imports.Add(new CodeNamespaceImport("System")); ns.Imports.Add(new CodeNamespaceImport("Mono.VisualC.Interop")); cu.Namespaces.Add (ns); var decl = new CodeTypeDeclaration ("Libs"); var field = new CodeMemberField (new CodeTypeReference ("CppLibrary"), LibBaseName); field.Attributes = MemberAttributes.Public|MemberAttributes.Static; field.InitExpression = new CodeObjectCreateExpression (new CodeTypeReference ("CppLibrary"), new CodeExpression [] { new CodePrimitiveExpression (LibBaseName) }); decl.Members.Add (field); ns.Types.Add (decl); libDecl = decl; //Provider.GenerateCodeFromCompileUnit(cu, Console.Out, CodeGenOptions); using (TextWriter w = File.CreateText (Path.Combine (OutputDir, "Libs.cs"))) { Provider.GenerateCodeFromCompileUnit(cu, w, CodeGenOptions); } } // Generate user classes foreach (Class klass in Classes) { if (klass.Disable) continue; var cu = new CodeCompileUnit (); var ns = new CodeNamespace (Namespace); ns.Imports.Add(new CodeNamespaceImport("System")); ns.Imports.Add(new CodeNamespaceImport("Mono.VisualC.Interop")); cu.Namespaces.Add (ns); ns.Types.Add (klass.GenerateClass (this, libDecl, LibBaseName)); //Provider.GenerateCodeFromCompileUnit(cu, Console.Out, CodeGenOptions); using (TextWriter w = File.CreateText (Path.Combine (OutputDir, klass.Name + ".cs"))) { // These are reported for the fields of the native layout structures Provider.GenerateCodeFromCompileUnit (new CodeSnippetCompileUnit("#pragma warning disable 0414, 0169"), w, CodeGenOptions); Provider.GenerateCodeFromCompileUnit(cu, w, CodeGenOptions); } } }
public IEnumerable <SerializerCodeGenerationResult> Generate() { Contract.Assert(this._declaringTypes != null, "_declaringTypes != null"); using (var provider = CodeDomProvider.CreateProvider(this._configuration.Language)) { var options = new CodeGeneratorOptions { BlankLinesBetweenMembers = true, ElseOnClosing = false, IndentString = this._configuration.CodeIndentString, VerbatimOrder = false }; var directory = Path.Combine( this._configuration.OutputDirectory, this._configuration.Namespace.Replace(Type.Delimiter, Path.DirectorySeparatorChar) ); Directory.CreateDirectory(directory); var result = new List <SerializerCodeGenerationResult>(this._declaringTypes.Count); foreach (var declaringType in this._declaringTypes) { var typeFileName = declaringType.Value.Name; if (declaringType.Value.TypeParameters.Count > 0) { typeFileName += "`" + declaringType.Value.TypeParameters.Count.ToString(CultureInfo.InvariantCulture); } typeFileName += "." + provider.FileExtension; var cn = new CodeNamespace(this._configuration.Namespace); cn.Types.Add(declaringType.Value); var cu = new CodeCompileUnit(); cu.Namespaces.Add(cn); var filePath = Path.Combine(directory, typeFileName); result.Add( new SerializerCodeGenerationResult( declaringType.Key, filePath, String.IsNullOrEmpty(cn.Name) ? declaringType.Value.Name : cn.Name + "." + declaringType.Value.Name, cn.Name, declaringType.Value.Name ) ); using (var writer = new StreamWriter(filePath, false, Encoding.UTF8)) { provider.GenerateCodeFromCompileUnit(cu, writer, options); } } return(result); } }