public string DumpApi(SignatureWriter WriteSignature, DumpPostProcesser postProcess = null)
{
if (Database == null)
{
throw new Exception("Cannot Dump API without a ReflectionDatabase provided.");
}
buffer.Clear();
foreach (ClassDescriptor classDesc in Database.Classes.Values)
{
WriteSignature(this, classDesc, 0);
NextLine();
foreach (MemberDescriptor memberDesc in sorted(classDesc.Members))
{
WriteSignature(this, memberDesc, 1);
NextLine();
}
}
foreach (EnumDescriptor enumDesc in Database.Enums.Values)
{
WriteSignature(this, enumDesc, 0);
NextLine();
foreach (EnumItemDescriptor itemDesc in sorted(enumDesc.Items))
{
WriteSignature(this, itemDesc, 1);
NextLine();
}
}
return(ExportResults(postProcess));
}
public override void Write(SignatureWriter wtr)
{
wtr.Write(Element);
wtr.Write(vt ? ElementType.ValueType : ElementType.Class);
wtr.WriteTypeDefOrRefEncoded(t);
ts.Write(wtr);
}
public void Write() {
uint codeSize = InitializeInstructionOffsets();
jitBody.MaxStack = keepMaxStack ? body.MaxStack : GetMaxStack();
jitBody.Options = 0;
if (body.InitLocals)
jitBody.Options |= 0x10;
if (body.Variables.Count > 0) {
var local = new LocalSig(body.Variables.Select(var => var.Type).ToList());
jitBody.LocalVars = SignatureWriter.Write(metadata, local);
}
else
jitBody.LocalVars = new byte[0];
using (var ms = new MemoryStream()) {
uint _codeSize = WriteInstructions(new BinaryWriter(ms));
Debug.Assert(codeSize == _codeSize);
jitBody.ILCode = ms.ToArray();
}
jitBody.EHs = new JITEHClause[exceptionHandlers.Count];
if (exceptionHandlers.Count > 0) {
jitBody.Options |= 8;
for (int i = 0; i < exceptionHandlers.Count; i++) {
ExceptionHandler eh = exceptionHandlers[i];
jitBody.EHs[i].Flags = (uint)eh.HandlerType;
uint tryStart = GetOffset(eh.TryStart);
uint tryEnd = GetOffset(eh.TryEnd);
jitBody.EHs[i].TryOffset = tryStart;
jitBody.EHs[i].TryLength = tryEnd - tryStart;
uint handlerStart = GetOffset(eh.HandlerStart);
uint handlerEnd = GetOffset(eh.HandlerEnd);
jitBody.EHs[i].HandlerOffset = handlerStart;
jitBody.EHs[i].HandlerLength = handlerEnd - handlerStart;
if (eh.HandlerType == ExceptionHandlerType.Catch) {
uint token = metadata.GetToken(eh.CatchType).Raw;
if ((token & 0xff000000) == 0x1b000000)
jitBody.Options |= 0x80;
jitBody.EHs[i].ClassTokenOrFilterOffset = token;
}
else if (eh.HandlerType == ExceptionHandlerType.Filter) {
jitBody.EHs[i].ClassTokenOrFilterOffset = GetOffset(eh.FilterStart);
}
}
}
}
public override byte[] Compute()
{
using (Operation op = L.Begin("Build file signature for file {file}", File.FullName))
{
using (FileStream basisStream = File.Open(FileMode.Open, FileAccess.Read, FileShare.Read))
using (MemoryStream ms = new MemoryStream())
{
SignatureWriter octoSigWriter = new SignatureWriter(ms);
SignatureBuilder signatureBuilder = new SignatureBuilder();
signatureBuilder.ProgressReporter = new OctoSigBuildProgressReporter(File);
signatureBuilder.Build(basisStream, octoSigWriter);
ComputedDateTime = DateTime.UtcNow;
op.Complete();
return(ComputedSignature = ms.ToArray());
}
}
}
/// <summary>
/// Returns the given signature, remapped with the
/// <see cref="SignatureVisitor" />
/// returned by
/// <see cref="CreateSignatureRemapper" />
/// .
/// </summary>
/// <param name="signature">
/// a <i>JavaTypeSignature</i>, <i>ClassSignature</i> or <i>MethodSignature</i>.
/// </param>
/// <param name="typeSignature">
/// whether the given signature is a <i>JavaTypeSignature</i>.
/// </param>
/// <returns>
/// signature the given signature, remapped with the
/// <see cref="SignatureVisitor" />
/// returned by
/// <see cref="CreateSignatureRemapper" />
/// .
/// </returns>
public virtual string MapSignature(string signature, bool typeSignature)
{
if (signature == null)
{
return(null);
}
var signatureReader = new SignatureReader(signature);
var signatureWriter = new SignatureWriter();
var signatureRemapper = CreateSignatureRemapper(signatureWriter);
if (typeSignature)
{
signatureReader.AcceptType(signatureRemapper);
}
else
{
signatureReader.Accept(signatureRemapper);
}
return(signatureWriter.ToString());
}
public override void Write(SignatureWriter wtr)
{
wtr.Write(Element);
}
public override void Write(SignatureWriter wtr)
{
wtr.Write(Element);
wtr.WriteCompressedInt(num);
}
public override void Write(SignatureWriter wtr)
{
wtr.Write(Element);
wtr.WriteTypeDefOrRefEncoded(tkn);
}
public static int Main(string[] args)
{
if (args.Length < 2 || args.Length > 2)
{
WriteUsage();
return(1);
}
var inputFile = args[0];
if (!File.Exists(inputFile))
{
Console.WriteLine(Directory.GetCurrentDirectory());
Console.WriteLine(inputFile + " not found.");
return(1);
}
var writeSource = true;
var writeSignatures = false;
string outputFile = null;
if (args.Length == 2)
{
if (args[1] == "/sig")
{
writeSignatures = true;
}
else
{
outputFile = args[1];
}
}
var reader = XmlReader.Create(inputFile, new XmlReaderSettings {
DtdProcessing = DtdProcessing.Prohibit
});
var serializer = new XmlSerializer(typeof(Tree));
var tree = (Tree)serializer.Deserialize(reader);
if (writeSignatures)
{
SignatureWriter.Write(Console.Out, tree);
}
else
{
if (writeSource)
{
var outputPath = outputFile.Trim('"');
var prefix = Path.GetFileName(inputFile);
var outputMainFile = Path.Combine(outputPath, $"{prefix}.Main.Generated.cs");
var outputInternalFile = Path.Combine(outputPath, $"{prefix}.Internal.Generated.cs");
var outputSyntaxFile = Path.Combine(outputPath, $"{prefix}.Syntax.Generated.cs");
WriteToFile(tree, SourceWriter.WriteMain, outputMainFile);
WriteToFile(tree, SourceWriter.WriteInternal, outputInternalFile);
WriteToFile(tree, SourceWriter.WriteSyntax, outputSyntaxFile);
}
//if (writeTests)
//{
// WriteToFile(tree, TestWriter.Write, outputFile);
//}
}
return(0);
}
