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