637 lines
17 KiB
C
637 lines
17 KiB
C
/*============================================================================
|
|
*
|
|
* _ITABLE.H
|
|
*
|
|
* Internal header file for MAPI 1.0 In-memory MAPI Table DLL
|
|
*
|
|
* Copyright (C) 1993 and 1994 Microsoft Corporation
|
|
*
|
|
*
|
|
* Hungarian shorthand:
|
|
* To avoid excessively long identifier names, the following
|
|
* shorthand expressions are used:
|
|
*
|
|
* LPSPropTagArray lppta
|
|
* LPSRestriction lpres
|
|
* LPSPropValue lpprop
|
|
* LPSRow lprow
|
|
* LPSRowSet lprows
|
|
* LPSSortOrder lpso
|
|
* LPSSortOrderSet lpsos
|
|
*/
|
|
|
|
// $MAC - Fix up some naming conflicts
|
|
|
|
#ifdef MAC
|
|
#define FFindColumn ITABLE_FFindColumn
|
|
#endif
|
|
|
|
typedef struct _TAD FAR * LPTAD;
|
|
typedef struct _VUE FAR * LPVUE;
|
|
|
|
// Global Constants
|
|
#define ROW_CHUNK_SIZE 50
|
|
#define COLUMN_CHUNK_SIZE 15
|
|
|
|
// Max number of notifications to send in a batch
|
|
//
|
|
// Raid: Horsefly/Exchange/36281
|
|
// This was changed from 8 to 1 because code in itable.c which fills in
|
|
// the batch cannot guarantee the correct order of the notifications in
|
|
// it. If this is ever changed, that bug will have to be revisited.
|
|
//
|
|
#define MAX_BATCHED_NOTIFS 1
|
|
|
|
// For use in aligning data in buffers
|
|
#if defined (_AMD64_) || defined (_IA64_)
|
|
#define ALIGNTYPE LARGE_INTEGER
|
|
#else
|
|
#define ALIGNTYPE DWORD
|
|
#endif
|
|
#define ALIGN ((ULONG) (sizeof(ALIGNTYPE) - 1))
|
|
#define LcbAlignLcb(lcb) (((lcb) + ALIGN) & ~ALIGN)
|
|
#define PbAlignPb(pb) ((LPBYTE) ((((DWORD) (pb)) + ALIGN) & ~ALIGN))
|
|
|
|
// This structure is used to keep track of a private memory buffer which is
|
|
// used with the private AllocateMore function ScBufAllocateMore(). This
|
|
// allows for one MAPI memory allocation when the size of a property is known
|
|
// and the author wishes to use PropCopyMore. See ITABLE.C ScCopyTadRow()
|
|
// for an example.
|
|
typedef struct _CMB
|
|
{
|
|
ULONG ulcb;
|
|
LPVOID lpv;
|
|
} CMB, * LPCMB;
|
|
|
|
|
|
#if !defined(NO_VALIDATION)
|
|
|
|
#define VALIDATE_OBJ(lpobj,objtype,fn,lpVtbl) \
|
|
if ( BAD_STANDARD_OBJ(lpobj,objtype,fn,lpVtbl)) \
|
|
{ \
|
|
DebugTrace( TEXT("%s::%s() - Invalid parameter passed as %s object\n"), \
|
|
#objtype, \
|
|
#fn, \
|
|
#objtype ); \
|
|
return ResultFromScode( MAPI_E_INVALID_PARAMETER ); \
|
|
}
|
|
|
|
#endif
|
|
|
|
#ifndef BEGIN_INTERFACE
|
|
#define BEGIN_INTERFACE
|
|
#endif
|
|
|
|
// $MAC - Supprt for WLM 4.0
|
|
#ifndef VTABLE_FILL
|
|
#define VTABLE_FILL
|
|
#endif
|
|
|
|
|
|
|
|
#define HrSetLastErrorIds(lpobj,sc,ids) \
|
|
UNKOBJ_HrSetLastError((LPUNKOBJ)(lpobj), \
|
|
(sc), \
|
|
(ids))
|
|
|
|
|
|
|
|
#ifdef WIN32
|
|
#define LockObj(lpobj) UNKOBJ_Lock((LPUNKOBJ)(lpobj))
|
|
__inline VOID
|
|
UNKOBJ_Lock( LPUNKOBJ lpunkobj )
|
|
{
|
|
EnterCriticalSection(&lpunkobj->csid);
|
|
}
|
|
|
|
#define UnlockObj(lpobj) UNKOBJ_Unlock((LPUNKOBJ)(lpobj))
|
|
__inline VOID
|
|
UNKOBJ_Unlock( LPUNKOBJ lpunkobj )
|
|
{
|
|
LeaveCriticalSection(&lpunkobj->csid);
|
|
}
|
|
#else
|
|
#define LockObj(lpobj)
|
|
#define UnlockObj(lpobj)
|
|
#endif
|
|
|
|
|
|
// Memory Management Macros for code readability
|
|
|
|
#define ScAllocateBuffer(lpobj,ulcb,lppv) \
|
|
UNKOBJ_ScAllocate((LPUNKOBJ)(lpobj), \
|
|
(ulcb), \
|
|
(LPVOID FAR *)(lppv))
|
|
|
|
|
|
#define ScAllocateMore(lpobj,ulcb,lpv,lppv) \
|
|
UNKOBJ_ScAllocateMore((LPUNKOBJ)(lpobj), \
|
|
(ulcb), \
|
|
(lpv), \
|
|
(LPVOID FAR *)(lppv))
|
|
|
|
#define ScFreeBuffer(lpobj,lpv) \
|
|
UNKOBJ_Free((LPUNKOBJ)(lpobj), (lpv))
|
|
|
|
#define ScCOAllocate(lpunkobj,ulcb,lplpv) \
|
|
UNKOBJ_ScCOAllocate((LPUNKOBJ)(lpunkobj),(ulcb),(lplpv))
|
|
|
|
|
|
#define ScCOReallocate(lpunkobj,ulcb,lplpv) \
|
|
UNKOBJ_ScCOReallocate((LPUNKOBJ)(lpunkobj),(ulcb),(lplpv))
|
|
|
|
|
|
#define COFree(lpunkobj,lpv) \
|
|
UNKOBJ_COFree((LPUNKOBJ)(lpunkobj),(lpv))
|
|
|
|
|
|
#define MAPIFreeRows(lpobj,lprows) \
|
|
UNKOBJ_FreeRows((LPUNKOBJ)(lpobj),(lprows))
|
|
|
|
|
|
|
|
|
|
/*============================================================================
|
|
* TAD (table data class)
|
|
*
|
|
* Implementes in-memory table data object.
|
|
*/
|
|
|
|
#undef INTERFACE
|
|
#define INTERFACE struct _TAD
|
|
#undef MAPIMETHOD_
|
|
#define MAPIMETHOD_(type,method) MAPIMETHOD_DECLARE(type,method,TAD_)
|
|
MAPI_IUNKNOWN_METHODS(IMPL)
|
|
MAPI_ITABLEDATA_METHODS(IMPL)
|
|
#undef MAPIMETHOD_
|
|
#define MAPIMETHOD_(type,method) MAPIMETHOD_TYPEDEF(type,method,TAD_)
|
|
MAPI_IUNKNOWN_METHODS(IMPL)
|
|
MAPI_ITABLEDATA_METHODS(IMPL)
|
|
#undef MAPIMETHOD_
|
|
#define MAPIMETHOD_(type,method) STDMETHOD_(type,method)
|
|
|
|
DECLARE_MAPI_INTERFACE(TAD_)
|
|
{
|
|
BEGIN_INTERFACE
|
|
MAPI_IUNKNOWN_METHODS(IMPL)
|
|
MAPI_ITABLEDATA_METHODS(IMPL)
|
|
};
|
|
|
|
typedef struct _TAD
|
|
{
|
|
TAD_Vtbl FAR * lpVtbl;
|
|
UNKOBJ_MEMBERS;
|
|
|
|
UNKINST inst;
|
|
|
|
LPVUE lpvueList;
|
|
|
|
ULONG ulTableType;
|
|
ULONG ulPropTagIndexCol;
|
|
|
|
ULONG ulcColsMac;
|
|
LPSPropTagArray lpptaCols; // Initial view col set (CO)
|
|
|
|
ULONG ulcRowsAdd;
|
|
ULONG ulcRowMacAdd;
|
|
LPSRow * parglprowAdd; // Unsorted Row Set (CO)
|
|
|
|
ULONG ulcRowsIndex;
|
|
ULONG ulcRowMacIndex;
|
|
LPSRow * parglprowIndex; // Row Set Sorted by Index (CO)
|
|
|
|
LPVOID lpvDataSource; // used to store container specific data
|
|
ULONG cbDataSource; // bytes in lpvDataSource to copy to new allocation.
|
|
// If non-zero, CreateView should LocalAlloc this size
|
|
// and copy data from lpvDataSource into it. Release
|
|
// should LocalFree.
|
|
|
|
// With multiple containers, it becomes necessary to figure
|
|
// out which container the table represents. We cache the containers
|
|
// EID in the table for easy access. This is a pointer .. no need to free
|
|
LPSBinary pbinContEID;
|
|
|
|
// When calling get ContentsTable, we may sometimes want a list of
|
|
// contents from ALL the folders/containers for a particular profile and
|
|
// return those contents as a single contentstable. Following flag caches
|
|
// this setting so we collate contents of all folders. Works only if the
|
|
// container being opened was the PAB container and if bProfilesAPIEnabled
|
|
// (ie profiles were invoked explicitly)
|
|
BOOL bAllProfileContents;
|
|
|
|
// For PAB containers where profilesAPIEnabled=FALSE, GetContentsTable
|
|
// typically means return contents of ALL the WAB since user hasn;t asked for
|
|
// profiles. In this case we may want to have the option of opening only
|
|
// a particular folder and getting only the conetnts of that folder .. so we
|
|
// need a flag to cache this inverse option.
|
|
BOOL bContainerContentsOnly;
|
|
|
|
// When calling GetContentsTable, the caller can specify MAPI_UNICODE
|
|
// for unicode tables.. we cache that flag in case we need to refill the table
|
|
// at some later point ..
|
|
BOOL bMAPIUnicodeTable;
|
|
} TAD;
|
|
|
|
SCODE
|
|
ScCopyTadRowSet(
|
|
LPTAD lptad,
|
|
LPSRowSet lprowsetIn,
|
|
ULONG * pcNewTags,
|
|
ULONG * pcRows,
|
|
LPSRow * * pparglprowUnsortedCopy,
|
|
LPSRow * * pparglprowSortedCopy );
|
|
|
|
SCODE
|
|
ScCopyTadRow( LPTAD lptad,
|
|
LPSRow lprow,
|
|
ULONG * pTagsAdded,
|
|
LPSRow FAR * lplprowCopy );
|
|
|
|
VOID
|
|
UpdateViews( LPTAD lptad,
|
|
ULONG cRowsToRemove,
|
|
LPSRow * parglprowToRemove,
|
|
ULONG cRowsToAdd,
|
|
LPSRow * parglprowToAddUnsorted,
|
|
LPSRow * parglprowToAddSorted );
|
|
|
|
VOID
|
|
FixupView(
|
|
LPVUE lpvue,
|
|
ULONG cRowsToRemove,
|
|
LPSRow * parglprowToRemove,
|
|
ULONG cRowsToAdd,
|
|
LPSRow * parglprowToAddUnsorted,
|
|
LPSRow * parglprowToAddSorted );
|
|
|
|
SCODE
|
|
ScReplaceRows(
|
|
LPTAD lptad,
|
|
ULONG cRowsNew,
|
|
LPSRow * parglprowNew,
|
|
ULONG * pcRowsOld,
|
|
LPSRow * * pparglprowOld );
|
|
|
|
SCODE
|
|
ScFindRow( LPTAD lptad,
|
|
LPSPropValue lpprop,
|
|
LPSRow * * pplprow );
|
|
SCODE
|
|
ScAddRow( LPUNKOBJ lpunkobj,
|
|
LPSSortOrderSet lpsos,
|
|
LPSRow lprow,
|
|
ULONG uliRow,
|
|
ULONG * pulcRows,
|
|
ULONG * pulcRowsMac,
|
|
LPSRow ** pparglprows,
|
|
LPSRow ** pplprow );
|
|
|
|
|
|
|
|
|
|
|
|
/*============================================================================
|
|
* VUE (table view class)
|
|
*/
|
|
|
|
#undef INTERFACE
|
|
#define INTERFACE struct _VUE
|
|
#undef MAPIMETHOD_
|
|
#define MAPIMETHOD_(type,method) MAPIMETHOD_DECLARE(type,method,VUE_)
|
|
MAPI_IUNKNOWN_METHODS(IMPL)
|
|
MAPI_IMAPITABLE_METHODS(IMPL)
|
|
#undef MAPIMETHOD_
|
|
#define MAPIMETHOD_(type,method) MAPIMETHOD_TYPEDEF(type,method,VUE_)
|
|
MAPI_IUNKNOWN_METHODS(IMPL)
|
|
MAPI_IMAPITABLE_METHODS(IMPL)
|
|
#undef MAPIMETHOD_
|
|
#define MAPIMETHOD_(type,method) STDMETHOD_(type,method)
|
|
|
|
DECLARE_MAPI_INTERFACE(VUE_)
|
|
{
|
|
BEGIN_INTERFACE
|
|
MAPI_IUNKNOWN_METHODS(IMPL)
|
|
MAPI_IMAPITABLE_METHODS(IMPL)
|
|
};
|
|
|
|
/* BOOKMARK status
|
|
*
|
|
* dwfBKSFree is used for a bookmark that is NOT valid and
|
|
* is available for use
|
|
* dwfBKSValid is set for any used bookmark.
|
|
* dwfChanged is used with dwfBKSValid to indicate that the marked row
|
|
* has moved since the last query which in involved this
|
|
* bookmark
|
|
* dwfBKSMoving is used with dwfBKSValid to indicate that the marked row is
|
|
* in the process of being moved relative to other rows.
|
|
* dwfBKSStale is used with dwfBKSValid to indicate the given bookmark
|
|
* no longer marks a row but has not been Freed
|
|
* dwfBKSMask is the set of all valid bookmark status
|
|
*
|
|
*/
|
|
#define dwfBKSFree ((DWORD) 0x00000000)
|
|
#define dwfBKSValid ((DWORD) 0x00000001)
|
|
#define dwfBKSChanged ((DWORD) 0x00000002)
|
|
#define dwfBKSMoving ((DWORD) 0x00000004)
|
|
#define dwfBKSStale ((DWORD) 0x00000008)
|
|
#define dwfBKSMask (~(dwfBKSValid|dwfBKSChanged|dwfBKSMoving|dwfBKSStale))
|
|
|
|
#define FBadBookmark(lpvue,bk) \
|
|
((bk) >= cBookmarksMax || \
|
|
((lpvue)->rgbk[(bk)].dwfBKS == dwfBKSFree) || \
|
|
((lpvue)->rgbk[(bk)].dwfBKS & dwfBKSMask)) \
|
|
|
|
typedef struct
|
|
{
|
|
DWORD dwfBKS; // Bookmark status
|
|
union
|
|
{
|
|
ULONG uliRow; // dwfBKSValid || dwfBKSChanged
|
|
LPSRow lprow; // dwfBKSMoving
|
|
};
|
|
} BK, * PBK;
|
|
|
|
|
|
// There is a maximum of 42 client defined bookmarks for each VUE. This
|
|
// seems adequate for an in-memory table.
|
|
// Bookmarks are kept as an array of 45 where the first three are
|
|
// the MAPI predefined bookmarks.
|
|
|
|
#define cBookmarksMax 45 // Max. # of bookmarks including reserved ones
|
|
#define cBookmarksReserved 3 // # of reserved bookmarks (begin, cur, end)
|
|
|
|
#define BOOKMARK_MEMBERS \
|
|
struct \
|
|
{ \
|
|
union \
|
|
{ \
|
|
struct \
|
|
{ \
|
|
BK bkBeginning; \
|
|
BK bkCurrent; \
|
|
BK bkEnd; \
|
|
}; \
|
|
BK rgbk[cBookmarksMax]; \
|
|
}; \
|
|
} \
|
|
|
|
typedef BOOKMARK_MEMBERS UBK, * PUBK;
|
|
|
|
typedef struct _VUE
|
|
{
|
|
VUE_Vtbl FAR * lpVtbl;
|
|
UNKOBJ_MEMBERS;
|
|
|
|
LPVUE lpvueNext;
|
|
LPTAD lptadParent;
|
|
|
|
LPSPropTagArray lpptaCols; // Column set (MAPI)
|
|
LPSRestriction lpres; // Restriction (MAPI)
|
|
LPSSortOrderSet lpsos; // Sort order set (MAPI)
|
|
|
|
CALLERRELEASE FAR * lpfReleaseCallback;
|
|
ULONG ulReleaseData;
|
|
|
|
ULONG ulcRowMac; // Space available for rows
|
|
LPSRow * parglprows; // Sorted Row Set
|
|
|
|
BOOKMARK_MEMBERS;
|
|
|
|
LPADVISELIST lpAdviseList;
|
|
ULONG ulcAdvise;
|
|
MAPIUID mapiuidNotif;
|
|
|
|
LPVOID lpvDataSource; // used to store container specific data
|
|
ULONG cbDataSource; // bytes in lpvDataSource to copy to new allocation.
|
|
// If non-zero, CreateView should LocalAlloc this size
|
|
// and copy data from lpvDataSource into it. Release
|
|
// should LocalFree.
|
|
|
|
BOOL bMAPIUnicodeTable; //tracks whether parent table needs UNICODE data or not
|
|
|
|
} VUE;
|
|
|
|
typedef struct _VUENOTIFKEY
|
|
{
|
|
ULONG ulcb;
|
|
MAPIUID mapiuid;
|
|
|
|
} VUENOTIFKEY;
|
|
|
|
BOOL
|
|
FBookMarkStale( LPVUE lpvue,
|
|
BOOKMARK bk);
|
|
|
|
SCODE
|
|
ScLoadRows( ULONG ulcRowsSrc,
|
|
LPSRow * rglprowsSrc,
|
|
LPVUE lpvue,
|
|
LPSRestriction lpres,
|
|
LPSSortOrderSet lpsos );
|
|
|
|
SCODE
|
|
ScDeleteAllRows( LPTAD lptad);
|
|
|
|
SCODE
|
|
ScMaybeAddRow( LPVUE lpvue,
|
|
LPSRestriction lpres,
|
|
LPSSortOrderSet lpsos,
|
|
LPSRow lprow,
|
|
ULONG uliRow,
|
|
ULONG * pulcRows,
|
|
ULONG * pulcRowMac,
|
|
LPSRow ** pparglprows,
|
|
LPSRow ** pplprow );
|
|
|
|
SCODE
|
|
ScCopyVueRow( LPVUE lpvue,
|
|
LPSPropTagArray lpptaCols,
|
|
LPSRow lprowSrc,
|
|
LPSRow lprowDst );
|
|
|
|
|
|
|
|
|
|
/*============================================================================
|
|
* Utilities
|
|
*/
|
|
|
|
SCODE
|
|
ScDupRestriction( LPUNKOBJ lpunkobj,
|
|
LPSRestriction lpres,
|
|
LPSRestriction FAR * lplpresCopy );
|
|
|
|
SCODE
|
|
ScDupRestrictionMore( LPUNKOBJ lpunkobj,
|
|
LPSRestriction lpresSrc,
|
|
LPVOID lpvLink,
|
|
LPSRestriction lpresDst );
|
|
|
|
SCODE
|
|
ScSatisfiesRestriction( LPSRow lprow,
|
|
LPSRestriction lpres,
|
|
ULONG * pfSatisfies );
|
|
SCODE
|
|
ScDupRgbEx( LPUNKOBJ lpunkobj,
|
|
ULONG ulcb,
|
|
LPBYTE lpb,
|
|
ULONG ulcbExtra,
|
|
LPBYTE FAR * lplpbCopy );
|
|
|
|
LPSRow *
|
|
PlprowCollateRow( ULONG ulcRows,
|
|
LPSRow * rglprows,
|
|
LPSSortOrderSet lpsos,
|
|
BOOL fAfterExisting,
|
|
LPSRow lprow );
|
|
|
|
LPSRow *
|
|
PlprowByLprow( ULONG ulcRows,
|
|
LPSRow * rglprows,
|
|
LPSRow lprow );
|
|
|
|
LPSPropValue __fastcall
|
|
LpSPropValueFindColumn( LPSRow lprow,
|
|
ULONG ulPropTagColumn );
|
|
|
|
STDMETHODIMP_(SCODE)
|
|
ScBufAllocateMore( ULONG ulcb,
|
|
LPCMB lpcmb,
|
|
LPVOID FAR * lplpv );
|
|
|
|
ULONG
|
|
UlcbPropToCopy( LPSPropValue lpprop );
|
|
|
|
|
|
|
|
#ifndef WIN16 // WIN16 C (not C++) doesn't support INLINE functions.
|
|
// Functions are defined in ITABLE.C.
|
|
/*============================================================================
|
|
- FFindColumn()
|
|
-
|
|
* Checks a prop tag array to see if a given prop tag exists.
|
|
*
|
|
* NOTE! The prop tag must match completely (even type).
|
|
*
|
|
*
|
|
* Parameters:
|
|
* lpptaCols in Prop tag array to check
|
|
* ulPropTag in Prop tag to check for.
|
|
*
|
|
* Returns:
|
|
* TRUE if ulPropTag is in lpptaCols
|
|
* FALSE if ulPropTag is not in lpptaCols
|
|
*/
|
|
|
|
__inline BOOL
|
|
FFindColumn( LPSPropTagArray lpptaCols,
|
|
ULONG ulPropTag )
|
|
{
|
|
UNALIGNED ULONG * pulPropTag;
|
|
|
|
|
|
pulPropTag = lpptaCols->aulPropTag + lpptaCols->cValues;
|
|
while ( --pulPropTag >= lpptaCols->aulPropTag )
|
|
if ( *pulPropTag == ulPropTag )
|
|
return TRUE;
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
|
|
/*============================================================================
|
|
- ScFindRow()
|
|
-
|
|
* Finds the first row in the table data whose index column property
|
|
* value is equal to that of the specified property and returns the
|
|
* location of that row in the table data, or, if no such row exists,
|
|
* the end of the table data.
|
|
*
|
|
* Parameters:
|
|
* lptad in TAD in which to find row
|
|
* lpprop in Index property to match
|
|
* puliRow out Pointer to location of found row
|
|
*
|
|
* Error returns:
|
|
* MAPI_E_INVALID_PARAMETER If proptag of property isn't the TAD's
|
|
* index column's proptag.
|
|
* MAPI_E_NOT_FOUND If no matching row is found (*pplprow
|
|
* is set to lptad->parglprows +
|
|
* lptad->cRows in this case).
|
|
*/
|
|
|
|
__inline SCODE
|
|
ScFindRow(
|
|
LPTAD lptad,
|
|
LPSPropValue lpprop,
|
|
LPSRow * * pplprow)
|
|
{
|
|
SCODE sc = S_OK;
|
|
SRow row = {0, 1, lpprop};
|
|
SizedSSortOrderSet(1, sosIndex) = { 1, 0, 0 };
|
|
|
|
if (lpprop->ulPropTag != lptad->ulPropTagIndexCol)
|
|
{
|
|
sc = MAPI_E_INVALID_PARAMETER;
|
|
goto ret;
|
|
}
|
|
|
|
Assert(!IsBadWritePtr(pplprow, sizeof(*pplprow)));
|
|
|
|
// Build a sort order set for the Index Column
|
|
sosIndex.aSort[0].ulPropTag = lptad->ulPropTagIndexCol;
|
|
sosIndex.aSort[0].ulOrder = TABLE_SORT_ASCEND;
|
|
|
|
*pplprow = PlprowCollateRow(lptad->ulcRowsIndex,
|
|
lptad->parglprowIndex,
|
|
(LPSSortOrderSet) &sosIndex,
|
|
FALSE,
|
|
&row);
|
|
|
|
// Find the row in the Index Sorted Row Set
|
|
if ( !lptad->ulcRowsIndex
|
|
|| (*pplprow >= (lptad->parglprowIndex + lptad->ulcRowsIndex))
|
|
|| LPropCompareProp( lpprop, (**pplprow)->lpProps))
|
|
{
|
|
sc = MAPI_E_NOT_FOUND;
|
|
}
|
|
|
|
ret:
|
|
return sc;
|
|
}
|
|
#else // !WIN16
|
|
BOOL FFindColumn( LPSPropTagArray lpptaCols, ULONG ulPropTag );
|
|
SCODE ScFindRow( LPTAD lptad, LPSPropValue lpprop, LPSRow * * pplprow);
|
|
#endif // !WIN16
|
|
|
|
|
|
// This macro is used on a ULONG or INT that is to be used as denominator
|
|
// If ul is non-zero it is returned unchanged. If ul is zero then a 1 is
|
|
// returned.
|
|
#define UlDenominator(ul) ((ul) | !(ul))
|
|
|
|
BOOL
|
|
FRowContainsProp(LPSRow lprow,
|
|
ULONG cValues,
|
|
LPSPropValue lpsv);
|
|
|
|
STDAPI_(SCODE)
|
|
CreateTableData(LPCIID lpiid,
|
|
ALLOCATEBUFFER FAR * lpfAllocateBuffer,
|
|
ALLOCATEMORE FAR * lpfAllocateMore,
|
|
FREEBUFFER FAR * lpfFreeBuffer,
|
|
LPVOID lpvReserved,
|
|
ULONG ulTableType,
|
|
ULONG ulPropTagIndexCol,
|
|
LPSPropTagArray lpptaCols,
|
|
LPVOID lpvDataSource,
|
|
ULONG cbDataSource,
|
|
LPSBinary pbinContEID,
|
|
ULONG ulFlags,
|
|
LPTABLEDATA FAR * lplptad);
|
|
|
|
HRESULT HrVUERestrict( LPVUE lpvue,
|
|
LPSRestriction lpres,
|
|
ULONG ulFlags );
|