| public VerifyMultinameIndex ( uint index ) : bool | ||
| index | uint | |
| return | bool | |
/// <summary>
///
/// </summary>
/// <param name="abc"></param>
public void Verify( AbcFile abc )
{
//
// _Name must be a multiname of type QName
// _Supername must be a multiname
// _ProtectedNs if _FlagClassProtectedNs must point to namespace
// _Interface is multiname index
// _Iinit is index into method array
//
if ( !abc.VerifyMultinameIndex( _Name ) )
{
AbcVerifierException ave = new AbcVerifierException( "Invalid Name: " + _Name.ToString( "d" ) );
Log.Error(this, ave );
throw ave;
}
if ( abc.ConstantPool.Multinames[ (int)_Name ].Type != MultinameType.QName )
{
AbcVerifierException ave = new AbcVerifierException( "Name: " + _Name.ToString( "d" ) + " is not of type QName" );
Log.Error(this, ave );
throw ave;
}
if ( _FlagClassProtectedNs )
{
if ( !abc.VerifyMultinameIndex( _ProtectedNs ) )
{
AbcVerifierException ave = new AbcVerifierException( "Invalid ProtectedNs: " + _ProtectedNs.ToString( "d" ) );
Log.Error(this, ave );
throw ave;
}
}
if ( !abc.VerifyMultinameIndex( _Supername ) )
{
AbcVerifierException ave = new AbcVerifierException( "Invalid SuperName: " + _Supername.ToString( "d" ) );
Log.Error(this, ave );
throw ave;
}
for ( int i = 0; i < _Interface.Count; i++ )
{
if ( !abc.VerifyMultinameIndex( _Interface[i] ) )
{
AbcVerifierException ave = new AbcVerifierException( "Invalid interface: " + _Interface[i].ToString( "d" ) );
Log.Error(this, ave );
throw ave;
}
if ( 0 == _Interface[ i ] )
{
AbcVerifierException ave = new AbcVerifierException( "Invalid interface, being 0" );
Log.Error(this, ave );
throw ave;
}
}
if ( _Iinit >= abc.Methods.Count )
{
AbcVerifierException ave = new AbcVerifierException( "Iinit does not point into method array: " + _Iinit.ToString( "d" ) );
Log.Error(this, ave );
throw ave;
}
foreach ( Traits_info ti in _Trait )
{
ti.Verify( abc );
}
}
/// <summary>
///
/// </summary>
/// <param name="abc"></param>
/// <param name="code"></param>
public void Verify(AbcFile abc, AVM2Code code)
{
if (!abc.VerifyMultinameIndex(_ExceptionType))
{
AbcVerifierException ave = new AbcVerifierException("Invalid Exception type: " + _ExceptionType.ToString("d"));
Log.Error(this, ave);
throw ave;
}
if (!abc.VerifyMultinameIndex(_VariableName))
{
AbcVerifierException ave = new AbcVerifierException("Invalid exception variable name: " + _VariableName.ToString("d")); ;
Log.Error(this, ave);
throw ave;
}
try
{
uint dummy = code.Address2Index(_From) + code.Address2Index(_To) + code.Address2Index(_Target);
dummy++;
}
catch (ArgumentOutOfRangeException aoor)
{
AbcVerifierException ave = new AbcVerifierException("Exception to/from/target not on a instruction", aoor);
Log.Error(this, ave);
throw ave;
}
}
/// <summary>
///
/// </summary>
/// <param name="abc"></param>
public void Verify(AbcFile abc)
{
if (!abc.VerifyMultinameIndex(TypeName))
{
AbcVerifierException ave = new AbcVerifierException("Invalid TypeName: " + TypeName.ToString("d"));
Log.Error(this, ave);
throw ave;
}
if (0 == Vindex)
{
return;
}
else
{
if ((!Enum.IsDefined(typeof(OptionType), Vkind)) || (Vkind == OptionType.TotallyInvalid))
{
AbcVerifierException ave = new AbcVerifierException("Invalid Vkind: " + Vkind.ToString("d"));
Log.Error(this, ave);
throw ave;
}
bool valid = false;
switch (Vkind)
{
case OptionType.Option_Int:
valid = (Vindex < abc.ConstantPool.Integers.Count);
break;
case OptionType.Option_UInt:
valid = (Vindex < abc.ConstantPool.UIntegers.Count);
break;
case OptionType.Option_Double:
valid = (Vindex < abc.ConstantPool.Doubles.Count);
break;
case OptionType.Option_Utf8:
valid = (Vindex < abc.ConstantPool.Strings.Count);
break;
case OptionType.Option_True:
case OptionType.Option_False:
case OptionType.Option_Null:
case OptionType.Option_Undefined:
valid = true;
break;
case OptionType.Option_Namespace:
case OptionType.Option_PackageNamespace:
case OptionType.Option_PackageInternalNs:
case OptionType.Option_ProtectedNamespace:
case OptionType.Option_ExplicitNamespace:
case OptionType.Option_StaticProtectedNs:
case OptionType.Option_PrivateNs:
valid = (Vindex < abc.ConstantPool.Namespaces.Count);
break;
default:
valid = false;
break;
}
if (!valid)
{
AbcVerifierException ave = new AbcVerifierException("Invalid Vindex " + Vindex.ToString("d") + " for vkind " + Vkind.ToString("d"));
Log.Error(this, ave);
throw ave;
}
}
}
/// <summary>
///
/// </summary>
/// <param name="abc"></param>
public void Verify(AbcFile abc)
{
if (!abc.VerifyMultinameIndex(Name))
{
AbcVerifierException ave = new AbcVerifierException("Invalid name: " + Name.ToString("d"));
Log.Error(this, ave);
throw ave;
}
if (abc.ConstantPool.Multinames[(int)Name].Type != MultinameType.QName)
{
AbcVerifierException ave = new AbcVerifierException("Invalid name type");
Log.Error(this, ave);
throw ave;
}
if (AttribMetadata)
{
foreach (UInt32 ind in _Metadata)
{
if (ind >= abc.Metadata.Count)
{
AbcVerifierException ave = new AbcVerifierException("Invalid metadata index: " + ind.ToString("d"));
Log.Error(this, ave);
throw ave;
}
}
}
switch (Type)
{
case TraitType.Trait_Const:
case TraitType.Trait_Slot:
_Data_Slot.Verify(abc);
break;
case TraitType.Trait_Class:
_Data_Class.Verify(abc);
break;
case TraitType.Trait_Function:
_Data_Function.Verify(abc);
break;
case TraitType.Trait_Method:
case TraitType.Trait_Getter:
case TraitType.Trait_Setter:
_Data_Method.Verify(abc);
break;
}
}
/// <summary>
///
/// </summary>
/// <param name="abc"></param>
public void Verify(AbcFile abc)
{
for (int i = 0; i < ParamType.Count; i++)
{
if (!abc.VerifyMultinameIndex(ParamType[i]))
{
AbcVerifierException ave = new AbcVerifierException("Invalid param type in method_info: " + ParamType[i].ToString("d"));
Log.Error(this, ave);
throw ave;
}
}
if (!abc.VerifyNameIndex(Name))
{
AbcVerifierException ave = new AbcVerifierException("Invalid method name : " + Name.ToString("d"));
Log.Error(this, ave);
throw ave;
}
if (!abc.VerifyMultinameIndex(ReturnType))
{
AbcVerifierException ave = new AbcVerifierException("Invalid return type: " + ReturnType.ToString("d"));
Log.Error(this, ave);
throw ave;
}
if (FlagHasOptional)
{
for (int i = 0; i < Option.Count; i++)
{
Option[i].Verify(abc);
}
}
if (FlagHasParamNames)
{
for (int i = 0; i < ParamNames.Count; i++)
{
if (!abc.VerifyNameIndex(ParamNames[i]))
{
AbcVerifierException ave = new AbcVerifierException("Invalid param name: " + ParamNames[i].ToString("d"));
Log.Error(this, ave);
throw ave;
}
}
}
}
