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