/// <summary>
///
/// </summary>
/// <param name="abc"></param>
public void Verify( AbcFile abc )
{
if ( ( !abc.VerifyNameIndex( _Key ) ) || ( !abc.VerifyNameIndex( _Value ) ) )
{
AbcVerifierException ave = new AbcVerifierException( "Invalid Key/Value pair: " + _Key.ToString( "d" ) + "/" + _Value.ToString( "d" ) );
Log.Error(this, ave );
throw ave;
}
}
/// <summary>
///
/// </summary>
/// <param name="abc"></param>
public void Verify( AbcFile abc )
{
if ( Cinit >= abc.Methods.Count )
{
AbcVerifierException ave = new AbcVerifierException( "Invalid Cinit: " + Cinit.ToString( "d" ) );
Log.Error(this, ave );
throw ave;
}
foreach ( Traits_info t in Traits )
{
t.Verify( abc );
}
}
/// <summary>
///
/// </summary>
/// <param name="abc"></param>
public void Verify(AbcFile abc)
{
if (!abc.VerifyNameIndex(_Name))
{
AbcVerifierException ave = new AbcVerifierException("Invalid Name entry " + _Name.ToString("d"));
Log.Error(this, ave);
throw ave;
}
foreach (Metadata_item_info i in _ItemInfo)
{
i.Verify(abc);
}
}
/// <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>
public void Verify( AbcFile abc )
{
for ( int i = 0; i < _Ns.Count; i++ )
{
if ( 0 == _Ns[ i ] )
{
AbcVerifierException ave = new AbcVerifierException( "Ns_set entry " + i.ToString( "d" ) + " is 0, which is not allowed" );
Log.Error(this, ave );
throw ave;
}
if ( _Ns[ i ] >= abc.ConstantPool.Namespaces.Count )
{
AbcVerifierException ave = new AbcVerifierException( "Ns_set entry " + i.ToString( "d" ) + " index outside Namespace array" );
Log.Error(this, ave );
throw ave;
}
}
}
/// <summary>
///
/// </summary>
/// <param name="abc"></param>
public void Verify( AbcFile abc )
{
try
{
if ( this.HasNsSet )
{
for ( int i = 0; i < abc.ConstantPool.NsSets[ ( int )this.NsSet ].Entries.Count; i++ )
{
int ldummy = abc.ConstantPool.Strings[ ( int )abc.ConstantPool.NsSets[ ( int )this.NsSet ].Entries[ i ] ].Length;
ldummy++;
}
}
if ( this.HasNamespace )
{
int ldummy = abc.ConstantPool.Strings[ ( int )abc.ConstantPool.Namespaces[ ( int )this.Namespace ].NameIndex ].Length;
ldummy++;
}
if ( this.HasNameIndex )
{
int ldummy = abc.ConstantPool.Strings[ ( int )this.NameIndex ].Length;
ldummy++;
}
}
catch ( Exception e )
{
AbcVerifierException ave = new AbcVerifierException( "Multiname entry has invalid indices", e );
Log.Error(this, ave );
throw ave;
}
}
/// <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)
{
try
{
object test = this.GetValue(abc);
}
catch (IndexOutOfRangeException ioor)
{
AbcVerifierException ave = new AbcVerifierException("Option_info out of range value", ioor);
Log.Error(this, ave);
throw ave;
}
}
/// <summary>
///
/// </summary>
/// <param name="abc"></param>
public void Verify(AbcFile abc)
{
if (ClassI >= abc.Classes.Count)
{
AbcVerifierException ave = new AbcVerifierException("Invalid Classi: " + ClassI.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)
{
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 (Method >= abc.Methods.Count)
{
AbcVerifierException ave = new AbcVerifierException("Invalid Method: " + Method.ToString("d"));
Log.Error(this, ave);
throw ave;
}
}
/// <summary>
///
/// </summary>
/// <param name="abc"></param>
public void Verify(AbcFile abc)
{
string name = null;
if (!Enum.IsDefined(typeof(NamespaceKind), _Kind))
{
AbcVerifierException ave = new AbcVerifierException("Namespace with invalid kind type " + _Kind.ToString("d"));
Log.Error(this, ave);
throw ave;
}
try
{
name = abc.ConstantPool.Strings[(int)_Name];
}
catch (Exception e)
{
AbcVerifierException ave = new AbcVerifierException("Namespace with invalid name index " + _Name.ToString("d"), e);
Log.Error(this, ave);
throw ave;
}
if (!IsValidNamespace(name))
{
AbcVerifierException ave = new AbcVerifierException("Namespace name is invalid: >>>" + name + "<<<");
Log.Error(this, ave);
throw ave;
}
}
/// <summary>
///
/// </summary>
/// <param name="abc"></param>
public void Verify(AbcFile abc)
{
if (Method >= abc.Methods.Count)
{
AbcVerifierException ave = new AbcVerifierException("Invalid Method: " + Method.ToString("d"));
Log.Error(this, ave);
throw ave;
}
Code.Verify(abc);
foreach (Exception_info ex in Exceptions)
{
ex.Verify(abc, Code);
}
foreach (Traits_info t in Traits)
{
t.Verify(abc);
}
}
/// <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;
}
}
}
}
