public SharpAssemblyParameter(SharpAssembly_ asm, Param[] paramTable, uint index, IReturnType type) { if (asm == null) { throw new System.ArgumentNullException("asm"); } if (paramTable == null) { throw new System.ArgumentNullException("paramTable"); } if (index > paramTable.GetUpperBound(0) || index < 1) { throw new System.ArgumentOutOfRangeException("index", index, String.Format("must be between 1 and {0}!", paramTable.GetUpperBound(0))); } AssemblyReader assembly = asm.Reader; Param param = asm.Tables.Param[index]; name = assembly.GetStringFromHeap(param.Name); if (param.IsFlagSet(Param.FLAG_OUT)) { modifier |= ParameterModifier.Out; } // Attributes ArrayList attrib = asm.Attributes.Param[index] as ArrayList; if (attrib == null) goto noatt; foreach(SharpCustomAttribute customattribute in attrib) { SharpAssemblyAttribute newatt = new SharpAssemblyAttribute(asm, customattribute); if (newatt.Name == "System.ParamArrayAttribute") modifier |= ParameterModifier.Params; attributeCollection.Add(newatt); } noatt: if (type == null) { returnType = new SharpAssemblyReturnType("PARAMETER_UNKNOWN"); } else { if (type.Name.EndsWith("&")) { modifier |= ParameterModifier.Ref; } returnType = type; } }
public SharpAssemblyField(SharpAssembly_ assembly, Field[] fieldTable, SharpAssemblyClass declaringtype, uint index) { if (assembly == null) { throw new System.ArgumentNullException("assembly"); } if (fieldTable == null) { throw new System.ArgumentNullException("fieldTable"); } if (declaringtype == null) { throw new System.ArgumentNullException("declaringtype"); } if (index > fieldTable.GetUpperBound(0) || index < 0) { throw new System.ArgumentOutOfRangeException("index", index, String.Format("must be between 1 and {0}!", fieldTable.GetUpperBound(0))); } declaringType = declaringtype; Field field = fieldTable[index]; string name = assembly.Reader.GetStringFromHeap(field.Name); FullyQualifiedName = String.Concat(declaringType.FullyQualifiedName, ".", name); // Attributes ArrayList attrib = assembly.Attributes.Field[index] as ArrayList; if (attrib == null) goto noatt; AbstractAttributeSection sect = new AbstractAttributeSection(); foreach(SharpCustomAttribute customattribute in attrib) { sect.Attributes.Add(new SharpAssemblyAttribute(assembly, customattribute)); } attributes.Add(sect); noatt: if (field.IsFlagSet(Field.FLAG_INITONLY)) { modifiers |= ModifierEnum.Readonly; } if (field.IsFlagSet(Field.FLAG_STATIC)) { modifiers |= ModifierEnum.Static; } if (field.IsMaskedFlagSet(Field.FLAG_PRIVATE, Field.FLAG_FIELDACCESSMASK)) { // I assume that private is used most and public last (at least should be) modifiers |= ModifierEnum.Private; } else if (field.IsMaskedFlagSet(Field.FLAG_FAMILY, Field.FLAG_FIELDACCESSMASK)) { modifiers |= ModifierEnum.Protected; } else if (field.IsMaskedFlagSet(Field.FLAG_PUBLIC, Field.FLAG_FIELDACCESSMASK)) { modifiers |= ModifierEnum.Public; } else if (field.IsMaskedFlagSet(Field.FLAG_ASSEMBLY, Field.FLAG_FIELDACCESSMASK)) { modifiers |= ModifierEnum.Internal; } else if (field.IsMaskedFlagSet(Field.FLAG_FAMORASSEM, Field.FLAG_FIELDACCESSMASK)) { modifiers |= ModifierEnum.ProtectedOrInternal; } else if (field.IsMaskedFlagSet(Field.FLAG_FAMANDASSEM, Field.FLAG_FIELDACCESSMASK)) { modifiers |= ModifierEnum.Protected; modifiers |= ModifierEnum.Internal; } if (field.IsFlagSet(Field.FLAG_LITERAL)) { modifiers |= ModifierEnum.Const; } if (field.IsFlagSet(Field.FLAG_SPECIALNAME)) { modifiers |= ModifierEnum.SpecialName; } // field return type uint sigOffset = field.Signature; assembly.Reader.LoadBlob(ref sigOffset); sigOffset++; // skip field id returnType = new SharpAssemblyReturnType(assembly, ref sigOffset); // field constant value -- for enums Constant cst = (Constant)assembly.FieldConstantTable[index]; if (declaringtype.ClassType == ClassType.Enum && cst != null) { try { DataType dt = (DataType)cst.Type; byte[] blob = assembly.Reader.GetBlobFromHeap(cst.Val); BinaryReader binReader = new BinaryReader(new MemoryStream(blob)); switch (dt) { case DataType.Byte: initialValue = binReader.ReadByte(); break; case DataType.Int16: initialValue = binReader.ReadInt16(); break; case DataType.Int32: initialValue = binReader.ReadInt32(); break; case DataType.Int64: initialValue = binReader.ReadInt64(); break; case DataType.SByte: initialValue = binReader.ReadSByte(); break; case DataType.UInt16: initialValue = binReader.ReadUInt16(); break; case DataType.UInt32: initialValue = binReader.ReadUInt32(); break; case DataType.UInt64: initialValue = binReader.ReadUInt64(); break; default: // not supported break; } binReader.Close(); } catch { Runtime.LoggingService.Info("SharpAssemblyField: Error reading constant value"); } } }
public SharpAssemblyAttribute(SharpAssembly_ assembly, SharpCustomAttribute attribute) { uint sigOffset = 0; if (attribute.IsMemberRef) { MemberRef[] memberTable = assembly.Tables.MemberRef; sigOffset = memberTable[attribute.MemberIndex].Signature; uint trIndex = memberTable[attribute.MemberIndex].Class; int table = assembly.Reader.GetCodedIndexTable(CodedIndex.MemberRefParent, ref trIndex); if (table != 1) { Runtime.LoggingService.Info("SharpAssemblyAttribute: unsupported MemberRefParent coded index"); return; // unsupported } attributeType = SharpAssemblyClass.FromTypeRef(assembly, trIndex); } else { TypeDef[] typeDefTable = assembly.Tables.TypeDef; sigOffset = assembly.Tables.Method[attribute.MemberIndex].Signature; uint tdIndex = 0; for (uint i = 1; i <= typeDefTable.GetUpperBound(0); ++i) { if (typeDefTable[i].MethodList <= attribute.MemberIndex && i == typeDefTable.GetUpperBound(0)) { tdIndex = i; break; } if (typeDefTable[i].MethodList <= attribute.MemberIndex && typeDefTable[i+1].MethodList > attribute.MemberIndex) { tdIndex = i; break; } } attributeType = SharpAssemblyClass.FromTypeDef(assembly, tdIndex); } if (attributeType != null) name = attributeType.FullyQualifiedName; if (attribute.ValueIndex == 0) return; try { // Get return types of positional arguments by inspecting the method signature assembly.Reader.LoadBlob(ref sigOffset); sigOffset += 1; // skip calling convention int numReturnTypes = assembly.Reader.LoadBlob(ref sigOffset); new SharpAssemblyReturnType(assembly, ref sigOffset); SharpAssemblyReturnType[] returnTypes = new SharpAssemblyReturnType[numReturnTypes]; for (int i = 0; i < returnTypes.Length; ++i) { returnTypes[i] = new SharpAssemblyReturnType(assembly, ref sigOffset); } // Get the return type values and the named arguments byte[] argBlob = assembly.Reader.GetBlobFromHeap(attribute.ValueIndex); Stream str = new MemoryStream(argBlob); BinaryReader binaryReader = new BinaryReader(str); ushort prolog = binaryReader.ReadUInt16(); if (prolog != 1) { Runtime.LoggingService.Info("SharpAssemblyAttribute: Wrong prolog in argument list"); return; } // read positional arguments for (int i = 0; i < returnTypes.Length; ++i) { string rettypename = returnTypes[i].Name; SharpAssemblyClass underlyingClass = returnTypes[i].UnderlyingClass; // enum -> determine base integer size and try to display the user-friendly name of the value if (underlyingClass != null && underlyingClass.IsSubclassOf("System.Enum")) { //underlyingClass.LoadMembers(); foreach (IField field in underlyingClass.Fields) { if (field.Name.EndsWith("value__")) { rettypename = field.ReturnType.Name; break; } } Runtime.LoggingService.Info("Enum: return type = " + rettypename); object argValue = GetFixedArg(argBlob, binaryReader, rettypename); Runtime.LoggingService.Info("Enum: arg value = " + argValue.ToString()); foreach (IField field in underlyingClass.Fields) { if (field is SharpAssemblyField) { try { if (((field as SharpAssemblyField).InitialValue as IComparable).CompareTo(argValue) == 0) { positionalArguments.Add(underlyingClass.Name + "." + field.Name); goto namefound; } } catch {} } } // if the value cannot be found positionalArguments.Add(argValue.ToString()); Runtime.LoggingService.Info("Enum: no name found"); namefound: ; } else { positionalArguments.Add(GetFixedArg(argBlob, binaryReader, rettypename).ToString()); } } ushort numnamed = binaryReader.ReadUInt16(); for (int i = 0; i < numnamed; ++i) { /*byte field_or_prop = */ binaryReader.ReadByte(); byte type = binaryReader.ReadByte(); string typename = ""; if (type == 0x50) { typename = "Type"; } else { DataType dt = (DataType)type; typename = dt.ToString(); } string argname = GetSerString(argBlob, binaryReader.BaseStream); namedArguments.Add(argname, GetFixedArg(argBlob, binaryReader, typename).ToString()); } binaryReader.Close(); } catch (Exception) { Runtime.LoggingService.Info("SharpAssemblyAttribute: Error loading arguments."); //Runtime.LoggingService.Info(e.ToString()); } }
public SharpAssemblyMethod(SharpAssembly_ asm, Method[] methodTable, SharpAssemblyClass declaringtype, uint index) { if (asm == null) { throw new System.ArgumentNullException("asm"); } if (methodTable == null) { throw new System.ArgumentNullException("methodTable"); } if (declaringtype == null) { throw new System.ArgumentNullException("declaringType"); } if (index > methodTable.GetUpperBound(0) || index < 1) { throw new System.ArgumentOutOfRangeException("index", index, String.Format("must be between 1 and {0}!", methodTable.GetUpperBound(0))); } AssemblyReader assembly = asm.Reader; declaringType = declaringtype; Method methodDef = methodTable[index]; string name = assembly.GetStringFromHeap(methodDef.Name); FullyQualifiedName = String.Concat(declaringType.FullyQualifiedName, ".", name); // Attributes ArrayList attrib = asm.Attributes.Method[index] as ArrayList; if (attrib == null) goto noatt; AbstractAttributeSection sect = new AbstractAttributeSection(); foreach(SharpCustomAttribute customattribute in attrib) { sect.Attributes.Add(new SharpAssemblyAttribute(asm, customattribute)); } attributes.Add(sect); noatt: modifiers = ModifierEnum.None; if (methodDef.IsFlagSet(Method.FLAG_STATIC)) { modifiers |= ModifierEnum.Static; } if (methodDef.IsMaskedFlagSet(Method.FLAG_PRIVATE, Method.FLAG_MEMBERACCESSMASK)) { modifiers |= ModifierEnum.Private; } else if (methodDef.IsMaskedFlagSet(Method.FLAG_PUBLIC, Method.FLAG_MEMBERACCESSMASK)) { modifiers |= ModifierEnum.Public; } else if (methodDef.IsMaskedFlagSet(Method.FLAG_FAMILY, Method.FLAG_MEMBERACCESSMASK)) { modifiers |= ModifierEnum.Protected; } else if (methodDef.IsMaskedFlagSet(Method.FLAG_ASSEM, Method.FLAG_MEMBERACCESSMASK)) { modifiers |= ModifierEnum.Internal; } else if (methodDef.IsMaskedFlagSet(Method.FLAG_FAMORASSEM, Method.FLAG_MEMBERACCESSMASK)) { modifiers |= ModifierEnum.ProtectedOrInternal; } else if (methodDef.IsMaskedFlagSet(Method.FLAG_FAMANDASSEM, Method.FLAG_MEMBERACCESSMASK)) { modifiers |= ModifierEnum.Protected; modifiers |= ModifierEnum.Internal; } if (methodDef.IsFlagSet(Method.FLAG_VIRTUAL)) { modifiers |= ModifierEnum.Virtual; } if (methodDef.IsFlagSet(Method.FLAG_FINAL)) { modifiers |= ModifierEnum.Final; } if (methodDef.IsFlagSet(Method.FLAG_ABSTRACT)) { modifiers |= ModifierEnum.Abstract; } if (methodDef.IsFlagSet(Method.FLAG_SPECIALNAME)) { modifiers |= ModifierEnum.SpecialName; } uint offset = methodDef.Signature; assembly.LoadBlob(ref offset); offset += 1; // skip calling convention int numReturnTypes = assembly.LoadBlob(ref offset); returnType = new SharpAssemblyReturnType(asm, ref offset); IReturnType[] returnTypes = new IReturnType[numReturnTypes]; for (int i = 0; i < returnTypes.Length; ++i) { returnTypes[i] = new SharpAssemblyReturnType(asm, ref offset); } AddParameters(asm, methodTable, index, returnTypes); }
public SharpAssemblyProperty(SharpAssembly_ asm, Property[] propertyTable, SharpAssemblyClass declaringtype, uint index) { if (asm == null) { throw new System.ArgumentNullException("asm"); } if (propertyTable == null) { throw new System.ArgumentNullException("propertyTable"); } if (declaringtype == null) { throw new System.ArgumentNullException("declaringType"); } if (index > propertyTable.GetUpperBound(0) || index < 1) { throw new System.ArgumentOutOfRangeException("index", index, String.Format("must be between 1 and {0}!", propertyTable.GetUpperBound(0))); } AssemblyReader assembly = asm.Reader; declaringType = declaringtype; Property property = asm.Tables.Property[index]; string name = assembly.GetStringFromHeap(property.Name); FullyQualifiedName = String.Concat(declaringType.FullyQualifiedName, ".", name); MethodSemantics[] sem = (MethodSemantics[])assembly.MetadataTable.Tables[MethodSemantics.TABLE_ID]; Method[] method = (Method[])assembly.MetadataTable.Tables[Method.TABLE_ID]; uint getterMethodIndex = 0; // used later for parameters if (sem == null) goto nosem; for (int i = 1; i <= sem.GetUpperBound(0); ++i) { uint table = sem[i].Association & 1; uint ident = sem[i].Association >> 1; if (table == 1 && ident == index) { // table: Property modifiers = ModifierEnum.None; Method methodDef = method[sem[i].Method]; if (methodDef.IsFlagSet(Method.FLAG_STATIC)) { modifiers |= ModifierEnum.Static; } if (methodDef.IsFlagSet(Method.FLAG_ABSTRACT)) { modifiers |= ModifierEnum.Abstract; } if (methodDef.IsFlagSet(Method.FLAG_VIRTUAL)) { modifiers |= ModifierEnum.Virtual; } if (methodDef.IsFlagSet(Method.FLAG_FINAL)) { modifiers |= ModifierEnum.Final; } if (methodDef.IsMaskedFlagSet(Method.FLAG_PRIVATE, Method.FLAG_MEMBERACCESSMASK)) { // I assume that private is used most and public last (at least should be) modifiers |= ModifierEnum.Private; } else if (methodDef.IsMaskedFlagSet(Method.FLAG_FAMILY, Method.FLAG_MEMBERACCESSMASK)) { modifiers |= ModifierEnum.Protected; } else if (methodDef.IsMaskedFlagSet(Method.FLAG_PUBLIC, Method.FLAG_MEMBERACCESSMASK)) { modifiers |= ModifierEnum.Public; } else if (methodDef.IsMaskedFlagSet(Method.FLAG_ASSEM, Method.FLAG_MEMBERACCESSMASK)) { modifiers |= ModifierEnum.Internal; } else if (methodDef.IsMaskedFlagSet(Method.FLAG_FAMORASSEM, Method.FLAG_MEMBERACCESSMASK)) { modifiers |= ModifierEnum.ProtectedOrInternal; } else if (methodDef.IsMaskedFlagSet(Method.FLAG_FAMANDASSEM, Method.FLAG_MEMBERACCESSMASK)) { modifiers |= ModifierEnum.Protected; modifiers |= ModifierEnum.Internal; } if ((sem[i].Semantics & MethodSemantics.SEM_GETTER) == MethodSemantics.SEM_GETTER) { getterRegion = new DefaultRegion(0, 0, 0, 0); getterMethod = new SharpAssemblyMethod(asm, method, declaringtype, sem[i].Method); getterMethodIndex = sem[i].Method; } if ((sem[i].Semantics & MethodSemantics.SEM_SETTER) == MethodSemantics.SEM_SETTER) { setterRegion = new DefaultRegion(0, 0, 0, 0); setterMethod = new SharpAssemblyMethod(asm, method, declaringtype, sem[i].Method); } } } nosem: // Attributes ArrayList attrib = asm.Attributes.Property[index] as ArrayList; if (attrib == null) goto noatt; AbstractAttributeSection sect = new AbstractAttributeSection(); foreach(SharpCustomAttribute customattribute in attrib) { sect.Attributes.Add(new SharpAssemblyAttribute(asm, customattribute)); } attributes.Add(sect); noatt: if ((property.Flags & Property.FLAG_SPECIALNAME) == Property.FLAG_SPECIALNAME) modifiers |= ModifierEnum.SpecialName; uint offset = property.Type; assembly.LoadBlob(ref offset); offset += 1; // skip calling convention int paramCount = assembly.LoadBlob(ref offset); returnType = new SharpAssemblyReturnType(asm, ref offset); IReturnType[] returnTypes = new IReturnType[paramCount]; for (int i = 0; i < returnTypes.Length; ++i) { returnTypes[i] = new SharpAssemblyReturnType(asm, ref offset); } if (getterMethodIndex != 0) { AddParameters(asm, asm.Tables.Method, getterMethodIndex, returnTypes); } else { AddParameters(asm, returnTypes); } }
public SharpAssemblyEvent(SharpAssembly_ asm, Event[] eventTable, SharpAssemblyClass declaringtype, uint index) { if (asm == null) { throw new System.ArgumentNullException("asm"); } if (eventTable == null) { throw new System.ArgumentNullException("eventTable"); } if (declaringtype == null) { throw new System.ArgumentNullException("declaringtype"); } if (index > eventTable.GetUpperBound(0) || index < 1) { throw new System.ArgumentOutOfRangeException("index", index, String.Format("must be between 1 and {0}!", eventTable.GetUpperBound(0))); } AssemblyReader assembly = asm.Reader; declaringType = declaringtype; Event evt = eventTable[index]; string name = assembly.GetStringFromHeap(evt.Name); FullyQualifiedName = String.Concat(declaringType.FullyQualifiedName, ".", name); MethodSemantics[] sem = asm.Tables.MethodSemantics; Method[] method = asm.Tables.Method; if (sem == null) goto nosem; for (int i = 1; i <= sem.GetUpperBound(0); ++i) { uint table = sem[i].Association & 1; uint ident = sem[i].Association >> 1; if (table == 0 && ident == index) { // table: Event modifiers = ModifierEnum.None; Method methodDef = method[sem[i].Method]; if (methodDef.IsFlagSet(Method.FLAG_STATIC)) { modifiers |= ModifierEnum.Static; } if (methodDef.IsMaskedFlagSet(Method.FLAG_PRIVATE, Method.FLAG_MEMBERACCESSMASK)) { // I assume that private is used most and public last (at least should be) modifiers |= ModifierEnum.Private; } else if (methodDef.IsMaskedFlagSet(Method.FLAG_FAMILY, Method.FLAG_MEMBERACCESSMASK)) { modifiers |= ModifierEnum.Protected; } else if (methodDef.IsMaskedFlagSet(Method.FLAG_PUBLIC, Method.FLAG_MEMBERACCESSMASK)) { modifiers |= ModifierEnum.Public; } else if (methodDef.IsMaskedFlagSet(Method.FLAG_ASSEM, Method.FLAG_MEMBERACCESSMASK)) { modifiers |= ModifierEnum.Internal; } else if (methodDef.IsMaskedFlagSet(Method.FLAG_FAMORASSEM, Method.FLAG_MEMBERACCESSMASK)) { modifiers |= ModifierEnum.ProtectedOrInternal; } else if (methodDef.IsMaskedFlagSet(Method.FLAG_FAMANDASSEM, Method.FLAG_MEMBERACCESSMASK)) { modifiers |= ModifierEnum.Protected; modifiers |= ModifierEnum.Internal; } if ((sem[i].Semantics & MethodSemantics.SEM_ADDON) == MethodSemantics.SEM_ADDON) { addMethod = new SharpAssemblyMethod(asm, method, declaringtype, sem[i].Method); } if ((sem[i].Semantics & MethodSemantics.SEM_REMOVEON) == MethodSemantics.SEM_REMOVEON) { removeMethod = new SharpAssemblyMethod(asm, method, declaringtype, sem[i].Method); } if ((sem[i].Semantics & MethodSemantics.SEM_FIRE) == MethodSemantics.SEM_FIRE) { raiseMethod = new SharpAssemblyMethod(asm, method, declaringtype, sem[i].Method); } } } nosem: // Attributes ArrayList attrib = asm.Attributes.Event[index] as ArrayList; if (attrib == null) goto noatt; AbstractAttributeSection sect = new AbstractAttributeSection(); foreach(SharpCustomAttribute customattribute in attrib) { sect.Attributes.Add(new SharpAssemblyAttribute(asm, customattribute)); } attributes.Add(sect); noatt: if ((evt.EventFlags & Event.FLAG_SPECIALNAME) == Event.FLAG_SPECIALNAME) modifiers |= ModifierEnum.SpecialName; uint typtab = evt.EventType & 0x03; uint typid = evt.EventType >> 2; if (typtab == 0) { // TypeDef TypeDef[] typedef = (TypeDef[])assembly.MetadataTable.Tables[TypeDef.TABLE_ID]; returnType = new SharpAssemblyReturnType(asm, typedef, typid); } else if (typtab == 1) { // TypeRef TypeRef[] typeref = (TypeRef[])assembly.MetadataTable.Tables[TypeRef.TABLE_ID]; returnType = new SharpAssemblyReturnType(asm, typeref, typid); } else { // TypeSpec returnType = new SharpAssemblyReturnType("NOT_SUPPORTED"); Runtime.LoggingService.Info("SharpAssemblyEvent: TypeSpec -- not supported"); } }