mapival.h

希望我上传的这些东西可以对搞编程的程序员有点小小的帮助！谢谢！

                         == offsetof( SRow, cValues)) \
                     && (   offsetof( ADRENTRY, rgPropVals) \
                         == offsetof( SRow, lpProps)) \
                    , "ADRLIST doesn't match SRowSet") \
         || FBadRowSet( (LPSRowSet) lpAdrList))

STDAPI_(BOOL)
FBadRglpszW( LPWSTR FAR *lppszW,
             ULONG      cStrings);

STDAPI_(BOOL)
FBadRowSet( LPSRowSet   lpRowSet);

STDAPI_(BOOL)
FBadRglpNameID( LPMAPINAMEID FAR *  lppNameId,
                ULONG               cNames);

STDAPI_(BOOL)
FBadEntryList( LPENTRYLIST  lpEntryList);


/* BAD_STANDARD_OBJ
 *
 * This macro insures that the object is a writable object of the correct size
 * and that this method belongs to the object.
 *
 * NOTES ON USE!
 *  This depends upon using the standard method of declaring the object
 *  interface.
 *
 *  prefix is the method prefix you chose when declaring the object interface.
 *  method is the standard method name of the calling method.
 *  lpVtbl is the name of the lpVtbl element of your object.
 */
#define BAD_STANDARD_OBJ( lpObj, prefix, method, lpVtbl) \
    (   IsBadWritePtr( (lpObj), sizeof(*lpObj)) \
     || IsBadReadPtr( (void *) &(lpObj->lpVtbl->method), sizeof(LPVOID)) \
     ||( ( LPVOID) (lpObj->lpVtbl->method) != (LPVOID) (prefix##method)))


#define FBadUnknown( lpObj ) \
    (   IsBadReadPtr( (lpObj), sizeof(LPVOID) ) \
     || IsBadReadPtr( (lpObj)->lpVtbl, 3 * sizeof(LPUNKNOWN) ) \
     || IsBadCodePtr( (FARPROC)(lpObj)->lpVtbl->QueryInterface ))

/*
 * IUnknown
 */


/*
 * QueryInterface
 */
#define FBadQueryInterface( lpObj, riid, ppvObj)    \
    (   IsBadReadPtr( riid, sizeof(IID)) \
     || IsBadWritePtr( ppvObj, sizeof(LPVOID)))


/*
 * AddRef
 *  No parameter validation required.
 */
#define FBadAddRef( lpObj)  FALSE


/*
 * Release
 *  No parameter validation required.
 */
#define FBadRelease( lpObj) FALSE


/*
 * GetLastError
 */
#define FBadGetLastError( lpObj, hResult, ulFlags, lppMAPIError )\
    (IsBadWritePtr( lppMAPIError, sizeof(LPMAPIERROR)))

/*
 * IMAPIProp
 */


/*
 * SaveChanges
 *  No parameter validation required.
 */
#define FBadSaveChanges( lpObj, ulFlags)    FALSE


/*
 * GetProps
 */
#define FBadGetProps( lpObj, lpPTagA, lpcValues, lppPropArray) \
    (   (   lpPTagA \
         && (   IsBadReadPtr( lpPTagA, sizeof(ULONG)) \
             || IsBadReadPtr( lpPTagA, (UINT)(  (lpPTagA->cValues + 1) \
                                              * sizeof(ULONG))))) \
     || IsBadWritePtr( lpcValues, sizeof(ULONG)) \
     || IsBadWritePtr( lppPropArray, sizeof(LPSPropValue)))


/*
 * GetPropList
 */
#define FBadGetPropList( lpObj, lppPTagA) \
    (IsBadWritePtr( lppPTagA, sizeof(LPSPropTagArray FAR *)))


/*
 * OpenProperty
 */
#define FBadOpenProperty( lpObj, ulPropTag, lpiid, ulInterfaceOptions, ulFlags \
                        , lppUnk) \
    (   IsBadReadPtr( lpiid, sizeof(IID)) \
     || IsBadWritePtr( lppUnk, sizeof (LPUNKNOWN FAR *)))


/*
 * SetProps
 */
#define FBadSetProps( lpObj, cValues, lpPropArray, lppProblems) \
    (   FBadRgPropVal( lpPropArray, (UINT) cValues) \
     || (   lppProblems \
         && IsBadWritePtr( lppProblems, sizeof(LPSPropProblemArray))))


/*
 * DeleteProps
 */
#define FBadDeleteProps( lpObj, lpPTagA, lppProblems) \
    (   (   !lpPTagA \
         || (   IsBadReadPtr( lpPTagA, sizeof(ULONG)) \
             || IsBadReadPtr( lpPTagA, (UINT)(  (lpPTagA->cValues + 1) \
                                              * sizeof(ULONG))))) \
     || (   lppProblems \
         && IsBadWritePtr( lppProblems, sizeof(LPSPropProblemArray))))


/*
 * CopyTo
 */
#define FBadCopyTo( lpIPDAT, ciidExclude, rgiidExclude, lpExcludeProps \
                  , ulUIParam, lpProgress, lpInterface, lpDestObj \
                  , ulFlags, lppProblems) \
    (   (   ciidExclude \
         && (  IsBadReadPtr( rgiidExclude, (UINT)(ciidExclude * sizeof(IID))))) \
     || (   lpExcludeProps \
         && (   IsBadReadPtr( lpExcludeProps, sizeof(ULONG)) \
             || IsBadReadPtr( lpExcludeProps \
                            , (UINT)(  (lpExcludeProps->cValues + 1) \
                                     * sizeof(ULONG))))) \
     || (lpProgress && FBadUnknown( lpProgress )) \
     || (lpInterface && IsBadReadPtr( lpInterface, sizeof(IID))) \
     || IsBadReadPtr( lpDestObj, sizeof(LPVOID)) \
     || (   lppProblems \
         && IsBadWritePtr( lppProblems, sizeof(LPSPropProblemArray))))


/*
 * CopyProps
 */
#define FBadCopyProps( lpIPDAT, lpPropTagArray \
                     , ulUIParam, lpProgress, lpInterface, lpDestObj \
                     , ulFlags, lppProblems) \
    (   (   lpPropTagArray \
         && (   IsBadReadPtr( lpPropTagArray, sizeof(ULONG)) \
             || IsBadReadPtr( lpPropTagArray \
                            , (UINT)(  (lpPropTagArray->cValues + 1) \
                                     * sizeof(ULONG))))) \
     || (lpProgress && FBadUnknown( lpProgress )) \
     || (lpInterface && IsBadReadPtr( lpInterface, sizeof(IID))) \
     || IsBadReadPtr( lpDestObj, sizeof(LPVOID)) \
     || (   lppProblems \
         && IsBadWritePtr( lppProblems, sizeof(LPSPropProblemArray))))



