/// <inheritdoc /> public void Write(Stream stream) { TokenWriter.WriteToken(Name, stream); stream.WriteWhiteSpace(); stream.WriteText(Symbol); stream.WriteNewLine(); }
public static void Test() { TokenWriter writer = new TokenWriter("Hello, my name is {Name} and I am from {City}."); string result = writer.Format(new KeyValueCollection().Add("Name", "Peter").Add("City", "Prague")); Console.WriteLine(result); }
public ObjectToken WriteObject(Stream stream, IToken token, int?reservedNumber = null) { int number; if (reservedNumber.HasValue) { if (!reservedNumbers.Remove(reservedNumber.Value)) { throw new InvalidOperationException(); } number = reservedNumber.Value; } else { number = CurrentNumber++; } var reference = new IndirectReference(number, 0); var obj = new ObjectToken(stream.Position, reference, token); objectOffsets.Add(reference, obj.Position); TokenWriter.WriteToken(obj, stream); return(obj); }
public static ILSpyUnresolvedFile Create(DecompiledTypeReference name, AstBuilder builder) { var writer = new StringWriter(); var target = new TextWriterTokenWriter(writer) { IndentationString = "\t" }; var output = new DebugInfoTokenWriterDecorator(TokenWriter.WrapInWriterThatSetsLocationsInAST(target)); builder.RunTransformations(); var syntaxTree = builder.SyntaxTree; syntaxTree.AcceptVisitor(new InsertParenthesesVisitor { InsertParenthesesForReadability = true }); syntaxTree.AcceptVisitor(new CSharpOutputVisitor(output, FormattingOptionsFactory.CreateSharpDevelop())); ILSpyUnresolvedFile file = new ILSpyUnresolvedFile(name); var v = new TypeSystemConvertVisitor(file); syntaxTree.AcceptVisitor(v); file.MemberLocations = output.MemberLocations; file.DebugSymbols = output.DebugSymbols; file.output = writer.ToString(); return(file); }
public void Run(IApplication application, IFile file) { if (file == null) { countingAppender.Application(application.Path); Process.Start(application.Path); } else { string arguments = file.Path; if (!String.IsNullOrEmpty(application.Arguments)) { TokenWriter writer = new TokenWriter(application.Arguments); arguments = writer.Format(new KeyValueCollection() .Add("FilePath", file.Path) .Add("DirectoryPath", System.IO.Path.GetDirectoryName(file.Path)) ); countingAppender.File(application.Path, application.Arguments, file.Path); } else { countingAppender.File(application.Path, file.Path); } Process.Start(new ProcessStartInfo(application.Path, arguments)); EventManager.RaiseProcessStarted(application, file); } }
/// <summary> /// Refresh the ICAL Event data of a event /// </summary> /// <param name="dbEvent">The event</param> /// <param name="description">The New desciption of the event</param> /// <param name="updateUid">True, when a new UID sould be set. Only recommenten, with a new (unsaved) event</param> public static void UpdateCalendarData(TableEvent dbEvent, string description, bool updateUid) { TokenNode calendarNode = calendarNode = ReadTokenNode(dbEvent); var icalEvent = calendarNode.Childs.Single().Childs.First(o => o.Name == "VEVENT"); UpdateStringToken(icalEvent, "SUMMARY", dbEvent.Title); UpdateStringToken(icalEvent, "DESCRIPTION", description); UpdateDateToken(icalEvent, "DTSTART", dbEvent.From, dbEvent.IsFullDayEvent); UpdateDateToken(icalEvent, "DTEND", dbEvent.To, dbEvent.IsFullDayEvent); //The uid helps the CalDav Server to uniquie identify the event and is required for events. if (updateUid) { UpdateStringToken(icalEvent, "UID", Guid.NewGuid().ToString()); } using (var tmpStream = new MemoryStream()) { TokenWriter.WriteTokenNode(calendarNode.Childs.Single(), tmpStream); tmpStream.Seek(0, SeekOrigin.Begin); var reader = new StreamReader(tmpStream); dbEvent.CalendarData = reader.ReadToEnd(); } }
public void Write(TextWriter writer) { var decompiler = new AstBuilder(new DecompilerContext(assemblyDefinition.MainModule)); decompiler.AddAssembly(assemblyDefinition); var formattingPolicy = FormattingOptionsFactory.CreateMono().Clone(); IAstVisitor [] visitors = { new PublicApiVisitor(), new SortTreeVisitor(), new CSharpOutputVisitor(TokenWriter.Create(writer,indentation: " "), formattingPolicy) }; foreach (var visitor in visitors) { decompiler.SyntaxTree.AcceptVisitor(visitor); } foreach (var tool in visitorTools) { decompiler.SyntaxTree.AcceptVisitor(tool.Visitor); } writer.Flush(); }
protected virtual void ParseValue(TokenWriter tokenWriter, BasicReader reader) { int startPos = reader.Position; if (reader.StartsWith(ListValueSeperator)) { tokenWriter.Add(new Token(TokenType.ListValueSeperator, ListValueSeperator, startPos, ListValueSeperator.Length)); reader.Skip(1); } else if (reader.StartsWith("'") || reader.StartsWith("\"")) { this.ParseQuotedString(tokenWriter, reader); } else if (reader.StartsWith("$")) { TokenType type; char[] endChar = new char[] { ' ', '\t', '\r', '\n', ',', '}', ')', '=', ';' }; string val = reader.ReadUntil(endChar.Contains); switch (val) { case "$null": type = TokenType.NullValue; break; case "$true": case "$false": type = TokenType.BoolValue; break; default: throw new InvalidDataException("Not a literal token: " + val); } tokenWriter.Add(new Token(type, val, startPos, reader.Position - startPos)); } else if (reader.StartsWith(DictionaryStart)) { this.ParseDictionary(tokenWriter, reader); } else if (reader.StartsWith(ListStart)) { this.ParseList(tokenWriter, reader); } else { char[] endChar = new char[] { ' ', '\t', '\r', '\n', ',', '}', ')', '=', ';' }; string val = reader.PeekUntil(endChar.Contains); bool decimalSep = val.Any(c => c == '.'); int skipSign = val[0] == '+' || val[0] == '-' ? 1 : 0; if (val.Skip(skipSign).Count(char.IsDigit) + (decimalSep ? 1 : 0) == val.Length - skipSign) { reader.Skip(val.Length); tokenWriter.Add(new Token(TokenType.NumericValue, val, startPos, reader.Position - startPos)); } else this.ParseUnquotedString(tokenWriter, reader); } }
void WriteQualifiedName(string name, TokenWriter writer, CSharpFormattingOptions formattingPolicy) { var node = AstType.Create(name); var outputVisitor = new CSharpOutputVisitor(writer, formattingPolicy); node.AcceptVisitor(outputVisitor); }
public FreescaleClient(TokenWriter writer, TokenReader reader) : base(writer, reader) { Input .OfType <Heartbeat>() .Subscribe(h => Heartbeat?.Invoke(this, h)); Input.Enable(); }
public CSharpWriter(TokenWriter writer) { if (writer == null) { throw new ArgumentNullException(nameof(writer)); } this.writer = writer; }
private void ParseOne(TokenWriter tokenWriter, BasicReader reader) { reader.AdvanceWhitespace(); if (reader.StartsWith(ParameterIndicator)) this.ParseParameter(tokenWriter, reader); else this.ParseValue(tokenWriter, reader); }
public void WriteTypeParameters(TokenWriter writer, IEnumerable <AstNode> typeParameters) { if (typeParameters.Any()) { writer.WriteToken(Roles.LChevron, "<"); WriteCommaSeparatedList(typeParameters); writer.WriteToken(Roles.RChevron, ">"); } }
private void ConvertType(IType type, TokenWriter writer, CSharpFormattingOptions formattingPolicy) { TypeSystemAstBuilder astBuilder = CreateAstBuilder(); astBuilder.AlwaysUseShortTypeNames = true; AstType astType = astBuilder.ConvertType(type); astType.AcceptVisitor(new CSharpOutputVisitor(writer, formattingPolicy)); }
protected virtual void Parse(TokenWriter tokenWriter, BasicReader reader) { while (!reader.Eof) { this.ParseOne(tokenWriter, reader); } tokenWriter.Add(new Token(TokenType.EndOfString, null, reader.Position, 0)); }
public void Run(IApplication application, IFile file, bool isAdministratorRequired = false) { string arguments = null; if (file == null) { if (!String.IsNullOrEmpty(application.EmptyArguments)) { arguments = application.EmptyArguments; countingAppender.Application(application.Path, arguments); } else { countingAppender.Application(application.Path); } } else { if (!String.IsNullOrEmpty(application.FileArguments)) { TokenWriter writer = new TokenWriter(application.FileArguments); arguments = writer.Format(new KeyValueCollection() .Add("FilePath", file.Path) .Add("DirectoryPath", Path.GetDirectoryName(file.Path)) ); countingAppender.File(application.Path, application.FileArguments, file.Path); } else { arguments = file.Path; countingAppender.File(application.Path, file.Path); } } ProcessStartInfo info = arguments == null ? new ProcessStartInfo(application.Path) : new ProcessStartInfo(application.Path, arguments); if (isAdministratorRequired || application.IsAdministratorRequired) { info.Verb = "runas"; } try { Process.Start(info); EventManager.RaiseProcessStarted(application, file); } catch (Win32Exception e) { // "The operation was canceled by the user". if (e.NativeErrorCode != 1223) { throw; } } }
static void WriteCode(TextWriter output, DecompilerSettings settings, SyntaxTree syntaxTree, IDecompilerTypeSystem typeSystem) { syntaxTree.AcceptVisitor(new InsertParenthesesVisitor { InsertParenthesesForReadability = true }); TokenWriter tokenWriter = new TextWriterTokenWriter(output); tokenWriter = TokenWriter.WrapInWriterThatSetsLocationsInAST(tokenWriter); syntaxTree.AcceptVisitor(new CSharpOutputVisitor(tokenWriter, settings.CSharpFormattingOptions)); }
public override RichText GetRichTextTooltip(IEntity entity) { var flags = ConversionFlags.All & ~(ConversionFlags.ShowBody | ConversionFlags.PlaceReturnTypeAfterParameterList); var output = new StringWriter(); var decoratedWriter = new TextWriterTokenWriter(output); var writer = new CSharpHighlightingTokenWriter(TokenWriter.InsertRequiredSpaces(decoratedWriter), locatable: decoratedWriter); new CSharpAmbience() { ConversionFlags = flags }.ConvertSymbol(entity, writer, new DecompilerSettings().CSharpFormattingOptions); return(new RichText(output.ToString(), writer.HighlightingModel)); }
void WriteTypeDeclarationName(ITypeDefinition typeDef, TokenWriter writer, CSharpFormattingOptions formattingPolicy) { var astBuilder = new TypeSystemAstBuilder(); EntityDeclaration node = astBuilder.ConvertEntity(typeDef); if (typeDef.DeclaringTypeDefinition != null) { WriteTypeDeclarationName(typeDef.DeclaringTypeDefinition, writer, formattingPolicy); writer.WriteToken(Roles.Dot, "."); } writer.WriteIdentifier(node.NameToken); WriteTypeParameters(writer, node.GetChildrenByRole(Roles.TypeParameter)); }
private void WriteHeader(HeaderDefinition header) { if (header.Nodes.Count == 0) { return; } var fileWriter = new CSharpFileTokenizer(); TokenizerContext context = fileWriter.Tokenize(header); var tokenWriter = new TokenWriter(); tokenWriter.Write(header.FullPath, context); }
public void EscapeSpecialCharacter() { using (var memStream = new MemoryStream()) { TokenWriter.WriteToken(new StringToken("\\"), memStream); TokenWriter.WriteToken(new StringToken("(Hello)"), memStream); // Read Test memStream.Position = 0; using (var streamReader = new StreamReader(memStream)) { var line = streamReader.ReadToEnd(); Assert.Equal("(\\\\) (\\(Hello\\)) ", line); } } }
/// <inheritdoc /> public void Write(Stream stream) { foreach (var operand in Operands) { stream.WriteDecimal(operand); stream.WriteWhiteSpace(); } if (PatternName != null) { TokenWriter.WriteToken(PatternName, stream); } stream.WriteText(Symbol); stream.WriteNewLine(); }
/// <inheritdoc /> public void Write(Stream stream) { stream.WriteText("["); for (var i = 0; i < Array.Count; i++) { TokenWriter.WriteToken(Array[i], stream); if (i < Array.Count - 1) { stream.WriteWhiteSpace(); } } stream.WriteText("]"); stream.WriteWhiteSpace(); stream.WriteText(Symbol); stream.WriteNewLine(); }
/// <inheritdoc /> public void Write(Stream stream) { TokenWriter.WriteToken(Name, stream); stream.WriteWhiteSpace(); if (PropertyDictionaryName != null) { TokenWriter.WriteToken(PropertyDictionaryName, stream); } else { TokenWriter.WriteToken(Properties, stream); } stream.WriteWhiteSpace(); stream.WriteText(Symbol); stream.WriteNewLine(); }
private static void TryBackupFile(UploadSettings configuration, string filePath) { if (!String.IsNullOrEmpty(configuration.BackupTemplate)) { TokenWriter writer = new TokenWriter(configuration.BackupTemplate); int order = 0; string newFilePath = null; do { string newFileName = writer.Format(token => { if (token == "FileName") { return(Path.GetFileNameWithoutExtension(filePath)); } if (token == "Extension") { return(Path.GetExtension(filePath).Substring(1)); } if (token == "Order") { return((++order).ToString()); } throw Ensure.Exception.NotSupported($"Not supported token '{token}' in backup template '{configuration.BackupTemplate}'."); }); string currentNewFilePath = Path.Combine(Path.GetDirectoryName(filePath), newFileName); if (currentNewFilePath == newFilePath || order > 100) { throw Ensure.Exception.InvalidOperation($"Maximum path probing reached on path '{newFilePath}'."); } newFilePath = currentNewFilePath; }while (File.Exists(newFilePath)); File.Copy(filePath, newFilePath); } }
public CSharpHighlightingTokenWriter(TokenWriter decoratedWriter, ISmartTextOutput textOutput = null, ILocatable locatable = null) : base(decoratedWriter) { var highlighting = HighlightingManager.Instance.GetDefinition("C#"); this.locatable = locatable; this.textOutput = textOutput; this.visibilityKeywordsColor = highlighting.GetNamedColor("Visibility"); this.namespaceKeywordsColor = highlighting.GetNamedColor("NamespaceKeywords"); this.structureKeywordsColor = highlighting.GetNamedColor("Keywords"); this.gotoKeywordsColor = highlighting.GetNamedColor("GotoKeywords"); this.queryKeywordsColor = highlighting.GetNamedColor("QueryKeywords"); this.exceptionKeywordsColor = highlighting.GetNamedColor("ExceptionKeywords"); this.checkedKeywordColor = highlighting.GetNamedColor("CheckedKeyword"); this.unsafeKeywordsColor = highlighting.GetNamedColor("UnsafeKeywords"); this.valueTypeKeywordsColor = highlighting.GetNamedColor("ValueTypeKeywords"); this.referenceTypeKeywordsColor = highlighting.GetNamedColor("ReferenceTypeKeywords"); this.operatorKeywordsColor = highlighting.GetNamedColor("OperatorKeywords"); this.parameterModifierColor = highlighting.GetNamedColor("ParameterModifiers"); this.modifiersColor = highlighting.GetNamedColor("Modifiers"); this.accessorKeywordsColor = highlighting.GetNamedColor("GetSetAddRemove"); this.referenceTypeColor = highlighting.GetNamedColor("ReferenceTypes"); this.valueTypeColor = highlighting.GetNamedColor("ValueTypes"); this.interfaceTypeColor = highlighting.GetNamedColor("InterfaceTypes"); this.enumerationTypeColor = highlighting.GetNamedColor("EnumTypes"); this.typeParameterTypeColor = highlighting.GetNamedColor("TypeParameters"); this.delegateTypeColor = highlighting.GetNamedColor("DelegateTypes"); this.methodDeclarationColor = this.methodCallColor = highlighting.GetNamedColor("MethodCall"); //this.eventDeclarationColor = this.eventAccessColor = defaultTextColor; //this.propertyDeclarationColor = this.propertyAccessColor = defaultTextColor; this.fieldDeclarationColor = this.fieldAccessColor = highlighting.GetNamedColor("FieldAccess"); //this.variableDeclarationColor = this.variableAccessColor = defaultTextColor; //this.parameterDeclarationColor = this.parameterAccessColor = defaultTextColor; this.valueKeywordColor = highlighting.GetNamedColor("NullOrValueKeywords"); this.thisKeywordColor = highlighting.GetNamedColor("ThisOrBaseReference"); this.trueKeywordColor = highlighting.GetNamedColor("TrueFalse"); this.typeKeywordsColor = highlighting.GetNamedColor("TypeKeywords"); this.attributeKeywordsColor = highlighting.GetNamedColor("AttributeKeywords"); //this.externAliasKeywordColor = ...; }
public virtual IEnumerable<Token> Tokenize(params string[] args) { TokenWriter tokenWriter = new TokenWriter(); Task.Factory.StartNew(() => { try { using (StringReader reader = new StringReader(string.Join(" ", args))) using (BasicReader basicReader = new BasicReader(reader, StringComparer.Ordinal)) { this.Parse(tokenWriter, basicReader); tokenWriter.Close(); } } catch (Exception ex) { tokenWriter.Abort(ex); } }); return tokenWriter.GetConsumingEnumerable(); }
protected virtual void ParseParameter(TokenWriter tokenWriter, BasicReader reader) { if (!reader.StartsWith(ParameterIndicator)) throw new InvalidOperationException(String.Format("Cannot parse paramer, expected {0}.", ParameterIndicator)); reader.Skip(1); int startPos = reader.Position; StringBuilder name = new StringBuilder(); char next; while (reader.TryPeek(out next) && next != ':' && !char.IsWhiteSpace(next)) { name.Append(reader.Read()); } if (!reader.Eof && next == ':') { tokenWriter.Add(new Token(TokenType.SwitchParameter, name.ToString(), startPos, reader.Position - startPos)); reader.Skip(1); // skip the : this.ParseOne(tokenWriter, reader); } else tokenWriter.Add(new Token(TokenType.ParameterName, name.ToString(), startPos, reader.Position - startPos)); }
void WriteMemberDeclarationName(IMember member, TokenWriter writer, CSharpFormattingOptions formattingPolicy) { TypeSystemAstBuilder astBuilder = CreateAstBuilder(); EntityDeclaration node = astBuilder.ConvertEntity(member); switch (member.SymbolKind) { case SymbolKind.Indexer: writer.WriteKeyword(Roles.Identifier, "this"); break; case SymbolKind.Constructor: WriteQualifiedName(member.DeclaringType.Name, writer, formattingPolicy); var typeNode = astBuilder.ConvertEntity(member.DeclaringTypeDefinition); WriteTypeParameters(writer, typeNode.GetChildrenByRole(Roles.TypeParameter)); break; case SymbolKind.Destructor: writer.WriteToken(DestructorDeclaration.TildeRole, "~"); WriteQualifiedName(member.DeclaringType.Name, writer, formattingPolicy); break; case SymbolKind.Operator: switch (member.Name) { case "op_Implicit": writer.WriteKeyword(OperatorDeclaration.ImplicitRole, "implicit"); writer.Space(); writer.WriteKeyword(OperatorDeclaration.OperatorKeywordRole, "operator"); writer.Space(); ConvertType(member.ReturnType, writer, formattingPolicy); break; case "op_Explicit": writer.WriteKeyword(OperatorDeclaration.ExplicitRole, "explicit"); writer.Space(); writer.WriteKeyword(OperatorDeclaration.OperatorKeywordRole, "operator"); writer.Space(); ConvertType(member.ReturnType, writer, formattingPolicy); break; default: writer.WriteKeyword(OperatorDeclaration.OperatorKeywordRole, "operator"); writer.Space(); var operatorType = OperatorDeclaration.GetOperatorType(member.Name); if (operatorType.HasValue) { writer.WriteToken(OperatorDeclaration.GetRole(operatorType.Value), OperatorDeclaration.GetToken(operatorType.Value)); } else { writer.WriteIdentifier(node.NameToken); } break; } break; default: writer.WriteIdentifier(Identifier.Create(member.Name)); IEnumerable <AstNode> typeArgs = node.GetChildrenByRole(Roles.TypeParameter); if (member is IMethod) { var typeArguments = ((IMethod)member).TypeArguments; if (typeArguments.Any() && typeArguments.First().Name == "TSource") { typeArgs = typeArgs.Skip(1); } } WriteTypeParameters(writer, typeArgs); break; } }
public InsertRequiredSpacesDecorator(TokenWriter writer) : base(writer) { }
void WriteMemberDeclarationName(IMember member, TokenWriter writer, CSharpFormattingOptions formattingPolicy) { TypeSystemAstBuilder astBuilder = CreateAstBuilder(); EntityDeclaration node = astBuilder.ConvertEntity(member); switch (member.SymbolKind) { case SymbolKind.Indexer: writer.WriteKeyword(Roles.Identifier, "this"); break; case SymbolKind.Constructor: WriteQualifiedName(member.DeclaringType.Name, writer, formattingPolicy); var typeNode = astBuilder.ConvertEntity(member.DeclaringTypeDefinition); WriteTypeParameters(writer, typeNode.GetChildrenByRole(Roles.TypeParameter)); break; case SymbolKind.Destructor: writer.WriteToken(DestructorDeclaration.TildeRole, "~"); WriteQualifiedName(member.DeclaringType.Name, writer, formattingPolicy); break; case SymbolKind.Operator: switch (member.Name) { case "op_Implicit": writer.WriteKeyword(OperatorDeclaration.ImplicitRole, "implicit"); writer.Space(); writer.WriteKeyword(OperatorDeclaration.OperatorKeywordRole, "operator"); writer.Space(); ConvertType(member.ReturnType, writer, formattingPolicy); break; case "op_Explicit": writer.WriteKeyword(OperatorDeclaration.ExplicitRole, "explicit"); writer.Space(); writer.WriteKeyword(OperatorDeclaration.OperatorKeywordRole, "operator"); writer.Space(); ConvertType(member.ReturnType, writer, formattingPolicy); break; default: writer.WriteKeyword(OperatorDeclaration.OperatorKeywordRole, "operator"); writer.Space(); var operatorType = OperatorDeclaration.GetOperatorType(member.Name); if (operatorType.HasValue) { writer.WriteToken(OperatorDeclaration.GetRole(operatorType.Value), OperatorDeclaration.GetToken(operatorType.Value)); } else { writer.WriteIdentifier(node.NameToken); } break; } break; default: writer.WriteIdentifier(Identifier.Create(member.Name)); if (member is IMethod) { var method = ((IMethod)member); var methodParameterTypeArguments = from p in method.Parameters from type in ExpandIntersections(p.Type) from typeArgument in type.TypeArguments select typeArgument.Name; IEnumerable <AstNode> typeArgs = node.GetChildrenByRole(Roles.TypeParameter).Where(arg => !methodParameterTypeArguments.Contains(arg.Name)); WriteTypeParameters(writer, typeArgs); } break; } }
public static IReadOnlyList <byte> ConvertToCMapStream(IReadOnlyDictionary <char, byte> unicodeToCharacterCode) { using (var memoryStream = new MemoryStream()) { TokenWriter.WriteToken(NameToken.CidInit, memoryStream); TokenWriter.WriteToken(NameToken.ProcSet, memoryStream); memoryStream.WriteText(FindResourceToken, true); memoryStream.WriteText(BeginToken); memoryStream.WriteNewLine(); memoryStream.WriteDecimal(12); memoryStream.WriteWhiteSpace(); memoryStream.WriteText(DictToken, true); memoryStream.WriteText(BeginToken); memoryStream.WriteNewLine(); memoryStream.WriteText(BeginCMapToken); memoryStream.WriteNewLine(); TokenWriter.WriteToken(NameToken.CidSystemInfo, memoryStream); var dictionary = new DictionaryToken(new Dictionary <NameToken, IToken> { { NameToken.Registry, new StringToken("Adobe") }, { NameToken.Ordering, new StringToken("UCS") }, { NameToken.Supplement, new NumericToken(0) } }); TokenWriter.WriteToken(dictionary, memoryStream); memoryStream.WriteWhiteSpace(); memoryStream.WriteText(DefToken); memoryStream.WriteNewLine(); TokenWriter.WriteToken(NameToken.Cmapname, memoryStream); TokenWriter.WriteToken(NameToken.Create("Adobe-Identity-UCS"), memoryStream); memoryStream.WriteText(DefToken); memoryStream.WriteNewLine(); TokenWriter.WriteToken(NameToken.CmapType, memoryStream); memoryStream.WriteNumberText(2, DefToken); memoryStream.WriteNumberText(1, "begincodespacerange"); TokenWriter.WriteToken(new HexToken(new[] { '0', '0' }), memoryStream); TokenWriter.WriteToken(new HexToken(new[] { 'F', 'F' }), memoryStream); memoryStream.WriteNewLine(); memoryStream.WriteText("endcodespacerange"); memoryStream.WriteNewLine(); memoryStream.WriteNumberText(unicodeToCharacterCode.Count, "beginbfchar"); foreach (var keyValuePair in unicodeToCharacterCode) { var unicodeInt = (ushort)keyValuePair.Key; var low = (byte)(unicodeInt >> 0); var high = (byte)(unicodeInt >> 8); var from = Hex.GetString(new[] { keyValuePair.Value }); var to = Hex.GetString(new[] { high, low }); TokenWriter.WriteToken(new HexToken(from.ToCharArray()), memoryStream); TokenWriter.WriteToken(new HexToken(to.ToCharArray()), memoryStream); memoryStream.WriteNewLine(); } memoryStream.WriteText("endbfchar"); memoryStream.WriteNewLine(); memoryStream.WriteText("endcmap"); memoryStream.WriteNewLine(); memoryStream.WriteText("CMapName currentdict /CMap defineresource pop"); memoryStream.WriteNewLine(); memoryStream.WriteText("end"); memoryStream.WriteNewLine(); memoryStream.WriteText("end"); memoryStream.WriteNewLine(); return(memoryStream.ToArray()); } }
public DebugInfoTokenWriterDecorator(TokenWriter writer) : base(writer) { }
protected IOClient(TokenWriter writer, TokenReader reader) { Output = writer; Input = new Dispatcher(new MessageReader(reader)); }
protected virtual void ParseQuotedString(TokenWriter tokenWriter, BasicReader reader) { // record position for later int pos = reader.Position; // skip leading quote char quoteChar = reader.Read(); StringBuilder val = new StringBuilder(); // escape char + quote char char[] stopChars = new[] { '`', quoteChar }; do { string tmp = reader.ReadUntil(stopChars.Contains); val.Append(tmp); char chr; if (reader.TryPeek(out chr)) { if (chr == '`') { // escape char, so skip one reader.Read(); // then process the next val.Append(reader.Read()); } else if (chr == quoteChar) { break; // exit } } else { throw new Exception("Premature end of stream"); } } while (!reader.Eof); // skip trailing quote reader.Skip(1); tokenWriter.Add(new Token(TokenType.StringValue, val.ToString(), pos, reader.Position - pos)); }
protected virtual void ParseDictionary(TokenWriter tokenWriter, BasicReader reader) { if (!reader.StartsWith(DictionaryStart)) throw new InvalidOperationException(String.Format("Cannot parse dictionary, expected {0}.", DictionaryStart)); tokenWriter.Add(new Token(TokenType.DictionaryStart, DictionaryStart, reader.Position, DictionaryStart.Length)); // skip reader.Skip(DictionaryStart.Length); while (!reader.StartsWith(DictionaryEnd) && !reader.Eof) { // trim ws reader.AdvanceWhitespace(); // parse dict-key this.ParseValue(tokenWriter, reader); // trim ws reader.AdvanceWhitespace(); // read seperator if (reader.StartsWith(DictionaryValueSeperator)) { // we no longer emit these tokens ////tokenWriter.Add(new Token //// { //// Position = reader.Position, //// Length = DictionaryValueSeperator.Length, //// Type = TokenType.DictionaryValueSeperator, //// Value = DictionaryValueSeperator //// }); reader.Skip(DictionaryValueSeperator.Length); } else { throw new Exception("Expected key seperator"); } // trim ws reader.AdvanceWhitespace(); // parse dict-value this.ParseValue(tokenWriter, reader); // trim ws reader.AdvanceWhitespace(); // read seperator if (reader.StartsWith(DictionaryKeySeperator)) { // we no longer emit these tokens ////tokenWriter.Add(new Token //// { //// Position = reader.Position, //// Length = DictionaryKeySeperator.Length, //// Type = TokenType.DictionaryKeySeperator, //// Value = DictionaryKeySeperator //// }); reader.Skip(DictionaryKeySeperator.Length); } else break; } if (!reader.Eof && reader.StartsWith(DictionaryEnd)) { tokenWriter.Add(new Token(TokenType.DictionaryEnd, DictionaryEnd, reader.Position, DictionaryEnd.Length)); reader.Skip(DictionaryEnd.Length); } else { throw new Exception("Expected end of dictionary"); } }
static int Main(string[] args) { var assemblyFilenameOption = new Option <FileInfo>( new[] { "--assembly", "-a" }, description: "The assembly to decompile into XML."); var verboseOption = new Option <bool>( new[] { "--verbose", "-v" }, description: "Provide output as code is running."); var outputOption = new Option <DirectoryInfo>( new[] { "--output", "-o" }, description: "The root directory where the XML files will be written. The directory must exist."); var rootCommand = new RootCommand { assemblyFilenameOption, verboseOption, outputOption, }; rootCommand.Description = "Command to extract C# code into XML suitable for reasoning."; rootCommand.SetHandler((FileInfo assemblyFile, bool verbose, DirectoryInfo outputDirectory) => { if (assemblyFile == null) { Console.Error.WriteLine("No assembly provided to extract"); return; } if (outputDirectory == null) { Console.Error.WriteLine("No target directory provided"); return; } // Set up the preferences for the decompilation of the IL into source. var settings = new DecompilerSettings() { AlwaysUseBraces = true, ShowXmlDocumentation = true }; settings.CSharpFormattingOptions.IndentationString = " "; var decompiler = new CSharpDecompiler(assemblyFile.FullName, settings); // Traverse all the types in the assembly foreach (var typeDefinition in decompiler.TypeSystem.MainModule.TopLevelTypeDefinitions) { if (typeDefinition.Name.StartsWith("<")) { continue; } if (verbose) { Console.WriteLine($"Extracting {typeDefinition.FullName}."); } var syntaxTree = decompiler.DecompileType(typeDefinition.FullTypeName); // This is needed to get the locations correctly set in the AST. StringWriter w = new StringWriter(); var q = new TextWriterTokenWriter(w); q.IndentationString = " "; TokenWriter tokenWriter = q; tokenWriter = TokenWriter.WrapInWriterThatSetsLocationsInAST(tokenWriter); syntaxTree.AcceptVisitor(new CSharpOutputVisitor(tokenWriter, settings.CSharpFormattingOptions)); var source = w.ToString(); var generator = new XmlGeneratorVisitor(assemblyFile.FullName, source); syntaxTree.AcceptVisitor(generator); File.WriteAllText(Path.Combine(outputDirectory.FullName, typeDefinition.FullTypeName.Name) + ".xml", generator.Document.ToString()); } }, assemblyFilenameOption, verboseOption, outputOption); return(rootCommand.Invoke(args)); }
protected virtual void ParseUnquotedString(TokenWriter tokenWriter, BasicReader reader) { // record position for later int pos = reader.Position; StringBuilder val = new StringBuilder(); // escape char + stop chars char[] stopChars = new[] { '`', ' ', '\t', '\r', '\n', '}', ')', '=' }; do { string tmp = reader.ReadUntil(stopChars.Contains); val.Append(tmp); char chr; if (reader.TryPeek(out chr)) { if (chr == '`') { // escape char, so skip one reader.Read(); // then process the next val.Append(reader.Read()); } else { break; // exit } } } while (!reader.Eof); tokenWriter.Add(new Token(TokenType.StringValue, val.ToString(), pos, reader.Position - pos)); }
protected virtual void ParseList(TokenWriter tokenWriter, BasicReader reader) { if (!reader.StartsWith(ListStart)) throw new InvalidOperationException(String.Format("Cannot parse list, expected {0}.", ListStart)); tokenWriter.Add(new Token(TokenType.ListStart, ListStart, reader.Position, ListStart.Length)); // skip it reader.Skip(ListStart.Length); // trim ws reader.AdvanceWhitespace(); while (!reader.StartsWith(ListEnd) && !reader.Eof) { // parse list value this.ParseValue(tokenWriter, reader); // trim ws reader.AdvanceWhitespace(); // read seperator if (reader.StartsWith(ListValueSeperator)) { // don't output these anymore ////tokenWriter.Add(new Token //// { //// Position = reader.Position, //// Length = ListValueSeperator.Length, //// Type = TokenType.ListValueSeperator, //// Value = ListValueSeperator //// }); reader.Skip(ListValueSeperator.Length); } else if (!reader.StartsWith(ListEnd)) { throw new Exception("Expected value seperator or end of list."); } // trim ws reader.AdvanceWhitespace(); } if (reader.StartsWith(ListEnd)) { tokenWriter.Add(new Token(TokenType.ListEnd, ListEnd, reader.Position, ListEnd.Length)); reader.Skip(ListEnd.Length); } else { throw new Exception("Expected end of list"); } }
protected virtual void ParseDictionary(TokenWriter tokenWriter, BasicReader reader) { if (!reader.StartsWith(DictionaryStart)) throw new InvalidOperationException($"Cannot parse dictionary, expected {DictionaryStart}."); tokenWriter.Add(new Token(TokenType.DictionaryStart, DictionaryStart, reader.Position, DictionaryStart.Length)); // skip reader.Skip(DictionaryStart.Length); while (!reader.StartsWith(DictionaryEnd) && !reader.Eof) { // trim ws reader.AdvanceWhitespace(); // parse dict-key this.ParseValue(tokenWriter, reader); // trim ws reader.AdvanceWhitespace(); // read seperator if (reader.StartsWith(DictionaryValueSeperator)) reader.Skip(DictionaryValueSeperator.Length); else throw new Exception("Expected key seperator"); // trim ws reader.AdvanceWhitespace(); // parse dict-value this.ParseValue(tokenWriter, reader); // trim ws reader.AdvanceWhitespace(); // read seperator if (reader.StartsWith(DictionaryKeySeperator)) reader.Skip(DictionaryKeySeperator.Length); else break; } if (!reader.Eof && reader.StartsWith(DictionaryEnd)) { tokenWriter.Add(new Token(TokenType.DictionaryEnd, DictionaryEnd, reader.Position, DictionaryEnd.Length)); reader.Skip(DictionaryEnd.Length); } else throw new Exception("Expected end of dictionary"); }