mirror of https://github.com/lianthony/NT4.0
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
265 lines
9.4 KiB
265 lines
9.4 KiB
#define wMagicMR 0x4D47
|
|
#define DC_FOO 4
|
|
#define FOO_NIL -1
|
|
#define FOO_MAGIC -2
|
|
|
|
typedef struct mr {
|
|
#ifdef _DEBUG
|
|
int wMagic;
|
|
int cLocked;
|
|
#endif /* DEBUG */
|
|
HANDLE hFoo;
|
|
QB qFoo;
|
|
int cFooCur;
|
|
int cFooMax;
|
|
} MR, *QMR;
|
|
typedef HANDLE HMR;
|
|
|
|
typedef struct mrd {
|
|
MR mr;
|
|
int iFooFree;
|
|
int iFooFirst;
|
|
int iFooLast;
|
|
} MRD, *QMRD;
|
|
typedef HANDLE HMRD;
|
|
|
|
typedef struct foo {
|
|
int iFooPrev;
|
|
int iFooNext;
|
|
} MRDN, *QMRDN;
|
|
|
|
/* "Assert Comma": This translates into an assert plus a comma
|
|
* in debug, and nothing in non-debug. Used for the assert-macros
|
|
* in this file.
|
|
*/
|
|
#ifdef _DEBUG
|
|
#define AssertC( a ) a,
|
|
#else
|
|
#define AssertC( a )
|
|
#endif
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
|
| Dynamically allocated array |
|
|
| The key object here is the MR, which is a small data structure which |
|
|
| keeps track of relevant information about the list. The calling code |
|
|
| must provide space for the MR, and provides a QMR to the MR code. |
|
|
| Whenever the application wishes to use an MR, it must first call |
|
|
| FInitMR to initialize the MR. After that, it should call AccessMR |
|
|
| before using the MR, and DeAccessMg when it is done making calls. |
|
|
| FreeMR frees the MR data structures. |
|
|
-------------------------------------------------------------------------*/
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
|
| InitMR(qmr, cbFooSize) |
|
|
| InitMRD(qmrd, cbFooSize) |
|
|
| |
|
|
| Purpose: This initializes the fields of an MR with element size |
|
|
| cbFooSize. |
|
|
| Usage: Must be called before the MR is used. |
|
|
-------------------------------------------------------------------------*/
|
|
void STDCALL InitMR(QMR, int);
|
|
|
|
void STDCALL InitMRD(QMRD, int);
|
|
|
|
/*-------------------------------------------------------------------------
|
|
| FreeMR(qmr) |
|
|
| FreeMRD(qmrd) |
|
|
| |
|
|
| Purpose: This releases the memory used by an MR |
|
|
| Usage: The MR must be de-accessed first. |
|
|
-------------------------------------------------------------------------*/
|
|
|
|
#define FreeMR(p1) (AssertC((p1)->wMagic == wMagicMR) \
|
|
AssertC((p1)->cLocked == 0) \
|
|
AssertC(((p1)->wMagic = 0) == 0) \
|
|
FreeGh((p1)->hFoo))
|
|
|
|
#define FreeMRD(p1) (AssertC((p1)->mr.wMagic == wMagicMR) \
|
|
AssertC((p1)->mr.cLocked == 0) \
|
|
AssertC(((p1)->mr.wMagic = 0) == 0) \
|
|
FreeGh((p1)->mr.hFoo))
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
|
| AccessMR(qmr) |
|
|
| AccessMRD(qmrd) |
|
|
| |
|
|
| Purpose: This prepares an MR for use. It must be called before the MR |
|
|
| is accessed. |
|
|
-------------------------------------------------------------------------*/
|
|
|
|
#ifdef _DEBUG
|
|
|
|
#define AccessMR(p1) (AssertC((p1)->wMagic == wMagicMR) \
|
|
AssertC((p1)->cLocked++ > 0) \
|
|
(p1)->qFoo = PtrFromGh((p1)->hFoo))
|
|
|
|
#define AccessMRD(p1) (AssertC((p1)->mr.wMagic == wMagicMR) \
|
|
AssertC((p1)->mr.cLocked++ > 0) \
|
|
(p1)->mr.qFoo = PtrFromGh((p1)->mr.hFoo))
|
|
|
|
/*-------------------------------------------------------------------------
|
|
| DeAccessMR(qmr) |
|
|
| DeAccessMRD(qmrd) |
|
|
| |
|
|
| Purpose: This unlocks the fields of an MR. |
|
|
-------------------------------------------------------------------------*/
|
|
|
|
#if 0
|
|
#define DeAccessMR(p1) (AssertC((p1)->wMagic == wMagicMR)
|
|
AssertC((p1)->cLocked-- > 0) \
|
|
|
|
#define DeAccessMRD(p1) (AssertC((p1)->mr.wMagic == wMagicMR) \
|
|
AssertC((p1)->mr.cLocked-- > 0)
|
|
#endif
|
|
|
|
#define DeAccessMR(p1)
|
|
#define DeAccessMRD(p1)
|
|
|
|
#else
|
|
|
|
#define AccessMR(p1) ((p1)->qFoo = PtrFromGh((p1)->hFoo))
|
|
#define AccessMRD(p1) ((p1)->mr.qFoo = PtrFromGh((p1)->mr.hFoo))
|
|
|
|
#define DeAccessMR(p1)
|
|
#define DeAccessMRD(p1)
|
|
|
|
#endif
|
|
|
|
/*-------------------------------------------------------------------------
|
|
| QFooInMR(qmr, cbFooSize, iFoo) |
|
|
| QFooInMRD(qmrd, cbFooSize, iFoo) |
|
|
| |
|
|
| Purpose: This returns a pointer to element iFoo of the array. |
|
|
-------------------------------------------------------------------------*/
|
|
|
|
#define QFooInMR(p1, p2, p3) (AssertC((p1)->wMagic == wMagicMR) \
|
|
AssertC((p1)->cLocked > 0) \
|
|
(QV)((QB)(p1)->qFoo + (p3) * (p2)))
|
|
|
|
#define QFooInMRD(p1, p2, p3) (AssertC((p1)->mr.wMagic == wMagicMR) \
|
|
AssertC((p1)->mr.cLocked > 0) \
|
|
(QV)((QB)(p1)->mr.qFoo + (p3) * ((p2) + sizeof(MRDN)) + sizeof(MRDN)))
|
|
|
|
#define QMRDNInMRD(p1, p2, p3) (AssertC((p1)->mr.wMagic == wMagicMR) \
|
|
AssertC((p1)->mr.cLocked > 0) \
|
|
(QMRDN)((QB)(p1)->mr.qFoo + (p3) * ((p2) + sizeof(MRDN))))
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
|
| AppendMR(qmr, cbFooSize) |
|
|
| |
|
|
| Purpose: This makes room for a new element at the end of the MR. |
|
|
-------------------------------------------------------------------------*/
|
|
void STDCALL AppendMR(QMR, int);
|
|
|
|
/*-------------------------------------------------------------------------
|
|
| TruncateMRFront(qmr, cbFooSize) |
|
|
| |
|
|
| Purpose: This removes an element from the beginning of the MR. |
|
|
-------------------------------------------------------------------------*/
|
|
|
|
#define TruncateMRFront(p1, p2) (AssertC((p1)->wMagic == wMagicMR) \
|
|
AssertC((p1)->cLocked > 0) \
|
|
AssertC((p1)->cFooCur > 0) \
|
|
AssertC(sizeof(*p1) == sizeof(MR)) \
|
|
MoveMemory((p1)->qFoo, (QB)((p1)->qFoo) + (p2), (LONG) (p2) * --((p1)->cFooCur)))
|
|
|
|
/*-------------------------------------------------------------------------
|
|
| TruncateMRBack(qmr) |
|
|
| |
|
|
| Purpose: This removes an element from the end of the MR. |
|
|
-------------------------------------------------------------------------*/
|
|
#define TruncateMRBack(p1) (AssertC((p1)->wMagic == wMagicMR) \
|
|
AssertC((p1)->cLocked > 0) \
|
|
AssertC((p1)->cFooCur > 0) \
|
|
AssertC(sizeof(*p1) == sizeof(MR)) \
|
|
(--((p1)->cFooCur)))
|
|
|
|
/*-------------------------------------------------------------------------
|
|
| CFooInMR(qmr) |
|
|
| |
|
|
| Purpose: Returns the number of elements in the MR. |
|
|
-------------------------------------------------------------------------*/
|
|
|
|
#define CFooInMR(p1) (AssertC((p1)->wMagic == wMagicMR) \
|
|
AssertC((p1)->cLocked > 0) \
|
|
(p1)->cFooCur)
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
|
| ClearMR(qmr) |
|
|
| |
|
|
| Purpose: This eliminates all elements from the MR. It does not reduce |
|
|
| the amount of memory occupied by the MR. |
|
|
-------------------------------------------------------------------------*/
|
|
|
|
#define ClearMR(p1) (AssertC((p1)->wMagic == wMagicMR) \
|
|
((QMR)(p1))->cFooCur=0)
|
|
|
|
/*-------------------------------------------------------------------------
|
|
| IFooInsertFooMRD(qmrd, cbFooSize, iFooOld) |
|
|
| |
|
|
| Purpose: Inserts a new element into the linked list. If iFooOld is |
|
|
| iFooFirstReq, the element is made the first element in the |
|
|
| list. If it is iFooLastReq, it is made the last element in |
|
|
| the list. Otherwise, it is placed immediately after iFooOld. |
|
|
| Returns: iFoo of the new element. |
|
|
-------------------------------------------------------------------------*/
|
|
int STDCALL IFooInsertFooMRD(QMRD, int, int);
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
|
| void DeleteFooMRD(qmrd, cbFooSize, iFoo) |
|
|
| |
|
|
| Purpose: Deletes an element from the linked list. |
|
|
-------------------------------------------------------------------------*/
|
|
void STDCALL DeleteFooMRD(QMRD, int, int);
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
|
| int IFooNextMRD(qmrd, cbFooSize, iFoo) |
|
|
| |
|
|
| Purpose: Returns the iFoo of the next element in the list. |
|
|
-------------------------------------------------------------------------*/
|
|
#define IFooNextMRD(p1, p2, p3) \
|
|
((p3) == FOO_NIL ? (p1)->iFooFirst : (QMRDNInMRD((p1), (p2), (p3)))->iFooNext)
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
|
| int IFooPrevMRD(qmrd, cbFooSize, iFoo) |
|
|
| |
|
|
| Purpose: Returns the iFoo of the previous element in the list. |
|
|
-------------------------------------------------------------------------*/
|
|
#define IFooPrevMRD(p1, p2, p3) \
|
|
((p3) == FOO_NIL ? (p1)->iFooLast : (QMRDNInMRD((p1), (p2), (p3)))->iFooPrev)
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
|
| int IFooFirstMRD(qmrd) |
|
|
| |
|
|
| Purpose: Returns the iFoo of the first element in the list. |
|
|
-------------------------------------------------------------------------*/
|
|
#define IFooFirstMRD(p1) (p1)->iFooFirst
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
|
| int IFooLastMRD(qmrd) |
|
|
| |
|
|
| Purpose: Returns the iFoo of the first element in the list. |
|
|
-------------------------------------------------------------------------*/
|
|
#define IFooLastMRD(p1) (p1)->iFooLast
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
|
| int FVerifyMRD(qmrd, cbFooSize) |
|
|
| |
|
|
| Purpose: Verifies the integrity of the MRD. |
|
|
-------------------------------------------------------------------------*/
|
|
#ifdef _DEBUG
|
|
int FVerifyMRD(QMRD, int);
|
|
#else /* DEBUG */
|
|
#define FVerifyMRD(p1, p2)
|
|
#endif /* DEBUG */
|