/*
 * GetNamesFromIDs
 */
#define FBadGetNamesFromIDs( lpIPDAT, lppPropTags, lpPropSetGuid, ulFlags, \
                             lpcPropNames, lpppPropNames) \
    (   IsBadReadPtr( lppPropTags, sizeof(LPSPropTagArray)) \
     || ( lpPropSetGuid && IsBadReadPtr( lpPropSetGuid, sizeof(GUID))) \
     || (   *lppPropTags \
         && (   IsBadReadPtr( *lppPropTags, sizeof(ULONG)) \
             || IsBadReadPtr( *lppPropTags \
                            , (UINT)( ( ( *lppPropTags)->cValues + 1) \
                                     * sizeof(ULONG))))) \
     || IsBadWritePtr( lpcPropNames, sizeof (ULONG)) \
     || IsBadWritePtr( lpppPropNames, sizeof (LPVOID FAR *)))



/*
 * GetNamesFromIDs
 */
#define FBadGetIDsFromNames( lpIPDAT, cPropNames, lppPropNames, ulFlags \
                           , lppPropTags) \
    (   (cPropNames && FBadRglpNameID( lppPropNames, cPropNames)) \
     || IsBadWritePtr( lppPropTags, sizeof(LPULONG FAR *)))


STDAPI_(ULONG)
FBadRestriction( LPSRestriction lpres );

STDAPI_(ULONG)
FBadPropTag( ULONG ulPropTag );

STDAPI_(ULONG)
FBadRow( LPSRow lprow );

STDAPI_(ULONG)
FBadProp( LPSPropValue lpprop );

STDAPI_(ULONG)
FBadSortOrderSet( LPSSortOrderSet lpsos );

STDAPI_(ULONG)
FBadColumnSet( LPSPropTagArray lpptaCols );

/* Validation function

    The eMethod parameter tells us which internal validation to perform.
    
    The ppThis parameter tells us where the stack is, so we can access the other 
    parameters.  
    
    Becuase of this *magic* we MUST obtain the pointer to the This pointer in 
    the method function.
    
*/

#ifdef WIN16
#define BASED_STACK         __based(__segname("_STACK"))
#else
#define BASED_STACK
#endif


#ifdef WIN16
HRESULT  PASCAL
#else
HRESULT  STDAPICALLTYPE     
#endif
__CPPValidateParameters(METHODS eMethod, const LPVOID ppFirst);

#ifdef WIN16
HRESULT  PASCAL
#else
HRESULT  STDAPICALLTYPE     
#endif
__ValidateParameters(METHODS eMethod, LPVOID ppThis);

#ifdef _MAC
#define STDAPIVCALLTYPE         __cdecl
#define STDAPIV                 EXTERN_C HRESULT STDAPIVCALLTYPE
#define STDAPIV_(type)          EXTERN_C type STDAPIVCALLTYPE
#endif /* _MAC */

/* Macro wrappers for platform independent validation */

#if defined(_X86_) || defined( WIN16 )
#define ValidateParms(x)    { HRESULT _hr_ = HrValidateParameters x; if (HR_FAILED(_hr_)) return (_hr_); }
#define UlValidateParms(x)  { HRESULT _hr_ = HrValidateParameters x; if (HR_FAILED(_hr_)) return (ULONG)(_hr_); }
#define CheckParms(x)       AssertSz(HR_SUCCEEDED( HrValidateParameters x), "Parameter validation failed for method called by MAPI!")