public void RemoveFromMethodInfo(string methodName, ProjectItem projectItem)
{
string filePath = projectItem.FileNames[0];
int index = filePath.IndexOf(serverMethodsFolderName);
if (index == 1)
{
return;
}
string partialPath = filePath.Substring(index + serverMethodsFolderName.Length + 1);
partialPath = Path.ChangeExtension(partialPath, null);
string fodlerPath = methodName + "\\";
if (fodlerPath == partialPath)
{
MethodInfos.RemoveAll(x => x.MethodName == methodName);
return;
}
MethodInfo methodInfos = this.MethodInfos.FirstOrDefault(m => m.MethodName == methodName);
List <string> classesForRemoving = new List <string>();
foreach (var partialClass in methodInfos.PartialClasses)
{
if (partialClass.IndexOf(partialPath) == 0)
{
classesForRemoving.Add(partialClass);
}
}
classesForRemoving.ForEach(cfr => methodInfos.PartialClasses.Remove(cfr));
}
public override void EnterClass_body(CSharpParser.Class_bodyContext context)
{
Console.WriteLine();
Console.WriteLine(context.GetText());
foreach (var classMemberDeclaration in context.class_member_declarations().class_member_declaration())
{
var typedMemberDeclarationListener = new TypedMemberDeclarationListener(_className);
classMemberDeclaration.common_member_declaration().typed_member_declaration().EnterRule(typedMemberDeclarationListener);
if (typedMemberDeclarationListener.MethodInfo != null)
{
MethodInfos.Add(typedMemberDeclarationListener.MethodInfo);
}
if (typedMemberDeclarationListener.FieldInfo != null)
{
FieldInfos.Add(typedMemberDeclarationListener.FieldInfo);
}
/*Console.WriteLine();
* Console.WriteLine(classMemberDeclaration.attributes().GetText());
* Console.WriteLine();
* Console.WriteLine(classMemberDeclaration.all_member_modifiers().GetText());
* Console.WriteLine(classMemberDeclaration.common_member_declaration().GetText());*/
}
}
DumpedMethods decryptMethods()
{
var dumpedMethods = new DumpedMethods();
var peImage = decrypterInfo.peImage;
var methodInfos = new MethodInfos(decrypterInfo.mainType, peImage, decrypterInfo.peHeader, decrypterInfo.mcKey);
methodInfos.initializeInfos();
var methodDef = peImage.DotNetFile.MetaData.TablesStream.MethodTable;
for (uint rid = 1; rid <= methodDef.Rows; rid++) {
var dm = new DumpedMethod();
peImage.readMethodTableRowTo(dm, rid);
var info = methodInfos.lookup(dm.mdRVA);
if (info == null)
continue;
ushort magic = peImage.readUInt16(dm.mdRVA);
if (magic != 0xFFF3)
continue;
var mbHeader = MethodBodyParser.parseMethodBody(MemoryImageStream.Create(info.body), out dm.code, out dm.extraSections);
peImage.updateMethodHeaderInfo(dm, mbHeader);
dumpedMethods.add(dm);
}
return dumpedMethods;
}
IEnumerable <BaseTypeSyntax> GetBaseTypes()
{
var opaqueTypeName = Element.Attribute(gs + "opaque")?.Value;
if (opaqueTypeName != null)
{
switch (opaqueTypeName)
{
case "ref-counted":
opaqueTypeName = typeof(GISharp.Runtime.ReferenceCountedOpaque).FullName;
break;
case "owned":
opaqueTypeName = typeof(GISharp.Runtime.OwnedOpaque).FullName;
break;
case "static":
opaqueTypeName = typeof(GISharp.Runtime.StaticOpaque).FullName;
break;
case "gtype-struct":
opaqueTypeName = GTypeStructParent.FullName;
break;
default:
var message = string.Format("Unknown oqaue type '{0}.", opaqueTypeName);
throw new Exception(message);
}
yield return(SimpleBaseType(ParseTypeName(opaqueTypeName)));
}
if (IsGObject)
{
var parent = Element.Attribute("parent")?.Value;
if (parent == null)
{
yield return(SimpleBaseType(
ParseTypeName(typeof(GISharp.Runtime.ReferenceCountedOpaque).FullName)));
}
else
{
var parentType = GirType.ResolveType(parent, Element.Document);
yield return(SimpleBaseType(ParseTypeName(parentType.FullName)));
}
// TODO: add interfaces for objects
}
if (MethodInfos.Any(x => x.IsEquals))
{
var typeName = string.Concat(typeof(IEquatable <>).FullName.TakeWhile(x => x != '`'));
typeName = string.Format("{0}<{1}>", typeName, ManagedName);
yield return(SimpleBaseType(ParseTypeName(typeName)));
}
if (MethodInfos.Any(x => x.IsCompare))
{
var typeName = string.Concat(typeof(IComparable <>).FullName.TakeWhile(x => x != '`'));
typeName = string.Format("{0}<{1}>", typeName, ManagedName);
yield return(SimpleBaseType(ParseTypeName(typeName)));
}
}
public static AppScreenException NonVirtualMethods(MethodInfos methodInfos)
{
StringBuilder messageBuilder = new StringBuilder();
methodInfos.ForEach(delegate(MethodInfo entity)
{
string message = string.Format("{0} method in class {1} is not virtual", entity.Name, entity.DeclaringType.Name);
messageBuilder.AppendLine(message);
});
return new AppScreenException(messageBuilder.ToString());
}
public static AppScreenException NonVirtualMethods(MethodInfos methodInfos)
{
StringBuilder messageBuilder = new StringBuilder();
methodInfos.ForEach(delegate(MethodInfo entity)
{
string message = string.Format("{0} method in class {1} is not virtual", entity.Name, entity.DeclaringType.Name);
messageBuilder.AppendLine(message);
});
return(new AppScreenException(messageBuilder.ToString()));
}
public void CleanUp()
{
LastSelectedDir = string.Empty;
LastSelectedMfFile = string.Empty;
UseVSFormatting = default(bool);
LastSelectedSearchTypeInOpenFromPackage = string.Empty;
Connections.Clear();
MethodInfos.Clear();
LastSavedSearch.Clear();
MethodsFolderPath = string.Empty;
MethodConfigPath = string.Empty;
IOMFilePath = string.Empty;
}
private int FindIndex(MethodInfo methodInfo)
{
string name = methodInfo.Name;
MethodInfo[] methodInfoArray = MethodInfos
.Where(info => info.Name == name)
.ToArray();
return(methodInfoArray.Length == 1 ? 0 :
methodInfoArray
.Select((info, index) => (info, index))
.Where(tuple => tuple.info == methodInfo)
.Select(tuple => tuple.index)
.FirstOrDefault());
}
public List <string> GetOverLoadList()
{
if (MethodInfos.Any())
{
return(MethodInfos
.ToList()
.Select(x => x.MethodInfo.MethodSignature() + "\r\n\r\n" + new XmlCommentsHelper().GetMethodComments(x.MethodInfo))
.ToList());
}
return(ConstructorInfos
.ToList()
.Select(x => x.ConstructorInfo.ConstructorSignature() + "\r\n\r\n" + new XmlCommentsHelper().GetConstructorComments(x.ConstructorInfo))
.ToList());
}
internal MemberInfoList(Type interfaceType)
{
MemberInfo[] membersInfos = interfaceType
.GetAllTypes()
.SelectMany(type => type.GetMembers())
.ToArray();
PropertyInfos = membersInfos
.OfType <PropertyInfo>()
.ToArray();
MethodInfos = membersInfos
.OfType <MethodInfo>()
.Where(methodInfo => !methodInfo.IsSpecialName)
.ToArray();
MethodIndexes = MethodInfos
.ToDictionary(
methodInfo => methodInfo,
FindIndex);
EventInfos = membersInfos
.OfType <EventInfo>()
.ToArray();
}
IEnumerable <MemberDeclarationSyntax> GetClassMemberDeclarations()
{
foreach (var d in NestedTypeInfos.SelectMany(x => x.Declarations))
{
yield return(d);
}
foreach (var d in FieldInfos.SelectMany(x => x.Declarations))
{
yield return(d);
}
if (HasDefaultConstructor)
{
yield return(DefaultConstructor);
}
if (IsGTypeStruct)
{
// taking advantage of the face that interfaces can't inherit,
// so parent will always be GISharp.GObject.TypeInterface for
// interfaces.
if (GTypeStructParent == typeof(GISharp.GObject.TypeInterface))
{
yield return(GetGTypeStructCreateInterfaceInfoMethod());
yield return(GetGTypeStructInterfaceInitMethod());
foreach (var m in GetGTypeInterfaceMethodImpls())
{
yield return(m);
}
}
else
{
yield return(GetGTypeStructGetInfoMethod());
}
}
foreach (var d in MethodInfos.SelectMany(x => x.Declarations))
{
yield return(d);
}
}
DumpedMethods DecryptMethods()
{
var dumpedMethods = new DumpedMethods();
var peImage = decrypterInfo.peImage;
var methodInfos = new MethodInfos(module, decrypterInfo.mainType, peImage, decrypterInfo.peHeader, decrypterInfo.mcKey);
methodInfos.InitializeInfos();
var methodDef = peImage.Metadata.TablesStream.MethodTable;
for (uint rid = 1; rid <= methodDef.Rows; rid++)
{
var dm = new DumpedMethod();
peImage.ReadMethodTableRowTo(dm, rid);
var info = methodInfos.Lookup(dm.mdRVA);
if (info == null)
{
continue;
}
ushort magic = peImage.ReadUInt16(dm.mdRVA);
if (magic != 0xFFF3)
{
continue;
}
var bodyReader = ByteArrayDataReaderFactory.CreateReader(info.body);
var mbHeader = MethodBodyParser.ParseMethodBody(ref bodyReader, out dm.code, out dm.extraSections);
peImage.UpdateMethodHeaderInfo(dm, mbHeader);
dumpedMethods.Add(dm);
}
return(dumpedMethods);
}
DumpedMethods decryptMethods()
{
var dumpedMethods = new DumpedMethods();
var peImage = decrypterInfo.peImage;
var methodInfos = new MethodInfos(decrypterInfo.mainType, peImage, decrypterInfo.peHeader, decrypterInfo.mcKey);
methodInfos.initializeInfos();
var methodDef = peImage.DotNetFile.MetaData.TablesStream.MethodTable;
for (uint rid = 1; rid <= methodDef.Rows; rid++)
{
var dm = new DumpedMethod();
peImage.readMethodTableRowTo(dm, rid);
var info = methodInfos.lookup(dm.mdRVA);
if (info == null)
{
continue;
}
ushort magic = peImage.readUInt16(dm.mdRVA);
if (magic != 0xFFF3)
{
continue;
}
var mbHeader = MethodBodyParser.parseMethodBody(MemoryImageStream.Create(info.body), out dm.code, out dm.extraSections);
peImage.updateMethodHeaderInfo(dm, mbHeader);
dumpedMethods.add(dm);
}
return(dumpedMethods);
}
IEnumerable <MemberDeclarationSyntax> GetStructMemberDeclarations()
{
return(NestedTypeInfos.SelectMany(x => x.Declarations)
.Concat(FieldInfos.SelectMany(x => x.Declarations))
.Concat(MethodInfos.SelectMany(x => x.Declarations)));
}
DumpedMethods decryptMethods()
{
var dumpedMethods = new DumpedMethods();
var peImage = decrypterInfo.peImage;
var methodInfos = new MethodInfos(decrypterInfo.mainType, peImage, decrypterInfo.peHeader, decrypterInfo.mcKey);
methodInfos.initializeInfos();
var metadataTables = peImage.Cor20Header.createMetadataTables();
var methodDef = metadataTables.getMetadataType(MetadataIndex.iMethodDef);
uint methodDefOffset = methodDef.fileOffset;
for (int i = 0; i < methodDef.rows; i++, methodDefOffset += methodDef.totalSize)
{
uint bodyRva = peImage.offsetReadUInt32(methodDefOffset);
if (bodyRva == 0)
{
continue;
}
var info = methodInfos.lookup(bodyRva);
if (info == null)
{
continue;
}
uint bodyOffset = peImage.rvaToOffset(bodyRva);
ushort magic = peImage.offsetReadUInt16(bodyOffset);
if (magic != 0xFFF3)
{
continue;
}
var dm = new DumpedMethod();
dm.token = (uint)(0x06000001 + i);
dm.mdImplFlags = peImage.offsetReadUInt16(methodDefOffset + (uint)methodDef.fields[1].offset);
dm.mdFlags = peImage.offsetReadUInt16(methodDefOffset + (uint)methodDef.fields[2].offset);
dm.mdName = peImage.offsetRead(methodDefOffset + (uint)methodDef.fields[3].offset, methodDef.fields[3].size);
dm.mdSignature = peImage.offsetRead(methodDefOffset + (uint)methodDef.fields[4].offset, methodDef.fields[4].size);
dm.mdParamList = peImage.offsetRead(methodDefOffset + (uint)methodDef.fields[5].offset, methodDef.fields[5].size);
var reader = new BinaryReader(new MemoryStream(info.body));
byte b = reader.ReadByte();
if ((b & 3) == 2)
{
dm.mhFlags = 2;
dm.mhMaxStack = 8;
dm.mhCodeSize = (uint)(b >> 2);
dm.mhLocalVarSigTok = 0;
}
else
{
reader.BaseStream.Position--;
dm.mhFlags = reader.ReadUInt16();
dm.mhMaxStack = reader.ReadUInt16();
dm.mhCodeSize = reader.ReadUInt32();
dm.mhLocalVarSigTok = reader.ReadUInt32();
uint codeOffset = (uint)(dm.mhFlags >> 12) * 4;
reader.BaseStream.Position += codeOffset - 12;
}
dm.code = reader.ReadBytes((int)dm.mhCodeSize);
if ((dm.mhFlags & 8) != 0)
{
reader.BaseStream.Position = (reader.BaseStream.Position + 3) & ~3;
dm.extraSections = reader.ReadBytes((int)(reader.BaseStream.Length - reader.BaseStream.Position));
}
dumpedMethods.add(dm);
}
return(dumpedMethods);
}
public void AddMethodInfo(MethodInfo methodInfo)
{
MethodInfos.RemoveAll(x => x.MethodName == methodInfo.MethodName);
MethodInfos.Add(methodInfo);
}
public Decrypter(MethodInfos methodInfos, int[] typeToMethod)
{
this.methodInfos = methodInfos;
this.typeToMethod = typeToMethod;
}
DumpedMethods decryptMethods()
{
var dumpedMethods = new DumpedMethods();
var methodInfos = new MethodInfos(mainType, peImage, peHeader, mcKey);
methodInfos.initializeInfos();
var metadataTables = peImage.Cor20Header.createMetadataTables();
var methodDef = metadataTables.getMetadataType(MetadataIndex.iMethodDef);
uint methodDefOffset = methodDef.fileOffset;
for (int i = 0; i < methodDef.rows; i++, methodDefOffset += methodDef.totalSize) {
uint bodyRva = peImage.offsetReadUInt32(methodDefOffset);
if (bodyRva == 0)
continue;
var info = methodInfos.lookup(bodyRva);
if (info == null)
continue;
uint bodyOffset = peImage.rvaToOffset(bodyRva);
ushort magic = peImage.offsetReadUInt16(bodyOffset);
if (magic != 0xFFF3)
continue;
var dm = new DumpedMethod();
dm.token = (uint)(0x06000001 + i);
dm.mdImplFlags = peImage.offsetReadUInt16(methodDefOffset + (uint)methodDef.fields[1].offset);
dm.mdFlags = peImage.offsetReadUInt16(methodDefOffset + (uint)methodDef.fields[2].offset);
dm.mdName = peImage.offsetRead(methodDefOffset + (uint)methodDef.fields[3].offset, methodDef.fields[3].size);
dm.mdSignature = peImage.offsetRead(methodDefOffset + (uint)methodDef.fields[4].offset, methodDef.fields[4].size);
dm.mdParamList = peImage.offsetRead(methodDefOffset + (uint)methodDef.fields[5].offset, methodDef.fields[5].size);
var reader = new BinaryReader(new MemoryStream(info.body));
byte b = reader.ReadByte();
if ((b & 3) == 2) {
dm.mhFlags = 2;
dm.mhMaxStack = 8;
dm.mhCodeSize = (uint)(b >> 2);
dm.mhLocalVarSigTok = 0;
}
else {
reader.BaseStream.Position--;
dm.mhFlags = reader.ReadUInt16();
dm.mhMaxStack = reader.ReadUInt16();
dm.mhCodeSize = reader.ReadUInt32();
dm.mhLocalVarSigTok = reader.ReadUInt32();
uint codeOffset = (uint)(dm.mhFlags >> 12) * 4;
reader.BaseStream.Position += codeOffset - 12;
}
dm.code = reader.ReadBytes((int)dm.mhCodeSize);
if ((dm.mhFlags & 8) != 0) {
reader.BaseStream.Position = (reader.BaseStream.Position + 3) & ~3;
dm.extraSections = reader.ReadBytes((int)(reader.BaseStream.Length - reader.BaseStream.Position));
}
dumpedMethods.add(dm);
}
return dumpedMethods;
}
public Decrypter(MethodInfos methodInfos, int[] typeToMethod)
{
this.methodInfos = methodInfos;
this.typeToMethod = typeToMethod;
}
public DecrypterV3(MethodInfos methodInfos)
{
this.methodInfos = methodInfos;
}
