public CLRSigParamOrRetType(CLRSignatureParser parser, bool allowSentinel)
{
CustomMods = CLRSigType.ReadCustomMods(parser);
CLRSignatureParser.Token token = parser.NextToken();
if (token == CLRSignatureParser.Token.TYPEDBYREF)
{
TypeOfType = TypeOfTypeEnum.TypedByRef;
parser.ConsumeToken();
}
else if (token == CLRSignatureParser.Token.SENTINEL)
{
if (!allowSentinel)
throw new ParseFailedException("Malformed signature");
TypeOfType = TypeOfTypeEnum.Sentinel;
parser.ConsumeToken();
}
else
{
bool allowVoid = AllowVoid;
if (token == CLRSignatureParser.Token.BYREF)
{
TypeOfType = TypeOfTypeEnum.ByRef;
token = parser.NextToken();
parser.ConsumeToken();
allowVoid = false;
}
else
TypeOfType = TypeOfTypeEnum.Value;
Type = CLRSigType.Parse(parser, allowVoid);
}
}
public CLRSigFieldSig(CLRSignatureParser parser)
{
if (parser.NextByte() != 0x6)
throw new ParseFailedException("Malformed FieldSig");
parser.ConsumeByte();
CustomMods = CLRSigType.ReadCustomMods(parser);
Type = CLRSigType.Parse(parser, false);
}
public CLRSigLocalVarSig(CLRSignatureParser parser)
{
if (parser.NextToken() != CLRSignatureParser.Token.LOCAL_SIG)
throw new ParseFailedException("Invalid local var sig");
parser.ConsumeToken();
uint numLocals = parser.ReadCompressedUInt();
LocalVars = new CLRSigLocalVar[numLocals];
for (uint i = 0; i < numLocals; i++)
LocalVars[i] = new CLRSigLocalVar(parser);
}
public CLRSigMethodSpec(CLRSignatureParser parser)
{
if (parser.NextToken() != CLRSignatureParser.Token.GENERICINST)
throw new ParseFailedException("Malformed method spec");
parser.ConsumeToken();
uint numGenericParams = parser.ReadCompressedUInt();
Types = new CLRSigType[numGenericParams];
for (uint i = 0; i < numGenericParams; i++)
{
Types[i] = CLRSigType.Parse(parser, false);
}
}
public CLRSigCustomAttributeNamedArg(CLRSignatureParser parser)
{
CLRSigType.ElementType baseType = (CLRSigType.ElementType)parser.ReadU8();
if (baseType == CLRSigType.ElementType.Special_CustomAttribField)
ArgKind = ArgKindEnum.Field;
else if (baseType == CLRSigType.ElementType.Special_CustomAttribProperty)
ArgKind = ArgKindEnum.Property;
else
throw new ParseFailedException("Unusual named arg type");
CLRSigType argType = CLRSigCustomAttributeElem.ReadFieldOrPropType(parser);
Name = CLRSigCustomAttributeElem.ReadUTF8String(parser);
Arg = new CLRSigCustomAttributeFixedArg(parser, argType);
}
public static CLRSigType Parse(CLRSignatureParser parser, bool permitVoid)
{
ElementType eType = (ElementType)parser.NextByte();
parser.ConsumeByte();
switch (eType)
{
case ElementType.BOOLEAN:
case ElementType.CHAR:
case ElementType.I1:
case ElementType.U1:
case ElementType.I2:
case ElementType.U2:
case ElementType.I4:
case ElementType.U4:
case ElementType.I8:
case ElementType.U8:
case ElementType.R4:
case ElementType.R8:
case ElementType.I:
case ElementType.U:
case ElementType.OBJECT:
case ElementType.STRING:
return new CLRSigTypeSimple(eType);
case ElementType.VOID:
if (!permitVoid)
throw new ParseFailedException("Unexpected void type");
return new CLRSigTypeSimple(eType);
case ElementType.ARRAY:
return new CLRSigTypeArray(eType, parser);
case ElementType.CLASS:
case ElementType.VALUETYPE:
return new CLRSigTypeStructured(eType, parser);
case ElementType.FNPTR:
return new CLRSigTypeFunctionPointer(eType, parser);
case ElementType.GENERICINST:
return new CLRSigTypeGenericInstantiation(eType, parser);
case ElementType.MVAR:
case ElementType.VAR:
return new CLRSigTypeVarOrMVar(eType, parser);
case ElementType.PTR:
return new CLRSigTypePointer(eType, parser);
case ElementType.SZARRAY:
return new CLRSigTypeSZArray(eType, parser);
default:
throw new ParseFailedException("Unexpected sig type");
}
}
public CLRSigCustomMod(CLRSignatureParser parser)
{
byte token = parser.NextByte();
parser.ConsumeByte();
if (token == 0x1f)
IsOptional = false;
else if (token == 0x20)
IsOptional = true;
else
throw new ParseFailedException("Strange custom mod token");
IndexedType = parser.ReadTypeDefOrRefOrSpecEncoded();
throw new NotSupportedException("Custom modifiers are not supported");
}
public CLRSigTypeSpec(CLRSignatureParser parser)
{
byte token = parser.NextByte();
// VAR and MVAR aren't permitted by the spec, but that appears to be an error
if (token != (byte)CLRSigType.ElementType.PTR &&
token != (byte)CLRSigType.ElementType.FNPTR &&
token != (byte)CLRSigType.ElementType.ARRAY &&
token != (byte)CLRSigType.ElementType.SZARRAY &&
token != (byte)CLRSigType.ElementType.GENERICINST &&
token != (byte)CLRSigType.ElementType.MVAR &&
token != (byte)CLRSigType.ElementType.VAR)
throw new ParseFailedException("Invalid sig type for type spec");
Type = CLRSigType.Parse(parser, false);
}
public static string ReadUTF8String(CLRSignatureParser parser)
{
byte firstByte = parser.NextByte();
if (firstByte == 0xff)
return null;
else
{
uint stringLengthBytes = parser.ReadCompressedUInt();
if (stringLengthBytes == 0)
return "";
else
{
byte[] utf8chars = new byte[stringLengthBytes];
parser.ReadBytes(utf8chars, stringLengthBytes);
return System.Text.Encoding.UTF8.GetString(utf8chars);
}
}
}
public CLRSigPropertySig(CLRSignatureParser parser)
{
CLRSignatureParser.Token headToken = parser.NextToken();
parser.ConsumeToken();
if (headToken == CLRSignatureParser.Token.PROPERTY_HASTHIS)
HasThis = true;
else if (headToken == CLRSignatureParser.Token.PROPERTY)
HasThis = false;
else
throw new ParseFailedException("Malformed PropertySig");
uint paramCount = parser.ReadCompressedUInt();
CustomMods = CLRSigType.ReadCustomMods(parser);
Type = CLRSigType.Parse(parser, false);
Parameters = new CLRSigParamType[paramCount];
for (uint i = 0; i < paramCount; i++)
Parameters[i] = new CLRSigParamType(parser, false);
}
public static CLRSigType ReadFieldOrPropType(CLRSignatureParser parser)
{
CLRSigType.ElementType basicType = (CLRSigType.ElementType)parser.ReadU8();
switch (basicType)
{
case CLRSigType.ElementType.BOOLEAN:
case CLRSigType.ElementType.CHAR:
case CLRSigType.ElementType.R4:
case CLRSigType.ElementType.R8:
case CLRSigType.ElementType.I1:
case CLRSigType.ElementType.U1:
case CLRSigType.ElementType.I2:
case CLRSigType.ElementType.U2:
case CLRSigType.ElementType.I4:
case CLRSigType.ElementType.U4:
case CLRSigType.ElementType.I8:
case CLRSigType.ElementType.U8:
case CLRSigType.ElementType.STRING:
return new CLRSigTypeSimple(basicType);
case CLRSigType.ElementType.Special_CustomAttribBoxedObject:
return new CLRSigTypeSimple(CLRSigType.ElementType.OBJECT);
case CLRSigType.ElementType.Special_CustomAttribEnum:
{
string typeName = ReadUTF8String(parser);
throw new NotImplementedException();
}
break;
case CLRSigType.ElementType.Special_SystemType:
// CLARITYTODO: Look up System.Type
throw new NotImplementedException();
case CLRSigType.ElementType.SZARRAY:
{
CLRSigType containedType = ReadFieldOrPropType(parser);
return new CLRSigTypeArray(CLRSigType.ElementType.SZARRAY, containedType);
}
default:
throw new ParseFailedException("Unexpected field or prop type");
}
}
public CLRSigCustomAttribute(CLRSignatureParser parser, CLRTableRow constructor)
{
Constructor = constructor;
if (parser.ReadU16() != 0x0001)
throw new NotSupportedException("Unusual CA prolog");
CLRSigMethodDefOrRefSig methodSig = null;
if (constructor is CLRMethodDefRow)
{
CLRMethodDefRow methodDef = (CLRMethodDefRow)constructor;
methodSig = methodDef.Signature;
}
else if (constructor is CLRMemberRefRow)
{
CLRMemberRefRow memberRef = (CLRMemberRefRow)constructor;
methodSig = memberRef.MethodSig;
if (methodSig == null)
throw new ParseFailedException("Bad CA constructor");
}
else
throw new ParseFailedException("Missing CA constructor");
int numFixedArgs = methodSig.ParamTypes.Length;
FixedArgs = new CLRSigCustomAttributeFixedArg[numFixedArgs];
for (int i = 0; i < numFixedArgs; i++)
{
CLRSigType paramType = methodSig.ParamTypes[i].Type;
CLRSigType containedType = paramType;
if (paramType is CLRSigTypeArray)
containedType = ((CLRSigTypeArray)paramType).ContainedType;
FixedArgs[i] = new CLRSigCustomAttributeFixedArg(parser, paramType);
}
uint numNamedArgs = parser.ReadU16();
NamedArgs = new CLRSigCustomAttributeNamedArg[numNamedArgs];
for (uint i = 0; i < numNamedArgs; i++)
NamedArgs[i] = new CLRSigCustomAttributeNamedArg(parser);
}
public CLRSigTypeArray(ElementType type, CLRSignatureParser parser)
{
BasicType = type;
ContainedType = CLRSigType.Parse(parser, false);
// ArrayShape (II.23.2.13)
Rank = parser.ReadCompressedUInt();
uint numSizes = parser.ReadCompressedUInt();
if (numSizes > Rank)
throw new ParseFailedException("Invalid array");
Sizes = new uint[numSizes];
for (uint i = 0; i < numSizes; i++)
Sizes[i] = parser.ReadCompressedUInt();
uint numLowBounds = parser.ReadCompressedUInt();
if (numLowBounds > Rank)
throw new ParseFailedException("Invalid array");
LowBounds = new int[numLowBounds];
for (uint i = 0; i < numLowBounds; i++)
LowBounds[i] = parser.ReadCompressedInt();
}
private void Parse(CLRSignatureParser parser, CLRSigType elemType)
{
ElementType = elemType.BasicType;
switch (elemType.BasicType)
{
case CLRSigType.ElementType.BOOLEAN:
Value = (parser.ReadU8() != 0);
break;
case CLRSigType.ElementType.CHAR:
Value = (char)(parser.ReadU16());
break;
case CLRSigType.ElementType.R4:
Value = parser.ReadF32();
break;
case CLRSigType.ElementType.R8:
Value = parser.ReadF64();
break;
case CLRSigType.ElementType.I1:
Value = parser.ReadS8();
break;
case CLRSigType.ElementType.U1:
Value = parser.ReadU8();
break;
case CLRSigType.ElementType.I2:
Value = parser.ReadS16();
break;
case CLRSigType.ElementType.U2:
Value = parser.ReadU16();
break;
case CLRSigType.ElementType.I4:
Value = parser.ReadS32();
break;
case CLRSigType.ElementType.U4:
Value = parser.ReadU32();
break;
case CLRSigType.ElementType.I8:
Value = parser.ReadS64();
break;
case CLRSigType.ElementType.U8:
Value = parser.ReadU64();
break;
case CLRSigType.ElementType.STRING:
Value = ReadUTF8String(parser);
break;
case CLRSigType.ElementType.OBJECT:
Parse(parser, ReadFieldOrPropType(parser));
return;
case CLRSigType.ElementType.CLASS:
case CLRSigType.ElementType.VALUETYPE:
{
CLRSigTypeStructured st = (CLRSigTypeStructured)elemType;
CLRTableRow underlyingType = st.TypeDefOrRefOrSpec;
string typeNamespace, typeName;
if (underlyingType is CLRTypeDefRow)
{
CLRTypeDefRow typeDef = (CLRTypeDefRow)underlyingType;
typeNamespace = typeDef.TypeNamespace;
typeName = typeDef.TypeName;
}
else if (underlyingType is CLRTypeRefRow)
{
CLRTypeRefRow typeRef = (CLRTypeRefRow)underlyingType;
typeNamespace = typeRef.TypeNamespace;
typeName = typeRef.TypeName;
}
else
throw new ParseFailedException("Unusual CA type");
if (typeNamespace == "System" && typeName == "Type")
{
Parse(parser, new CLRSigTypeSimple(CLRSigType.ElementType.STRING));
return;
}
// Must be an enum
{
CLRTypeDefRow enumType;
if (underlyingType is CLRTypeDefRow)
enumType = (CLRTypeDefRow)underlyingType;
else if (underlyingType is CLRTypeRefRow)
{
CLRTypeRefRow typeRef = (CLRTypeRefRow)underlyingType;
if (typeRef.Resolution == null)
throw new ParseFailedException("Custom attribute references unresolved enum type");
enumType = typeRef.Resolution;
}
else
throw new ParseFailedException("Unexpected CA underlying type");
CLRSigType valueType = null;
foreach (CLRFieldRow field in enumType.Fields)
{
if (!field.Static)
{
valueType = field.Signature.Type;
break;
}
}
if (valueType == null)
throw new ParseFailedException("Unknown CA enum type");
Parse(parser, valueType);
}
}
break;
default:
throw new NotSupportedException("Unsupported custom attrib type");
}
}
public CLRSigRetType(CLRSignatureParser parser)
: base(parser, false)
{
}
public CLRSigTypeVarOrMVar(ElementType type, CLRSignatureParser parser)
{
BasicType = type;
Value = parser.ReadCompressedUInt();
}
public CLRSigTypeStructured(ElementType type, CLRSignatureParser parser)
{
BasicType = type;
TypeDefOrRefOrSpec = parser.ReadTypeDefOrRefOrSpecEncoded();
}
public CLRSigTypeSZArray(ElementType type, CLRSignatureParser parser)
{
BasicType = type;
CustomMods = CLRSigType.ReadCustomMods(parser);
ContainedType = CLRSigType.Parse(parser, true);
}
public CLRSigTypePointer(ElementType type, CLRSignatureParser parser)
{
BasicType = type;
CustomMods = CLRSigType.ReadCustomMods(parser);
PointedToType = CLRSigType.Parse(parser, true);
}
public CLRSigTypeGenericInstantiation(ElementType type, CLRSignatureParser parser)
{
BasicType = type;
ElementType instType = (ElementType)parser.NextByte();
parser.ConsumeByte();
if (instType == ElementType.CLASS)
InstantiationType = InstType.Class;
else if (instType == ElementType.VALUETYPE)
InstantiationType = InstType.ValueType;
else
throw new ParseFailedException("Unexpected instantiation type");
GenericType = parser.ReadTypeDefOrRefOrSpecEncoded();
uint genArgCount = parser.ReadCompressedUInt();
ArgTypes = new CLRSigType[genArgCount];
for (uint i = 0; i < genArgCount; i++)
ArgTypes[i] = CLRSigType.Parse(parser, false);
}
public CLRSigCustomAttributeElem(CLRSignatureParser parser, CLRSigType overallType)
{
Parse(parser, overallType);
}
public static CLRSigCustomMod[] ReadCustomMods(CLRSignatureParser parser)
{
List<CLRSigCustomMod> customMods = new List<CLRSigCustomMod>();
byte nextToken = parser.NextByte();
while (nextToken == (byte)ElementType.CMOD_OPT || nextToken == (byte)ElementType.CMOD_REQD)
{
customMods.Add(new CLRSigCustomMod(parser));
nextToken = parser.NextByte();
throw new NotImplementedException();
}
return customMods.ToArray();
}
public static void ReadCustomModsAndConstraints(CLRSignatureParser parser, out CLRSigCustomMod[] outCustomMods, out CLRSigConstraint[] outConstraints)
{
List<CLRSigCustomMod> customMods = new List<CLRSigCustomMod>();
List<CLRSigConstraint> constraints = new List<CLRSigConstraint>();
byte nextToken = parser.NextByte();
while (true)
{
if (nextToken == (byte)ElementType.PINNED)
{
constraints.Add(new CLRSigConstraint(CLRSigConstraint.ConstraintTypeEnum.Pinned));
parser.ConsumeByte();
}
else if (nextToken == (byte)ElementType.CMOD_OPT || nextToken == (byte)ElementType.CMOD_REQD)
{
customMods.Add(new CLRSigCustomMod(parser));
nextToken = parser.NextByte();
}
else
break;
}
outCustomMods = customMods.ToArray();
outConstraints = constraints.ToArray();
}
public CLRSigMethodDefOrRefSig(CLRSignatureParser parser, Kind allowedKind)
{
byte baseByte = parser.NextByte();
parser.ConsumeByte();
CLRSignatureParser.Token callingConvention = (CLRSignatureParser.Token)(baseByte & 0x0f);
if ((baseByte & (byte)CLRSignatureParser.Token.HASTHIS) != 0)
{
HasThis = true;
if ((baseByte & (byte)CLRSignatureParser.Token.EXPLICITTHIS) != 0)
ExplicitThis = true;
}
if ((baseByte & (int)CLRSignatureParser.Token.GENERIC) != 0)
{
if (allowedKind != Kind.Def && allowedKind != Kind.DefOrRef && allowedKind != Kind.Ref)
throw new ParseFailedException("Invalid method signature");
allowedKind = Kind.Def;
NumGenericParameters = parser.ReadCompressedUInt();
}
switch (callingConvention)
{
case CLRSignatureParser.Token.DEFAULT:
if (allowedKind != Kind.Def && allowedKind != Kind.DefOrRef && allowedKind != Kind.Ref)
throw new ParseFailedException("Invalid method signature");
allowedKind = Kind.Def;
CallingConvention = CallingConventionType.Default;
break;
case CLRSignatureParser.Token.VARARG:
CallingConvention = CallingConventionType.VarArg;
break;
case CLRSignatureParser.Token.C:
if (allowedKind != Kind.StandAlone)
throw new ParseFailedException("Invalid method signature");
CallingConvention = CallingConventionType.C;
break;
case CLRSignatureParser.Token.STDCALL:
if (allowedKind != Kind.StandAlone)
throw new ParseFailedException("Invalid method signature");
CallingConvention = CallingConventionType.StdCall;
break;
case CLRSignatureParser.Token.THISCALL:
if (allowedKind != Kind.StandAlone)
throw new ParseFailedException("Invalid method signature");
CallingConvention = CallingConventionType.ThisCall;
break;
case CLRSignatureParser.Token.FASTCALL:
if (allowedKind != Kind.StandAlone)
throw new ParseFailedException("Invalid method signature");
CallingConvention = CallingConventionType.FastCall;
break;
default:
throw new ParseFailedException("Unexpected signature token");
}
uint paramCount = parser.ReadCompressedUInt();
// Return type
RetType = new CLRSigRetType(parser);
ParamTypes = new CLRSigParamType[paramCount];
bool allowSentinel = (allowedKind == Kind.StandAlone) && (CallingConvention == CallingConventionType.C || CallingConvention == CallingConventionType.VarArg);
// Parameter types
for (uint i = 0; i < paramCount; i++)
ParamTypes[i] = new CLRSigParamType(parser, allowSentinel);
}
public CLRSigTypeFunctionPointer(ElementType type, CLRSignatureParser parser)
{
BasicType = type;
MethodDefOrRefSig = new CLRSigMethodDefOrRefSig(parser, CLRSigMethodDefOrRefSig.Kind.DefOrRef);
}