sigparser.cpp

// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
//
// sigparser.cpp
//

//
// Signature parsing code
//
#include"stdafx.h"
#include"sigparser.h"
#include"contract.h"

HRESULT SigParser::SkipExactlyOne()
{
 CONTRACTL
 {
 INSTANCE_CHECK;
 NOTHROW;
 GC_NOTRIGGER;
 FORBID_FAULT;
 SUPPORTS_DAC;
 }
 CONTRACTL_END

 CorElementType typ;
 HRESULT hr = GetElemType(&typ);

IfFailRet(hr);

if (!CorIsPrimitiveType(typ))
 {
switch ((DWORD)typ)
 {
default:
// _ASSERT(!"Illegal or unimplement type in COM+ sig.");
return META_E_BAD_SIGNATURE;
break;
case ELEMENT_TYPE_VAR:
case ELEMENT_TYPE_MVAR:
IfFailRet(GetData(NULL)); // Skip variable number
break;
case ELEMENT_TYPE_VAR_ZAPSIG:
IfFailRet(GetData(NULL)); // Skip RID
break;
case ELEMENT_TYPE_OBJECT:
case ELEMENT_TYPE_STRING:
case ELEMENT_TYPE_TYPEDBYREF:
case ELEMENT_TYPE_CANON_ZAPSIG:
break;

case ELEMENT_TYPE_BYREF: //fallthru
case ELEMENT_TYPE_PTR:
case ELEMENT_TYPE_PINNED:
case ELEMENT_TYPE_SZARRAY:
case ELEMENT_TYPE_NATIVE_ARRAY_TEMPLATE_ZAPSIG:
case ELEMENT_TYPE_NATIVE_VALUETYPE_ZAPSIG:
IfFailRet(SkipExactlyOne()); // Skip referenced type
break;

case ELEMENT_TYPE_VALUETYPE: //fallthru
case ELEMENT_TYPE_CLASS:
IfFailRet(GetToken(NULL)); // Skip RID
break;

case ELEMENT_TYPE_MODULE_ZAPSIG:
IfFailRet(GetData(NULL)); // Skip index
IfFailRet(SkipExactlyOne()); // Skip type
break;

case ELEMENT_TYPE_FNPTR:
IfFailRet(SkipSignature());
break;

case ELEMENT_TYPE_ARRAY:
 {
IfFailRet(SkipExactlyOne()); // Skip element type
 ULONG rank;
IfFailRet(GetData(&rank)); // Get rank
if (rank)
 {
 ULONG nsizes;
IfFailRet(GetData(&nsizes)); // Get # of sizes
while (nsizes--)
 {
IfFailRet(GetData(NULL)); // Skip size
 }

 ULONG nlbounds;
IfFailRet(GetData(&nlbounds)); // Get # of lower bounds
while (nlbounds--)
 {
IfFailRet(GetData(NULL)); // Skip lower bounds
 }
 }

 }
break;

case ELEMENT_TYPE_SENTINEL:
// Should be unreachable since GetElem strips it
break;

case ELEMENT_TYPE_INTERNAL:
IfFailRet(GetPointer(NULL));
break;

case ELEMENT_TYPE_GENERICINST:
IfFailRet(SkipExactlyOne()); // Skip generic type
 ULONG argCnt;
IfFailRet(GetData(&argCnt)); // Get number of parameters
while (argCnt--)
 {
IfFailRet(SkipExactlyOne()); // Skip the parameters
 }
break;

 }
 }

return hr;
}

//---------------------------------------------------------------------------------------
//
// Skip only a method header signature - not the sigs of the args to the method.
//
HRESULT
SigParser::SkipMethodHeaderSignature(
 ULONG * pcArgs)
{
 CONTRACTL
 {
 INSTANCE_CHECK;
 NOTHROW;
 GC_NOTRIGGER;
 FORBID_FAULT;
 SUPPORTS_DAC;
 }
 CONTRACTL_END

 HRESULT hr = S_OK;

// Skip calling convention
 ULONG uCallConv;
IfFailRet(GetCallingConvInfo(&uCallConv));

if ((uCallConv == IMAGE_CEE_CS_CALLCONV_FIELD) ||
 (uCallConv == IMAGE_CEE_CS_CALLCONV_LOCAL_SIG))
 {
return META_E_BAD_SIGNATURE;
 }

// Skip type parameter count
if (uCallConv & IMAGE_CEE_CS_CALLCONV_GENERIC)
IfFailRet(GetData(NULL));

// Get arg count;
IfFailRet(GetData(pcArgs));

// Skip return type;
IfFailRet(SkipExactlyOne());

return hr;
} // SigParser::SkipMethodHeaderSignature

//---------------------------------------------------------------------------------------
//
// Skip a sub signature (as immediately follows an ELEMENT_TYPE_FNPTR).
HRESULT SigParser::SkipSignature()
{
 CONTRACTL
 {
 INSTANCE_CHECK;
 NOTHROW;
 GC_NOTRIGGER;
 FORBID_FAULT;
 SUPPORTS_DAC;
 }
 CONTRACTL_END

 HRESULT hr = S_OK;

 ULONG cArgs;

IfFailRet(SkipMethodHeaderSignature(&cArgs));

// Skip args.
while (cArgs) {
IfFailRet(SkipExactlyOne());
 cArgs--;
 }

return hr;
}