/// <summary>
/// Writes the constructor code to the specified output.
/// </summary>
/// <param name="output">The output.</param>
/// <param name="indentation">The current indentation.</param>
/// <param name="fields">The list of fields in the user type.</param>
/// <param name="constructorName">The constructor name.</param>
public void WriteCode(IndentedWriter output, int indentation, UserTypeField[] fields, string constructorName)
{
if (Static)
{
// Do nothing. We are initializing static variables in declaration statement because of the performance problems with generics.
}
else
{
output.WriteLine();
output.WriteLine(indentation, "public {0}({1})", constructorName, Arguments);
if (!string.IsNullOrEmpty(BaseClassInitialization))
{
output.WriteLine(indentation + 1, ": {0}", BaseClassInitialization);
}
output.WriteLine(indentation++, "{{");
if (ContainsFieldDefinitions)
{
foreach (var field in fields)
{
if (!field.CacheResult && !field.UseUserMember)
{
continue;
}
if (!field.Static)
{
field.WriteConstructorCode(output, indentation);
}
}
}
output.WriteLine(--indentation, "}}");
}
}
private void Object_BuildPrettyString(IndentedWriter writer)
{
writer.Write("{");
writer.Indent++;
var keys = Keys.AssertCast <String>();
if (keys.IsNotEmpty())
{
keys.ForEach((key, i) =>
{
writer.WriteLine();
writer.Write("\"{0}\" : ", key);
if (((IEnumerable)this[key].Keys).Cast <Object>().Count() > 0)
{
writer.WriteLine();
}
this[key].BuildPrettyString(writer);
if (i < this.Count() - 1)
{
writer.Write(",");
}
});
writer.WriteLine();
}
writer.Indent--;
writer.Write("}");
}
private void Array_BuildPrettyString(IndentedWriter writer)
{
writer.Write("[");
writer.Indent++;
var keys = Keys.AssertCast <int>();
if (keys.IsNotEmpty())
{
keys.ForEach((key, i) =>
{
(key == i).AssertTrue();
// todo. omg what's with these dynamic invocations?!
if (((IEnumerable)this[key].Keys).Cast <Object>().Count() > 0)
{
writer.WriteLine();
}
this[key].BuildPrettyString(writer);
if (i < this.Count() - 1)
{
writer.Write(",");
}
});
writer.WriteLine();
}
writer.Indent--;
writer.Write("]");
}
private static void WriteFileHeader(IndentedWriter writer)
{
writer.WriteLine("// WARNING: This file is generated by Epoxy. Do not edit this file manually.");
writer.WriteLine("// -------------------------------------------------------------------------");
writer.WriteLine();
writer.WriteLine("using System.Runtime.InteropServices;");
writer.WriteLine();
}
private void WriteVariableNativeBindings(Variable variable, IndentedWriter writer)
{
writer.WriteLine($"[DllImport(\"{Configuration.DllFileName}\")]");
writer.WriteLine($"private static extern {ToCsReturnType(variable)} {ToNativeVariableGet(variable)}();");
writer.WriteLine($"[DllImport(\"{Configuration.DllFileName}\")]");
writer.WriteLine($"private static extern void {ToNativeVariableSet(variable)}({ToCsParameter(variable)});");
writer.WriteLine();
}
/// <summary>
/// Writes the class comment on the specified output.
/// </summary>
/// <param name="output">The output.</param>
/// <param name="indentation">The current indentation.</param>
protected override void WriteClassComment(IndentedWriter output, int indentation)
{
base.WriteClassComment(output, indentation);
output.WriteLine(indentation, "// ---------------------------------------------------");
output.WriteLine(indentation, "// Specializations of this class");
foreach (var type in SpecializedTypes)
{
output.WriteLine(indentation, "// {0}", type.Symbol.Name);
}
}
private void WriteCsFunction(Function function, IndentedWriter writer)
{
string returnType = ToCsReturnType(function.Return);
string qualifiers = function.IsStatic || !function.IsClassMember ? "static " : "";
writer.WriteLine($"public {qualifiers}{returnType} {ToPascalCase(function.Name)}{ToCsParameterString(function.Parameters)}");
using (Scope functionScope = writer.IndentBlock())
{
writer.WriteLine($@"{(returnType == "void" ? "" : "return ")}{ToNativeFunction(function)}({(string.Join(", ", function.Parameters.Select(parameter => parameter.Name)))});");
}
writer.WriteLine();
}
private void WriteCsVariable(Variable variable, IndentedWriter writer)
{
// TODO: is return type the right marshalling strategy here?
string qualifiers = variable.IsStatic || !variable.IsClassMember ? "static " : "";
writer.WriteLine($"public {qualifiers}{ToCsReturnType(variable)} {ToPascalCase(variable.Name)}");
using (Scope propertyScope = writer.IndentBlock())
{
writer.WriteLine($"get {{ return {ToNativeVariableGet(variable)}(); }}");
writer.WriteLine($"set {{ {ToNativeVariableSet(variable)}(value); }}");
}
writer.WriteLine();
}
/// <summary>
/// Writes the constructor code to the specified output.
/// </summary>
/// <param name="output">The output.</param>
/// <param name="indentation">The current indentation.</param>
public virtual void WriteConstructorCode(IndentedWriter output, int indentation)
{
if (string.IsNullOrEmpty(ConstantValue))
{
if (UseUserMember && CacheResult)
{
output.WriteLine(indentation, "{0} = UserMember.Create(() => {1});", FieldName, ConstructorText);
}
else if (CacheResult)
{
output.WriteLine(indentation, "{2}{0} = {1};", FieldName, ConstructorText, !Static ? "this." : "");
}
}
}
public override void GenerateLanguageBindings(Graph graph)
{
if (!Directory.Exists(Configuration.LanguageBindingsDirectory))
{
Directory.CreateDirectory(Configuration.LanguageBindingsDirectory);
}
foreach (Class classDefinition in graph.Classes)
{
WriteCsClass(classDefinition, Path.Combine(Configuration.LanguageBindingsDirectory, $"{ToPascalCase(classDefinition.Name)}.cs"));
}
using (IndentedWriter writer = new IndentedWriter($"{Path.Combine(Configuration.LanguageBindingsDirectory, Configuration.GlobalsClassName)}.cs"))
{
WriteFileHeader(writer);
writer.WriteLine($"namespace {Configuration.GlobalsNamespace}");
using (Scope namespaceScope = writer.IndentBlock())
{
writer.WriteLine($"public static class {Configuration.GlobalsClassName}");
using (Scope classScope = writer.IndentBlock())
{
// write out the functions
foreach (Function function in graph.Functions)
{
WriteCsFunction(function, writer);
}
// write out the variables
foreach (Variable variable in graph.Variables)
{
WriteCsVariable(variable, writer);
}
// write out the native bindings for the functions
foreach (Function function in graph.Functions)
{
WriteFunctionNativeBindings(function, writer);
}
// write out the native bindings for the variables
foreach (Variable variable in graph.Variables)
{
WriteVariableNativeBindings(variable, writer);
}
}
}
}
}
private void PrintNode(ParserNode.SingleChildNode node)
{
this.PrintIndent();
_w.WriteLine(node.ToString());
var t = this.Pop();
this.Push(t == _finishIndent ? _space : _skipIndent);
this.Push(_finishIndent);
node.Child.Visit(this);
this.Pop();
this.Pop();
this.Push(t);
}
/// <summary>
/// Writes the code for this user type to the specified output.
/// </summary>
/// <param name="output">The output.</param>
/// <param name="error">The error text writer.</param>
/// <param name="factory">The user type factory.</param>
/// <param name="generationFlags">The user type generation flags.</param>
/// <param name="indentation">The current indentation.</param>
public override void WriteCode(IndentedWriter output, TextWriter error, UserTypeFactory factory, UserTypeGenerationFlags generationFlags, int indentation = 0)
{
// Check if we need to write namespace
string nameSpace = (DeclaredInType as NamespaceUserType)?.FullClassName ?? Namespace;
if ((DeclaredInType == null || (!generationFlags.HasFlag(UserTypeGenerationFlags.SingleFileExport) && DeclaredInType is NamespaceUserType)) && !string.IsNullOrEmpty(nameSpace))
{
output.WriteLine(indentation, "namespace {0}", nameSpace);
output.WriteLine(indentation++, "{{");
}
// Write beginning of the enumeration
if (generationFlags.HasFlag(UserTypeGenerationFlags.GenerateFieldTypeInfoComment))
{
output.WriteLine(indentation, "// {0} (original name: {1})", ClassName, Symbol.Name);
}
if (AreValuesFlags())
{
output.WriteLine(indentation, @"[System.Flags]");
}
if (Symbol.Size != 0)
{
output.WriteLine(indentation, @"public enum {0} : {1}", ClassName, GetEnumBasicType(Symbol));
}
else
{
output.WriteLine(indentation, @"public enum {0}", ClassName);
}
output.WriteLine(indentation++, @"{{");
// Write values
foreach (var enumValue in Symbol.GetEnumValues())
{
output.WriteLine(indentation, "{0} = {1},", enumValue.Item1, enumValue.Item2);
}
// Enumeration end
output.WriteLine(--indentation, @"}}");
if ((DeclaredInType == null || (!generationFlags.HasFlag(UserTypeGenerationFlags.SingleFileExport) && DeclaredInType is NamespaceUserType)) && !string.IsNullOrEmpty(nameSpace))
{
output.WriteLine(--indentation, "}}");
}
}
public ParserState <TResult> EnterNode(ParserNode nextNode, bool offTree = false)
{
if (nextNode.Parent != this.CurrNode && !(this.CurrNode is ParserNode.RecursiveParserNode) && !offTree)
{
throw new InvalidOperationException();
}
if (_log != null)
{
_log.Push().WriteLine("EnterNode @{2} {0} --> {1}", this.CurrNode, nextNode, this.Reader.Location).Push();
if (this.CurrNode is ParserNode.RecursiveParserNode)
{
_log.WriteLine("Enter to recursion");
}
}
return(this.EnterNodeImpl(nextNode));
}
private void WriteCsClass(Class classDefinition, string filePath)
{
using (IndentedWriter writer = new IndentedWriter(filePath))
{
WriteFileHeader(writer);
writer.WriteLine($"namespace {ToCsNamespace(classDefinition.Namespace)}");
using (Scope namespaceScope = writer.IndentBlock())
{
string className = ToPascalCase(classDefinition.Name);
writer.WriteLine($"class {className} : SafeEpoxyHandle");
using (Scope classScope = writer.IndentBlock())
{
// write out the constructor, destructor, and the member functions
foreach (Function function in classDefinition.Functions)
{
WriteCsFunction(function, writer);
}
// write out the member variables
foreach (Variable variable in classDefinition.Variables)
{
WriteCsVariable(variable, writer);
}
// write out the native bindings for the functions
foreach (Function function in classDefinition.Functions)
{
WriteFunctionNativeBindings(function, writer);
}
// write out the native bindings for the variables
foreach (Variable variable in classDefinition.Variables)
{
WriteVariableNativeBindings(variable, writer);
}
}
}
}
}
public void BasicTest()
{
using var sw = new StringWriter();
using var iw = new IndentedWriter(sw)
{
IndentString = "#", NewLine = "\n"
};
Assert.Equal("\n", iw.NewLine);
Assert.Equal(sw.Encoding, iw.Encoding);
iw.WriteLine("line1");
iw.Write("line");
iw.IncreaseIndent();
iw.WriteLine("2");
iw.Write("line");
iw.Write('3');
iw.WriteLine();
iw.IncreaseIndent(2);
iw.WriteLine("line4");
iw.DecreaseIndent();
iw.WriteLine("line5");
iw.DecreaseIndent(6);
iw.WriteLine("line6");
Assert.Equal("line1\nline2\n#line3\n###line4\n##line5\nline6\n", sw.ToString());
}
/// <summary>
/// Writes the field code to the specified output.
/// </summary>
/// <param name="output">The output.</param>
/// <param name="indentation">The current indentation.</param>
/// <param name="generationFlags">The user type generation flags.</param>
public virtual void WriteFieldCode(IndentedWriter output, int indentation, UserTypeGenerationFlags generationFlags)
{
if (generationFlags.HasFlag(UserTypeGenerationFlags.GenerateFieldTypeInfoComment) && !string.IsNullOrEmpty(FieldTypeInfoComment))
{
output.WriteLine(indentation, FieldTypeInfoComment);
}
if (!string.IsNullOrEmpty(ConstantValue))
{
output.WriteLine(indentation, "public static {0} {1} = ({0}){2};", FieldType, FieldName, GetConstantValue());
}
else if (Static && !UseUserMember)
{
output.WriteLine(indentation, "{3} static {0} {1} = {2};", FieldType, FieldName, ConstructorText, Access);
}
else if (UseUserMember && CacheResult)
{
output.WriteLine(indentation, "{3}{4} {0}UserMember<{1}> {2};", Static ? "static " : "", FieldType, FieldName, Access, OverrideWithNew ? " new" : "");
}
else if (CacheResult)
{
output.WriteLine(indentation, "{3}{4} {0}{1} {2};", Static ? "static " : "", FieldType, FieldName, Access, OverrideWithNew ? " new" : "");
}
if (generationFlags.HasFlag(UserTypeGenerationFlags.GenerateFieldTypeInfoComment))
{
output.WriteLine();
}
}
/// <summary>
/// Writes the code for this user type to the specified output.
/// </summary>
/// <param name="output">The output.</param>
/// <param name="error">The error text writer.</param>
/// <param name="factory">The user type factory.</param>
/// <param name="generationFlags">The user type generation flags.</param>
/// <param name="indentation">The current indentation.</param>
public override void WriteCode(IndentedWriter output, TextWriter error, UserTypeFactory factory, UserTypeGenerationFlags generationFlags, int indentation = 0)
{
string[] namespaces = this.namespaces;
if (generationFlags.HasFlag(UserTypeGenerationFlags.GenerateNamespaceAsStaticClass))
{
namespaces = NamespaceSymbol.Split(".".ToCharArray());
}
// Declared In Type with namespace
if (DeclaredInType != null || generationFlags.HasFlag(UserTypeGenerationFlags.GenerateNamespaceAsStaticClass))
{
foreach (string innerClass in namespaces)
{
output.WriteLine(indentation, "public static partial class {0}", innerClass);
output.WriteLine(indentation++, @"{{");
}
}
else
{
output.WriteLine(indentation, "namespace {0}", Namespace);
output.WriteLine(indentation++, @"{{");
}
// Inner types
foreach (var innerType in InnerTypes)
{
output.WriteLine();
innerType.WriteCode(output, error, factory, generationFlags, indentation);
}
// Declared In Type with namespace
if (DeclaredInType != null || generationFlags.HasFlag(UserTypeGenerationFlags.GenerateNamespaceAsStaticClass))
{
foreach (string innerClass in namespaces)
{
output.WriteLine(--indentation, "}}");
}
}
else
{
output.WriteLine(--indentation, "}}");
}
}
/// <summary>
/// Writes the code for this user type to the specified output.
/// </summary>
/// <param name="output">The output.</param>
/// <param name="error">The error text writer.</param>
/// <param name="factory">The user type factory.</param>
/// <param name="generationFlags">The user type generation flags.</param>
/// <param name="indentation">The current indentation.</param>
public override void WriteCode(IndentedWriter output, TextWriter error, UserTypeFactory factory, UserTypeGenerationFlags generationFlags, int indentation = 0)
{
// Declared In Type with namespace
if (DeclaredInType != null)
{
foreach (string innerClass in namespaces)
{
output.WriteLine(indentation, "public static class {0}", innerClass);
output.WriteLine(indentation++, @"{{");
}
}
else
{
output.WriteLine(indentation, "namespace {0}", Namespace);
output.WriteLine(indentation++, @"{{");
}
// Inner types
foreach (var innerType in InnerTypes)
{
output.WriteLine();
innerType.WriteCode(output, error, factory, generationFlags, indentation);
}
// Declared In Type with namespace
if (DeclaredInType != null)
{
foreach (string innerClass in namespaces)
{
output.WriteLine(--indentation, "}}");
}
}
else
{
output.WriteLine(--indentation, "}}");
}
}
public virtual void visit()
{
if (cancellationRequestedChecker())
{
return;
}
try {
XmlDocument xmlDocument = ouSignedInWebSession.get(ouStudentUriString);
if (null == xmlDocument)
{
log.WriteLine("Error: failed to download: {0}", ouStudentUriString);
return;
}
xmlDocument.preserve("OuStudent.xml");
visit(xmlDocument);
}
catch (Exception exception) {
log.WriteLine("Unable to access: {0}, exception: {1}", ouStudentUriString, exception);
}
}
/// <summary>
/// Writes the code for this user type to the specified output.
/// </summary>
/// <param name="output">The output.</param>
/// <param name="error">The error text writer.</param>
/// <param name="factory">The user type factory.</param>
/// <param name="generationFlags">The user type generation flags.</param>
/// <param name="indentation">The current indentation.</param>
public override void WriteCode(IndentedWriter output, TextWriter error, UserTypeFactory factory, UserTypeGenerationFlags generationFlags, int indentation = 0)
{
// Check if we need to write namespace
string nameSpace = (DeclaredInType as NamespaceUserType)?.FullClassName ?? Namespace;
if ((DeclaredInType == null || (!generationFlags.HasFlag(UserTypeGenerationFlags.SingleFileExport) && DeclaredInType is NamespaceUserType)) && !string.IsNullOrEmpty(nameSpace))
{
output.WriteLine(indentation, "namespace {0}", nameSpace);
output.WriteLine(indentation++, "{{");
}
// Write beginning of the enumeration
if (generationFlags.HasFlag(UserTypeGenerationFlags.GenerateFieldTypeInfoComment))
output.WriteLine(indentation, "// {0} (original name: {1})", ClassName, Symbol.Name);
if (AreValuesFlags())
output.WriteLine(indentation, @"[System.Flags]");
if (Symbol.Size != 0)
output.WriteLine(indentation, @"public enum {0} : {1}", ClassName, GetEnumBasicType(Symbol));
else
output.WriteLine(indentation, @"public enum {0}", ClassName);
output.WriteLine(indentation++, @"{{");
// Write values
foreach (var enumValue in Symbol.GetEnumValues())
{
output.WriteLine(indentation, "{0} = {1},", enumValue.Item1, enumValue.Item2);
}
// Enumeration end
output.WriteLine(--indentation, @"}}");
if ((DeclaredInType == null || (!generationFlags.HasFlag(UserTypeGenerationFlags.SingleFileExport) && DeclaredInType is NamespaceUserType)) && !string.IsNullOrEmpty(nameSpace))
{
output.WriteLine(--indentation, "}}");
}
}
/// <summary>
/// Writes the property code to the specified output.
/// </summary>
/// <param name="output">The output.</param>
/// <param name="indentation">The current indentation.</param>
/// <param name="generationFlags">The user type generation flags.</param>
/// <param name="firstField">if set to <c>true</c> this is the first field in the user type.</param>
public virtual void WritePropertyCode(IndentedWriter output, int indentation, UserTypeGenerationFlags generationFlags, ref bool firstField)
{
if (string.IsNullOrEmpty(ConstantValue))
{
if (generationFlags.HasFlag(UserTypeGenerationFlags.SingleLineProperty))
{
if (firstField)
{
output.WriteLine();
firstField = false;
}
if (!UseUserMember && !CacheResult && generationFlags.HasFlag(UserTypeGenerationFlags.GenerateFieldTypeInfoComment) && !string.IsNullOrEmpty(FieldTypeInfoComment))
{
output.WriteLine(indentation, FieldTypeInfoComment);
}
if (UseUserMember && CacheResult)
{
output.WriteLine(indentation, "public {0}{1} {2} {{ get {{ return {3}.Value; }} }}", Static ? "static " : "", FieldType, PropertyName, FieldName);
}
else if (CacheResult)
{
output.WriteLine(indentation, "public {0}{1} {2} {{ get {{ return {3}; }} }}", Static ? "static " : "", FieldType, PropertyName, FieldName);
}
else
{
output.WriteLine(indentation, "public {0}{1} {2} {{ get {{ return {3}; }} }}", Static ? "static " : "", FieldType, PropertyName, ConstructorText);
}
}
else
{
output.WriteLine();
if (!UseUserMember && !CacheResult && generationFlags.HasFlag(UserTypeGenerationFlags.GenerateFieldTypeInfoComment) && !string.IsNullOrEmpty(FieldTypeInfoComment))
{
output.WriteLine(indentation, FieldTypeInfoComment);
}
output.WriteLine(indentation, "public {0}{1} {2}", Static ? "static " : "", FieldType, PropertyName);
output.WriteLine(indentation++, "{{");
output.WriteLine(indentation, "get");
output.WriteLine(indentation++, "{{");
if (UseUserMember && CacheResult)
{
output.WriteLine(indentation, "return {0}.Value;", FieldName);
}
else if (CacheResult)
{
output.WriteLine(indentation, "return {0};", FieldName);
}
else
{
output.WriteLine(indentation, "return {0};", ConstructorText);
}
output.WriteLine(--indentation, "}}");
output.WriteLine(--indentation, "}}");
}
}
}
private void GenerateUsings()
{
_w.WriteLine("using System;");
_w.WriteLine("using System.Collections.Generic;");
_w.WriteLine("using System.Linq;");
_w.WriteLine("using System.Text;");
_w.WriteLine("using PolinaCompiler.Peg;");
_w.WriteLine();
}
/// <summary>
/// Writes the constructor code to the specified output.
/// </summary>
/// <param name="output">The output.</param>
/// <param name="indentation">The current indentation.</param>
public override void WriteConstructorCode(IndentedWriter output, int indentation)
{
output.WriteLine(indentation, "{0}();", FieldName);
}
//public static ParserTreeState ForStart(ParserNode root, ISourceTextReader reader, bool enableLog)
//{
// IndentedWriter w;
// if (enableLog)
// {
// w = new IndentedWriter(" ");
// w.Push().WriteLine("Start @{0} {1}", reader.GetPosition(), root).Push();
// }
// else
// {
// w = null;
// }
// if (root.Parent != null)
// throw new ArgumentException();
// return new ParserTreeState(
// w,
// null,
// ParsingTreeNode.CreateRootGroup(root, reader.Location),
// null,
// reader
// );
//}
public static ParserState <Result> ForStart(ParserNode grammarRoot, ParserNode omitRoot, ISourceTextReader reader, IParsingTreeNode oldRoot, Location limit, bool enableLog)
{
IndentedWriter w;
if (enableLog)
{
w = new IndentedWriter(" ");
if (oldRoot != null)
{
w.WriteLine("Incrementally");
}
w.Push().WriteLine("Start @{0} {1}", reader.GetPosition(), grammarRoot).Push();
}
else
{
w = null;
}
if (oldRoot != null)
{
ParserNode prevGrammarNode = null;
bool insideOmittedFragment;
var treeNode = ParsingTreeNode.CreateRootGroup(oldRoot, omitRoot, reader.Location, limit, out prevGrammarNode, out insideOmittedFragment);
if (!reader.MoveTo(treeNode.Location))
{
throw new NotImplementedException("");
}
if (w != null)
{
w.WriteLine("Reconstructing log indentation...");
var t = treeNode;
var path = new List <ParsingTreeNode.TemporaryGroup>();
while (t != null)
{
path.Add(t);
t = t.Parent;
}
path.Reverse();
for (int i = 0; i < path.Count - 1; i++)
{
w.Push().WriteLine("EnterNode @{2} {0} --> {1}", path[i].GrammarNode, path[i + 1].GrammarNode, path[i].Location).Push();
if (path[i].GrammarNode is ParserNode.RecursiveParserNode)
{
w.WriteLine("Enter to recursion");
}
}
w.WriteLine("...Identation reconstructed.");
}
ParserState <Result> state = new ParserTreeState(
w,
prevGrammarNode,
treeNode,
null,
reader
);
state.InsideOmittedFragment = insideOmittedFragment;
if (state.LastTerminalFailed == false)
{
state = state.ExitNode();
}
else
{
System.Diagnostics.Debug.Print(string.Empty);
}
return(state);
}
else
{
return(new ParserTreeState(
w,
null,
ParsingTreeNode.CreateRootGroup(grammarRoot, reader.Location),
null,
reader
));
}
}
/// <summary>
/// Writes the field code.
/// </summary>
/// <param name="output">The output.</param>
/// <param name="indentation">The indentation.</param>
/// <param name="options">The options.</param>
public override void WriteFieldCode(IndentedWriter output, int indentation, UserTypeGenerationFlags options)
{
output.WriteLine(indentation, "{0} {1}();", FieldType, FieldName);
}
/// <summary>
/// Writes the constructor code to the specified output.
/// </summary>
/// <param name="output">The output.</param>
/// <param name="indentation">The current indentation.</param>
public override void WriteConstructorCode(IndentedWriter output, int indentation)
{
output.WriteLine(indentation, "{0}();", FieldName);
}
/// <summary>
/// Writes the field code.
/// </summary>
/// <param name="output">The output.</param>
/// <param name="indentation">The indentation.</param>
/// <param name="options">The options.</param>
public override void WriteFieldCode(IndentedWriter output, int indentation, UserTypeGenerationFlags options)
{
output.WriteLine(indentation, "{0} {1}();", FieldType, FieldName);
}
/// <summary>
/// Writes the class comment on the specified output.
/// </summary>
/// <param name="output">The output.</param>
/// <param name="indentation">The current indentation.</param>
protected override void WriteClassComment(IndentedWriter output, int indentation)
{
base.WriteClassComment(output, indentation);
output.WriteLine(indentation, "// ---------------------------------------------------");
output.WriteLine(indentation, "// Specializations of this class");
foreach (var type in SpecializedTypes)
output.WriteLine(indentation, "// {0}", type.Symbol.Name);
}
void IParserStepVisitor.VisitTerminal(ITerminalStep terminal)
{
_w.WriteLine(terminal.ToString());
}
internal static bool GenerateSerializerToStream(XmlMapping[] xmlMappings, Type[] types, string defaultNamespace, Assembly assembly, Hashtable assemblies, Stream stream)
{
var compiler = new Compiler();
try
{
var scopeTable = new Hashtable();
foreach (XmlMapping mapping in xmlMappings)
{
scopeTable[mapping.Scope] = mapping;
}
var scopes = new TypeScope[scopeTable.Keys.Count];
scopeTable.Keys.CopyTo(scopes, 0);
assemblies.Clear();
var importedTypes = new Hashtable();
foreach (TypeScope scope in scopes)
{
foreach (Type t in scope.Types)
{
compiler.AddImport(t, importedTypes);
Assembly a = t.Assembly;
string name = a.FullName;
if (assemblies[name] != null)
{
continue;
}
if (!a.GlobalAssemblyCache)
{
assemblies[name] = a;
}
}
}
for (int i = 0; i < types.Length; i++)
{
compiler.AddImport(types[i], importedTypes);
}
compiler.AddImport(typeof(object).Assembly);
compiler.AddImport(typeof(System.Xml.Serialization.XmlSerializer).Assembly);
var writer = new IndentedWriter(compiler.Source, false);
writer.WriteLine("[assembly:System.Security.AllowPartiallyTrustedCallers()]");
writer.WriteLine("[assembly:System.Security.SecurityTransparent()]");
writer.WriteLine("[assembly:System.Security.SecurityRules(System.Security.SecurityRuleSet.Level1)]");
if (assembly != null && types.Length > 0)
{
for (int i = 0; i < types.Length; i++)
{
Type type = types[i];
if (type == null)
{
continue;
}
if (DynamicAssemblies.IsTypeDynamic(type))
{
throw new InvalidOperationException(SR.Format(SR.XmlPregenTypeDynamic, types[i].FullName));
}
}
writer.Write("[assembly:");
writer.Write(typeof(XmlSerializerVersionAttribute).FullName);
writer.Write("(");
writer.Write("ParentAssemblyId=");
ReflectionAwareCodeGen.WriteQuotedCSharpString(writer, GenerateAssemblyId(types[0]));
writer.Write(", Version=");
ReflectionAwareCodeGen.WriteQuotedCSharpString(writer, ThisAssembly.Version);
if (defaultNamespace != null)
{
writer.Write(", Namespace=");
ReflectionAwareCodeGen.WriteQuotedCSharpString(writer, defaultNamespace);
}
writer.WriteLine(")]");
}
var classes = new CodeIdentifiers();
classes.AddUnique("XmlSerializationWriter", "XmlSerializationWriter");
classes.AddUnique("XmlSerializationReader", "XmlSerializationReader");
string suffix = null;
if (types != null && types.Length == 1 && types[0] != null)
{
suffix = CodeIdentifier.MakeValid(types[0].Name);
if (types[0].IsArray)
{
suffix += "Array";
}
}
writer.WriteLine("namespace " + GeneratedAssemblyNamespace + " {");
writer.Indent++;
writer.WriteLine();
string writerClass = "XmlSerializationWriter" + suffix;
writerClass = classes.AddUnique(writerClass, writerClass);
var writerCodeGen = new XmlSerializationWriterCodeGen(writer, scopes, "public", writerClass);
writerCodeGen.GenerateBegin();
string[] writeMethodNames = new string[xmlMappings.Length];
for (int i = 0; i < xmlMappings.Length; i++)
{
writeMethodNames[i] = writerCodeGen.GenerateElement(xmlMappings[i]);
}
writerCodeGen.GenerateEnd();
writer.WriteLine();
string readerClass = "XmlSerializationReader" + suffix;
readerClass = classes.AddUnique(readerClass, readerClass);
var readerCodeGen = new XmlSerializationReaderCodeGen(writer, scopes, "public", readerClass);
readerCodeGen.GenerateBegin();
string[] readMethodNames = new string[xmlMappings.Length];
for (int i = 0; i < xmlMappings.Length; i++)
{
readMethodNames[i] = readerCodeGen.GenerateElement(xmlMappings[i]);
}
readerCodeGen.GenerateEnd(readMethodNames, xmlMappings, types);
string baseSerializer = readerCodeGen.GenerateBaseSerializer("XmlSerializer1", readerClass, writerClass, classes);
var serializers = new Hashtable();
for (int i = 0; i < xmlMappings.Length; i++)
{
if (serializers[xmlMappings[i].Key] == null)
{
serializers[xmlMappings[i].Key] = readerCodeGen.GenerateTypedSerializer(readMethodNames[i], writeMethodNames[i], xmlMappings[i], classes, baseSerializer, readerClass, writerClass);
}
}
readerCodeGen.GenerateSerializerContract("XmlSerializerContract", xmlMappings, types, readerClass, readMethodNames, writerClass, writeMethodNames, serializers);
writer.Indent--;
writer.WriteLine("}");
string codecontent = compiler.Source.ToString();
Byte[] info = new UTF8Encoding(true).GetBytes(codecontent);
stream.Write(info, 0, info.Length);
stream.Flush();
return(true);
}
finally
{
compiler.Close();
}
}
private void WriteFunctionNativeBindings(Function function, IndentedWriter writer)
{
writer.WriteLine($"[DllImport(\"{Configuration.DllFileName}\")]");
writer.WriteLine($"private static extern {ToCsReturnType(function.Return)} {ToNativeFunction(function)}{ToCsParameterString(function.Parameters)};");
writer.WriteLine();
}
/// <summary>
/// Writes the code for this user type to the specified output.
/// </summary>
/// <param name="output">The output.</param>
/// <param name="error">The error text writer.</param>
/// <param name="factory">The user type factory.</param>
/// <param name="generationFlags">The user type generation flags.</param>
/// <param name="indentation">The current indentation.</param>
public override void WriteCode(IndentedWriter output, TextWriter error, UserTypeFactory factory, UserTypeGenerationFlags generationFlags, int indentation = 0)
{
// Declared In Type with namespace
if (DeclaredInType != null)
{
foreach (string innerClass in namespaces)
{
output.WriteLine(indentation, "public static partial class {0}", innerClass);
output.WriteLine(indentation++, @"{{");
}
}
else
{
output.WriteLine(indentation, "namespace {0}", Namespace);
output.WriteLine(indentation++, @"{{");
}
// Inner types
foreach (var innerType in InnerTypes)
{
output.WriteLine();
innerType.WriteCode(output, error, factory, generationFlags, indentation);
}
// Declared In Type with namespace
if (DeclaredInType != null)
foreach (string innerClass in namespaces)
output.WriteLine(--indentation, "}}");
else
output.WriteLine(--indentation, "}}");
}
protected void WriteLine(string value)
{
_writer.WriteLine(value);
}
