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