public static void AddNode(CompilationUnit /*!*/ compilationUnit)
{
if (!DrawGraph)
{
return;
}
if (compilationUnit is ScriptCompilationUnit)
{
SourceUnit sourceUnit = ((ScriptCompilationUnit)compilationUnit).SourceUnit;
int node_id;
if (!sourceUnits.TryGetValue(sourceUnit, out node_id))
{
sourceUnits.Add(sourceUnit, node_id = nodeId++);
}
output.Write(node_id);
output.Write(" [label=\"");
output.Write(sourceUnit.SourceFile.RelativePath);
output.WriteLine("\"];");
}
else
{
output.Write(-1);
output.Write(" [label=\"ReflectedUnit\"];");
}
output.Flush();
}
public static void Write(string Message, bool Flush = false)
{
lock (_syncObject)
{
Writer.Write(Message);
if (Flush)
{
Writer.Flush();
}
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Writes the event to the logger.
/// </summary>
/// <param name="message">The message.</param>
/// ------------------------------------------------------------------------------------
private void WriteEventInternal(string message)
{
CheckDisposed();
if (m_out != null)
{
IntPtr mainWndHandle = Process.GetCurrentProcess().MainWindowHandle;
int handleInfo = mainWndHandle != IntPtr.Zero ? mainWndHandle.ToInt32() : 0;
// We don't want to indent the date...
m_out.Write(string.Format("{0} [0x{1:x}]\t", Now, handleInfo));
// ...but we want to indent all following lines (note: the first (current) line
// won't be indented)
m_out.Indent++;
if (message != null)
{
string[] lines = message.Split(new string[] { Environment.NewLine, "\n" },
StringSplitOptions.None);
foreach (string line in lines)
{
m_out.WriteLine(line);
}
}
else
{
m_out.WriteLine("Unknown event");
}
m_out.Indent--;
m_out.Flush(); //in case we crash
}
}
public static void Init()
{
// Test that we are able to open and write to the file
FileStream fStream = File.Open(FilePath, FileMode.Create, FileAccess.ReadWrite, FileShare.ReadWrite);
Writer = new IndentedTextWriter(new StreamWriter(fStream));
// Write some starting info
Writer.WriteLine("-------- BF2 Gamespy Redirector Trace Log --------");
Writer.WriteLine("Logging Start: " + DateTime.Now.ToString());
Writer.WriteLine("Program Version: " + Program.Version.ToString());
Writer.WriteLine("OS Version: " + Environment.OSVersion.VersionString);
Writer.WriteLine("Environment Type: " + ((Environment.Is64BitOperatingSystem) ? "x64" : "x86"));
Writer.WriteLine("Installed .NET Versions:");
Writer.Indent++;
try
{
string path = @"SOFTWARE\Microsoft\NET Framework Setup\NDP";
RegistryKey InstalledVersions = Registry.LocalMachine.OpenSubKey(path);
string[] versions = InstalledVersions.GetSubKeyNames();
for (int i = 0; i < versions.Length; i++)
{
Writer.WriteLine(versions[i].ToString() + " SP" + InstalledVersions.OpenSubKey(versions[i]).GetValue("SP"));
}
}
catch (Exception e)
{
Writer.WriteLine("ERROR: " + e.Message);
}
Writer.Indent--;
Writer.Flush();
}
public void GenerateItemConstructorsWithNames()
{
string fileName = Path.GetTempPath() + "Items_constructors_" + Guid.NewGuid() + ".txt";
using FileStream file = File.OpenWrite(fileName);
var writer = new IndentedTextWriter(new StreamWriter(file));
writer.Indent += 2;
writer.WriteLine();
var itemStates = ItemFactory.Itemstates.Values;
foreach (Itemstate state in itemStates)
{
Item item = ItemFactory.GetItem(state.Id);
if (!string.IsNullOrEmpty(item.Name))
{
continue;
}
string clazzName = CodeName(state.Name.Replace("minecraft:", ""), true);
string minecraftName = state.Name;
writer.WriteLine($"public Item{clazzName}() : base(\"{minecraftName}\", {state.Id})");
}
writer.Flush();
}
protected override void GenerateTable(System.Data.DataTable table)
{
StringWriter sw = new StringWriter();
IndentedTextWriter tw = new IndentedTextWriter(sw);
tw.WriteLine("CREATE TABLE {0} (",
formatTableName(table)
);
tw.Indent++;
bool comma = false;
foreach (DataColumn column in table.Columns)
{
if (comma)
{
tw.WriteLine(",");
}
else
{
comma = true;
}
GenerateColumn(column, tw);
}
tw.WriteLine(")");
tw.Indent--;
tw.Flush();
this.Admin.ExecuteNonQuery(ConnectionString, sw.ToString());
}
/// <summary>
/// Converts a unit of CodeDOM code into the C# source equivalent
/// </summary>
public static string CompileToCSharpSourceCode(this CodeCompileUnit code)
{
var providerOptions = new Dictionary <string, string>();
if (Environment.Version.Major < 4)
{
providerOptions.Add("CompilerVersion", "v3.5");
}
var compiler = new CSharpCodeProvider(providerOptions);
string result;
using (var sourceStream = new MemoryStream())
{
var tw = new IndentedTextWriter(new StreamWriter(sourceStream), "\t");
compiler.GenerateCodeFromCompileUnit(code, tw, new CodeGeneratorOptions());
tw.Flush();
sourceStream.Seek(0, SeekOrigin.Begin);
result = new StreamReader(sourceStream).ReadToEnd();
}
return(result);
}
public void Execute(SourceGeneratorContext context)
{
context.AddCompiledOnMetadataAttribute();
var compilation = context.Compilation;
var types = CompilationHelper.GetAllTypes(context.Compilation.Assembly);
using (var stringWriter = new StringWriter())
using (var indentedTextWriter = new IndentedTextWriter(stringWriter, " "))
{
var defaultToStringGenerator = new DefaultToStringGenerator(context);
foreach (var type in types)
{
if (DefaultToStringGenerator.ShouldUseGenerator(type))
{
defaultToStringGenerator.WriteType(type, indentedTextWriter);
}
}
indentedTextWriter.Flush();
stringWriter.Flush();
var sourceText = SourceText.From(stringWriter.ToString(), Encoding.UTF8);
var hintName = $"AutoToString_{compilation.Assembly.Name}.g.cs";
context.AddSource(hintName, sourceText);
}
}
private static string BuildMessage(IEnumerable <DbEntityValidationResult> validationResults)
{
var result = new StringWriter();
var writer = new IndentedTextWriter(result, "\t");
foreach (var entityError in validationResults)
{
var entity = (dynamic)entityError.Entry.Entity;
writer.Indent++;
writer.WriteLine("{0} Id = {1}", entityError.Entry.Entity, entity.Id);
writer.Indent++;
foreach (var validationError in entityError.ValidationErrors)
{
writer.WriteLine("{0}.{1}: {2}",
GetEntityType(entityError.Entry),
validationError.PropertyName,
validationError.ErrorMessage);
}
writer.Indent--;
writer.Indent--;
}
writer.Flush();
return(result.ToString());
}
static void ExtractMessageScripts()
{
using (Writer = new IndentedTextWriter(FileUtils.CreateText($".\\MessageScriptDump.txt")))
{
if (UseDecompiler)
{
Decompiler = new MessageScriptDecompiler(Writer);
}
foreach (var file in Directory.EnumerateFiles(DirectoryPath, "*.*", SearchOption.AllDirectories))
{
#if !DEBUG
try
#endif
{
ExtractMessageScript(file, File.OpenRead(file), null);
}
#if !DEBUG
catch (Exception e)
{
Console.WriteLine($"File \"{file}\" threw exception: {e.Message}");
}
#endif
}
Writer.Flush();
}
Console.WriteLine("Done.");
//Console.ReadKey();
}
/// <summary>
/// Generates a value type implementation for forValueType.
/// </summary>
/// <returns>true if generated, false if skipped</returns>
public bool GenerateValueTypeImpl(Type forValueType)
{
// create the fileName from targetDirectory and
// full type name
string fileName = forValueType.FullName;
fileName = fileName.Replace(".", "_") + "." + m_codeDomProvider.FileExtension;
fileName = Path.Combine(m_targetDir.FullName, fileName);
if (File.Exists(fileName) && !m_overwriteWhenExist)
{
Console.WriteLine("skip generation for " +
forValueType.FullName +
" because implementation file " +
fileName + " already exists ");
return(false);
}
StreamWriter targetStream = new StreamWriter(fileName, false);
IndentedTextWriter writer = new IndentedTextWriter(targetStream);
GenerateValueTypeImplToFile(forValueType, writer);
writer.Flush();
writer.Close();
return(true);
}
private static void CreateDataTypeRegisterMethod(CodeNamespace codeNamespace, TypeInfo dataTypeInfo, CodeGenerationInfo generationInfo)
{
using (IndentedTextWriter tw = new IndentedTextWriter(new StringWriter()))
{
tw.WriteLine("void register_{0}()", dataTypeInfo.Name);
tw.WriteLine("{");
tw.Indent++;
tw.WriteLine("static ntreev::crema::enum_info enumData({0});", dataTypeInfo.IsFlag.ToString().ToLower());
tw.WriteLine("if(ntreev::crema::enum_util::contains(typeid({0})) == true)", dataTypeInfo.Name);
tw.Indent++;
tw.WriteLine("return;");
tw.Indent--;
foreach (var item in dataTypeInfo.Members)
{
tw.WriteLine("enumData.add(\"{0}_{1}\", {0}_{1});", dataTypeInfo.Name, item.Name);
}
tw.WriteLine("ntreev::crema::enum_util::add(typeid({0}), &enumData);", dataTypeInfo.Name);
tw.Indent--;
tw.Write("}");
tw.Flush();
codeNamespace.AddCppStatement(tw.InnerWriter.ToString());
}
}
public static void WriteCode(this CodeNamespace @namespace, CodeDomProvider provider, TextWriter textWriter, CodeGeneratorOptions options)
{
if (@namespace == null)
{
throw new ArgumentNullException("namespace");
}
if (provider == null)
{
throw new ArgumentNullException("provider");
}
if (textWriter == null)
{
throw new ArgumentNullException("textWriter");
}
CodeGenerator.ValidateIdentifiers(@namespace);
if (textWriter is IndentedTextWriter)
{
provider.GenerateCodeFromNamespace(@namespace, textWriter, options);
}
else
{
using (IndentedTextWriter indentedWriter = new IndentedTextWriter(textWriter))
{
provider.GenerateCodeFromNamespace(@namespace, indentedWriter, options);
indentedWriter.Flush();
}
}
}
public static string ToString(DiscoveryResult discoveryResult)
{
using var stringWriter = new StringWriter();
using var writer = new IndentedTextWriter(stringWriter);
writer.WriteLine("digraph dependencies {");
writer.Indent++;
foreach (var project in discoveryResult.Projects)
{
writer.WriteLine($"\"{project.Id}\" [label=\"{project.Name}\", fillcolor=\"{ProjectBackgroundColor}\", style=filled];");
}
foreach (var package in discoveryResult.Packages)
{
writer.WriteLine($"\"{package.Id}\" [label=\"{package.Name}\", fillcolor=\"{PackageBackgroundColor}\", style=filled];");
}
foreach (var reference in discoveryResult.References)
{
writer.WriteLine($"\"{reference.From}\" -> \"{reference.To}\";");
}
writer.Indent--;
writer.WriteLine("}");
writer.Flush();
return(stringWriter.ToString());
}
public static void DumpProjectItems(DTE dte)
{
StringWriter sw = new StringWriter();
IndentedTextWriter tw = new IndentedTextWriter(sw);
tw.WriteLine(dte.Solution.FullName);
System.Collections.IEnumerator en = dte.Solution.GetEnumerator();
while (en.MoveNext())
{
if (en.Current is ProjectItem)
{
tw.Indent++;
tw.WriteLine(((ProjectItem)en.Current).Name);
DumpProjectItems(((ProjectItem)en.Current).ProjectItems, tw);
tw.Indent--;
}
else if (en.Current is Project)
{
Project p = en.Current as Project;
tw.Indent++;
tw.WriteLine(p.Name + " (" + p.Kind + ")");
DumpProjectItems(p.ProjectItems, tw);
tw.Indent--;
}
}
tw.Flush();
System.Diagnostics.Debugger.Log(0, "Debug", sw.ToString());
}
public void GenerateMissingItemsFromItemsStates()
{
string fileName = Path.GetTempPath() + "MissingItems_" + Guid.NewGuid() + ".txt";
using FileStream file = File.OpenWrite(fileName);
var writer = new IndentedTextWriter(new StreamWriter(file));
var itemStates = ItemFactory.Itemstates.Values;
List <Itemstate> newItems = new List <Itemstate>();
foreach (Itemstate state in itemStates)
{
var item = ItemFactory.GetItem(state.Id);
if (item.GetType() == typeof(Item))
{
newItems.Add(state);
Console.WriteLine($"New item: {state.Id}, {state.Name}");
string clazzName = CodeName(state.Name.Replace("minecraft:", ""), true);
string baseClazz = "Item";
baseClazz = clazzName.EndsWith("Axe") ? "ItemAxe" : baseClazz;
baseClazz = clazzName.EndsWith("Shovel") ? "ItemShovel" : baseClazz;
baseClazz = clazzName.EndsWith("Pickaxe") ? "ItemPickaxe" : baseClazz;
baseClazz = clazzName.EndsWith("Hoe") ? "ItemHoe" : baseClazz;
baseClazz = clazzName.EndsWith("Sword") ? "ItemSword" : baseClazz;
baseClazz = clazzName.EndsWith("Helmet") ? "ArmorHelmetBase" : baseClazz;
baseClazz = clazzName.EndsWith("Chestplate") ? "ArmorChestplateBase" : baseClazz;
baseClazz = clazzName.EndsWith("Leggings") ? "ArmorLeggingsBase" : baseClazz;
baseClazz = clazzName.EndsWith("Boots") ? "ArmorBootsBase" : baseClazz;
baseClazz = clazzName.EndsWith("Door") ? "ItemWoodenDoor" : baseClazz;
writer.WriteLine($"public class Item{clazzName} : {baseClazz} {{ public Item{clazzName}() : base({state.Id}) {{}} }}");
}
}
writer.Flush();
foreach (Itemstate state in newItems.OrderBy(s => s.Id))
{
string clazzName = CodeName(state.Name.Replace("minecraft:", ""), true);
writer.WriteLine($"else if (id == {state.Id}) item = new Item{clazzName}();");
}
writer.Flush();
}
static void WriteMessageScriptWithDecompiler(string name, MessageScript script)
{
Writer.WriteLine(name);
Decompiler.Decompile(script);
Writer.WriteLine();
Writer.Flush();
}
public void Flush_CallsUnderlyingFlush()
{
var indicator = new IndicatingTextWriter();
var itw = new IndentedTextWriter(indicator);
itw.Flush();
Assert.Equal(nameof(IndentedTextWriter.Flush), indicator.LastCalledMethod);
}
public static void DumpUIHierarchy(UIHierarchy hierarchy)
{
StringWriter sw = new StringWriter();
IndentedTextWriter tw = new IndentedTextWriter(sw);
DumpUIHierarchyItems(hierarchy.UIHierarchyItems, tw);
tw.Flush();
System.Diagnostics.Debugger.Log(0, "Debug", sw.ToString());
}
public override bool Generate(System.Reflection.Assembly refAssembly, System.Reflection.Assembly mscorlibAssembly, ClassUtil.ExcelImporter imp, string outputPath, string sFileName, ref int current, ref int max, string language, List <string> except)
{
try
{
string createFileName = System.Text.RegularExpressions.Regex.Replace(sFileName, @"\.[x][l][s]?\w", ".h");
using (MemoryStream stream = new MemoryStream())
{
var _writer = new IndentedTextWriter(new StreamWriter(stream, new System.Text.ASCIIEncoding()), " ");
{
string filename = System.IO.Path.GetFileName(createFileName);
_writer.WriteLineEx($"// generate {filename}");
_writer.WriteLineEx("// DO NOT TOUCH SOURCE....");
_writer.WriteLineEx($"#ifndef {filename.Replace(".","_").ToUpper()}");
_writer.WriteLineEx($"#define {filename.Replace(".", "_").ToUpper()}");
_writer.WriteLineEx($"#include <memory>");
_writer.WriteLineEx($"#include <string>");
_writer.WriteLineEx($"#include <vector>");
_writer.WriteLineEx($"#include <map>");
string[] sheets = imp.GetSheetList();
filename = filename.Replace(".h", string.Empty);
max = sheets.GetLength(0);
current = 0;
_writer.WriteLineEx($"namespace {ExportToCSMgr.NameSpace}");
_writer.WriteLineEx("{");
_writer.WriteLineEx($"namespace {filename}");
_writer.WriteLineEx("{");
foreach (string sheetName in sheets)
{
current++;
string trimSheetName = sheetName.Trim().Replace(" ", "_");
var rows = imp.GetSheetShortCut(sheetName, language);
var columns = ExportBaseUtil.GetColumnInfo(refAssembly, mscorlibAssembly, trimSheetName, rows, except);
SheetProcess(_writer, filename, trimSheetName, columns);
}
_writer.WriteLineEx("};");
_writer.WriteLineEx("};");
_writer.WriteLineEx($"#endif //{filename.Replace(".", "_").ToUpper()}");
_writer.Flush();
}
ExportBaseUtil.CheckReplaceFile(stream, $"{outputPath}/{createFileName}");
}
}
catch (System.Exception ex)
{
Console.Write(ex.Message);
return(false);
}
return(true);
}
private static void WriteInventoryToFile(string fileName, MetadataEntry[] slots)
{
Log.Info($"Writing inventory to filename: {fileName}");
FileStream file = File.OpenWrite(fileName);
IndentedTextWriter writer = new IndentedTextWriter(new StreamWriter(file));
writer.WriteLine("// GENERATED CODE. DON'T EDIT BY HAND");
writer.Indent++;
writer.Indent++;
writer.WriteLine("public static List<ItemStack> CreativeInventoryItems = new List<ItemStack>()");
writer.WriteLine("{");
writer.Indent++;
foreach (var entry in slots)
{
MetadataSlot slot = (MetadataSlot)entry;
NbtCompound extraData = slot.Value.ExtraData;
if (extraData == null)
{
writer.WriteLine($"new ItemStack({slot.Value.Id}, {slot.Value.Count}, {slot.Value.Metadata}),");
}
else
{
Log.Debug($"Nbt: " + extraData.ToString());
NbtList ench = (NbtList)extraData["ench"];
NbtCompound enchComp = (NbtCompound)ench[0];
var id = enchComp["id"].ShortValue;
var lvl = enchComp["lvl"].ShortValue;
writer.WriteLine($"new ItemStack({slot.Value.Id}, {slot.Value.Count}, {slot.Value.Metadata}){{ExtraData = new NbtCompound {{new NbtList(\"ench\") {{new NbtCompound {{new NbtShort(\"id\", {id}), new NbtShort(\"lvl\", {lvl}) }} }} }} }},");
}
}
new ItemStack(0, 0, 0)
{
ExtraData = new NbtCompound {
new NbtList("ench")
{
new NbtCompound {
new NbtShort("id", 0), new NbtShort("lvl", 0)
}
}
}
};
//var compound = new NbtCompound(string.Empty) { new NbtList("ench", new NbtCompound()) {new NbtShort("id", 0),new NbtShort("lvl", 0),}, };
writer.Indent--;
writer.WriteLine("};");
writer.Indent--;
writer.Indent--;
writer.Flush();
file.Close();
}
public string ToIndentedString()
{
var sb = new StringBuilder();
var sw = new StringWriter(sb);
IndentedTextWriter tw = new IndentedTextWriter(sw, " ");
this.WriteIndentedString(tw);
tw.Flush();
return(sb.ToString());
}
public static string PrintException(Exception ex)
{
var strWriter = new StringWriter();
var indentedWriter = new IndentedTextWriter(strWriter);
PrintException(indentedWriter, ex);
indentedWriter.WriteLine(StackTraceUtility.ExtractStringFromException(ex));
indentedWriter.Flush();
strWriter.Flush();
return(strWriter.ToString());
}
protected override void EndProcessing()
{
base.BeginProcessing();
try
{
try
{
if (Provider == null)
{
_provider.Dispose();
}
}
finally
{
if (Writer == null)
{
try
{
try
{
_indentedWriter.Flush();
_writer.Flush();
_writer.ToString();
}
finally { _indentedWriter.Dispose(); }
}
finally { _writer.Dispose(); }
}
else if (!(Writer is IndentedTextWriter))
{
try { _indentedWriter.Flush(); }
finally { _indentedWriter.Dispose(); }
}
}
}
catch (Exception exc)
{
WriteError(new ErrorRecord(exc, "WriterCloseError", ErrorCategory.CloseError, null));
}
}
private MemoryStream BuildScript(Menu scenesMenu, string namespaceName, string className, ClassQualifiers classQualifiers, int menuPriority)
{
MemoryStream memStream = new MemoryStream();
StreamWriter streamWriter = new StreamWriter(memStream, Encoding.UTF8);
IndentedTextWriter indentWriter = new IndentedTextWriter(streamWriter);
streamWriter.NewLine = "\n";
indentWriter.NewLine = "\n";
indentWriter.WriteLine("using UnityEngine;");
indentWriter.WriteLine("using UnityEditor;");
indentWriter.WriteLine();
bool isPartial = (classQualifiers & ClassQualifiers.Partial) != 0;
bool isStatic = (classQualifiers & ClassQualifiers.Static) != 0;
bool usingNameSpace = !string.IsNullOrEmpty(namespaceName);
if (usingNameSpace)
{
indentWriter.WriteLine("namespace {0} {{", namespaceName);
indentWriter.Indent++;
}
indentWriter.WriteLine("public {1}{2}class {0} {{", className, isStatic ? "static " : "", isPartial ? "partial " : "");
indentWriter.Indent++;
WritePrefix(indentWriter);
int priority = menuPriority + 12; // start at higher priority so that we get a separator after the Rebuild options.
WriteMenu(indentWriter, scenesMenu, "", "", priority);
WritePostfix(indentWriter);
indentWriter.Indent--;
indentWriter.WriteLine("}");
if (usingNameSpace)
{
indentWriter.Indent--;
indentWriter.WriteLine("}");
}
indentWriter.Flush();
streamWriter.Flush();
memStream.Flush();
return(memStream);
}
/// <summary>
/// Prints a UnityEngine.GameObject, along with its components and children. Prints properties of components, but not of GameObjects, and doesn't print GameObjects in properties.
/// </summary>
/// <param name="o">The game object to print</param>
/// <param name="componentFilter">A filter that says which components to print fully (printing their properties). By default, all will be expanded.</param>
/// <param name="gameObjectFilter">A filter that says which GameObject children to print recursively (e.g. print their components and their children). Only the names of filtered children will appear.</param>
/// <returns></returns>
public static string PrintUnityGameObject(GameObject o, Func <GameObject, bool> gameObjectFilter = null, Func <Component, bool> componentFilter = null)
{
componentFilter = componentFilter ?? (x => true);
gameObjectFilter = gameObjectFilter ?? (x => true);
var dumper = new UnityObjectDumper();
var strWriter = new StringWriter();
var identedWriter = new IndentedTextWriter(strWriter, "\t");
dumper.PrintUnityGameObject(o, identedWriter, gameObjectFilter, componentFilter);
identedWriter.Flush();
strWriter.Flush();
return(strWriter.ToString());
}
/// <summary>
/// Retorna a representação string da consulta SQL.
/// </summary>
/// <returns>A representação string da consulta SQL.</returns>
public override string ToString()
{
var sb = new StringBuilder();
using (var sw = new StringWriter(sb))
using (var tw = new IndentedTextWriter(sw))
{
Render(tw);
tw.Flush();
}
return(sb.ToString());
}
/// <summary>
/// Writes the class file. This method actually creates the physical
/// class file and populates it accordingly.
/// </summary>
/// <param name="className">Name of the class file to be written.</param>
/// <param name="codeNamespace">
/// The CodeNamespace which represents the
/// file to be written.
/// </param>
private void WriteClassFile(string className, CodeNamespace codeNamespace)
{
CSharpCodeProvider cSharpCodeProvider = new CSharpCodeProvider( );
string sourceFile = OutputDirectory + Path.DirectorySeparatorChar + className + "." + cSharpCodeProvider.FileExtension;
sourceFile = Utility.ScrubPathOfIllegalCharacters(sourceFile);
IndentedTextWriter indentedTextWriter = new IndentedTextWriter(new StreamWriter(sourceFile, false), " ");
CodeGeneratorOptions codeGenerationOptions = new CodeGeneratorOptions( );
codeGenerationOptions.BracingStyle = "C";
cSharpCodeProvider.GenerateCodeFromNamespace(codeNamespace, indentedTextWriter, codeGenerationOptions);
indentedTextWriter.Flush( );
indentedTextWriter.Close( );
}
/// <summary>
/// Generates and returns the generated output
/// </summary>
/// <param name="inputFileName">The name of the file the custom tool is being run against</param>
/// <param name="inputFileContent">The contents of the file the custom tool is being run against</param>
protected override byte[] GenerateCode(string inputFileName, string inputFileContent)
{
GadgeteerModel model = LoadGadgeteerModel(inputFileName);
if (model == null)
{
OnError("Unable to load model: {0}", inputFileName);
return(null);
}
string userCodeFileName = Path.ChangeExtension(inputFileName, CodeProvider.FileExtension);
model.GenerateUsingsInUserCode(GlobalServiceProvider, userCodeFileName);
CodeCompileUnit code = new CodeCompileUnit();
CodeTypeDeclaration programClass;
CodeStatementCollection mainStatements;
CodeStatementCollection initializeModuleStatements;
CodeMemberProperty mainboard;
GenerateFileHeader(inputFileName, code, out programClass, out mainStatements, out initializeModuleStatements, out mainboard);
GenerateMainMethod(mainStatements, model);
GenerateModulesDeclaration(programClass, model);
GenerateModulesInitialization(initializeModuleStatements, model);
GenerateMainboardProperty(mainboard, model);
if (model.Store != null)
{
model.Store.Dispose();
}
using (MemoryStream codeStream = new MemoryStream())
{
IndentedTextWriter codeWriter = new IndentedTextWriter(new StreamWriter(codeStream));
try
{
CodeProvider.GenerateCodeFromCompileUnit(code, codeWriter, null);
}
catch (Exception compileException)
{
OnError("Code generation failed: {0}", compileException.Message);
return(new byte[0]);
}
codeWriter.Flush();
return(codeStream.ToArray());
}
}
private void GenerateDebugInfo(CodeCompileUnit compileUnit)
{
using (CSharpCodeProvider codeProvider = new CSharpCodeProvider())
{
CodeGeneratorOptions options = new CodeGeneratorOptions();
options.BracingStyle = "C";
using (IndentedTextWriter indentwriter = new IndentedTextWriter(debugOutput, " "))
{
codeProvider.GenerateCodeFromCompileUnit(compileUnit, indentwriter, options);
indentwriter.Flush();
indentwriter.Close();
}
}
}
