windows-xp/Source/XPSP1/NT/shell/ext/docprop/plex.c

/*---------------------------------------------------------------------------
FILE : PLEX.C
AUTHOR: STOLEN FROM EXCEL modified by NavPal
 This file contains routines used to manipulate the PL (pronounced:
 "plex") structures.
----------------------------------------------------------------------------*/
#include "priv.h"
#pragma hdrstop

#ifndef WINNT
#include "plex.h"
#include "debug.h"
#endif
/*-----------------------------------------------------------------------
|	FInRange
|		Simple little routine that tells you if a number lies within a
|		range.
|	
|	
|	Arguments:
|		w:			Number to check
|		wFirst:	First number in the range	
|		wLast:	Last number in the range
|		
|	Returns:
|		fTrue if the number is in range
|		
|	Keywords: in range check
-----------------------------------------------------------------------*/
BOOL FInRange(w, wFirst, wLast)
int w;
int wFirst, wLast;
{
	Assert(wLast >= wFirst);
	return(w >= wFirst && w <= wLast);
}
#ifdef DEBUG
/*----------------------------------------------------------------------------
|	FValidPl
|
|	Checks for a valid PL structure.
|
|	Arguments:
|		ppl		PL to check
|
|	Returns:
|		fTrue if the PL looks reasonable.
----------------------------------------------------------------------------*/
BOOL FValidPl(pvPl)
VOID *pvPl;
{
#define ppl ((PL *)pvPl)
	if (ppl== NULL ||
			ppl->cbItem == 0 ||
			ppl->iMac < 0 ||
			ppl->iMax < 0 ||
			ppl->iMax < ppl->iMac)
		return(fFalse);
	return(fTrue);
#undef ppl
}
#endif //DEBUG
/*----------------------------------------------------------------------------
|	CbPlAlloc
|
|	Returns amount of memory allocated to the given PL
|
|	Arguments:
|		ppl		PL to return info for.
|
|	Returns:
|		memory allocated to the PL
----------------------------------------------------------------------------*/
int CbPlAlloc(pvPl)
VOID *pvPl;
{
#define ppl ((PL *)pvPl)
	if (ppl == NULL)
		return(0);
#ifdef DEBUG
	Assert(FValidPl(ppl));
#endif // DEBUG
	return(WAlign(cbPL + (ppl->iMax * ppl->cbItem)));
#undef ppl
}
/*----------------------------------------------------------------------------
|	FreePpl
|
|	Frees a PL.
|
|	Arguments:
|		ppl		PL to free
|
|	Returns:
|		Nothing.
----------------------------------------------------------------------------*/
void FreePpl(pvPl)
VOID *pvPl;
{
#ifdef DEBUG
	Assert(FValidPl(pvPl));
#endif // DEBUG
	VFreeMemP(pvPl, (unsigned) CbPlAlloc(pvPl));
}
/*----------------------------------------------------------------------------
|	PplAlloc
|
|	Allocates and initializes a PL.
|
|	Arguments:
|		cbItem		sizeof structure in the PL
|		dAlloc		number of items to allocate at a time
|		iMax		number of items in initial allocation
|
|	Returns:
|		Pointer to PL.
|
|	Notes:
|		returns NULL if OOM
----------------------------------------------------------------------------*/
VOID *PplAlloc(cbItem, dAlloc, iMax)
unsigned cbItem;
int dAlloc;
unsigned iMax;
{
	PL *ppl;
	long cb;

	if (iMax > 32767) /* not too likely, but what the heck. */
		return(NULL);

	Assert((cbItem>=1 && cbItem<=65535u) && FInRange(dAlloc, 1, 31));

	cb = WAlign((long) cbPL + (long) cbItem * (long) iMax);

	ppl = (PL *)PvMemAlloc((unsigned) cb);
	if(ppl==NULL)
		return(NULL);
	FillBuf(ppl,0, (unsigned) cb);
	ppl->cbItem = cbItem;
	ppl->dAlloc = dAlloc;
	ppl->iMax = iMax;
	ppl->fUseCount = fFalse;
#ifdef DEBUG
	Assert(FValidPl(ppl));
#endif // DEBUG
	return(ppl);
}
/*----------------------------------------------------------------------------
|	IAddPl
|
|	Adds an item to a PL.
|
|	Arguments:
|		pppl		Pointer to PL.  May change if reallocated.
|		pv		New item to add.
|
|	Returns:
|		Index of new item.
|
|	Notes:
|		returns -1 if OOM
----------------------------------------------------------------------------*/
int IAddPl(ppvPl, pv)
VOID  **ppvPl;
VOID  *pv;
{
	int cbItem;
	int iMac;
	PL *ppl, *pplNew;

	ppl = *ppvPl;
#ifdef DEBUG
	Assert(FValidPl(ppl));
#endif // DEBUG
	cbItem = ppl->cbItem;
	iMac = ppl->iMac;
#ifdef UNUSED
	if (ppl->fUseCount)
		{
		int i;
		BYTE *pb;

		(*(int *)pv) = 1;

		// Search for an unused entry
		for (i = 0, pb = ppl->rg; i < iMac; i++, pb += cbItem)
			{
			if ((*(int *) pb) == 0)
				{
				bltbh(hpv, hpb, cbItem);
				return i;
				}
			}
		}
#endif
	if (iMac == ppl->iMax)
		{
		pplNew = PplAlloc(cbItem, ppl->dAlloc, iMac + ppl->dAlloc);
		if(pplNew==NULL)//OOM
			return(-1);
		pplNew->fUseCount = ppl->fUseCount;
		PbMemCopy(pplNew->rg,ppl->rg, iMac * cbItem);
	     /* pplNew->iMac = iMac;  /* This is not needed because hppl->iMac
					  will be over-written later */
		FreePpl(ppl);
		*ppvPl = ppl = pplNew;
		}
	PbMemCopy(&ppl->rg[iMac * cbItem],pv,cbItem);
	ppl->iMac = iMac + 1;
#ifdef DEBUG
	Assert(FValidPl(*ppvPl));
#endif // DEBUG
	return(iMac);
}
/*----------------------------------------------------------------------------
|	RemovePl
|
|	Removes an item from a PL.
|
|	Arguments:
|		ppl		PL to remove item from
|		i		index of item to remove
|
|	Returns:
|		fTrue if an item was removed (only fFalse for use count plexes).
----------------------------------------------------------------------------*/
BOOL RemovePl(pvPl, i)
VOID *pvPl;
int i;
{
	int iMac;
	int cbItem;
	BYTE *p;
#define ppl ((PL *)pvPl)

#ifdef DEBUG
	Assert(FValidPl(ppl) && i < ppl->iMac);
#endif // DEBUG
	iMac = ppl->iMac;
	cbItem = ppl->cbItem;
	p = &ppl->rg[i * cbItem];
#ifdef UNUSED
	if (ppl->fUseCount)
		{
		Assert((*(int HUGE *) hp) > 0);
		if (--(*(int HUGE *) hp) > 0)
			return fFalse;
		}
#endif
	if (i != iMac - 1)
		{
		PbMemCopy(p,p+cbItem,(iMac - i - 1) * cbItem);
		}
	ppl->iMac = iMac - 1;
#ifdef DEBUG
	Assert(FValidPl(ppl));
#endif // DEBUG
	return fTrue;
#undef ppl
}
/*----------------------------------------------------------------------------
|	ILookupPl
|
|	Searches a PL for an item.
|
|	Arguments:
|		ppl		PL to lookup into
|		p		item to lookup
|		pfnSgn		Comparison function
|
|	Returns:
|		index of item, if found.
|		-1 if not found.
----------------------------------------------------------------------------*/
int ILookupPl(pvPl, pvItem, pfnSgn)
VOID *pvPl;
VOID *pvItem;
int (*pfnSgn)();
{
	int i;
	BYTE *p;
#define ppl ((PL *)pvPl)

	if (ppl == NULL)
		return(-1);
#ifdef DEBUG
	Assert(FValidPl(ppl));
#endif // DEBUG
#ifdef UNUSED
	if (ppl->fUseCount)
		{
		for (i = 0, p = ppl->rg; i < ppl->iMac; i++, p += ppl->cbItem)
			{
			if (*(int *)p != 0 && (*(int (*)(void *,void *))pfnSgn)(p, pvItem) == sgnEQ)
				return(i);
			}
		}
	else
#endif
		{
		for (i = 0, p = ppl->rg; i < ppl->iMac; i++, p += ppl->cbItem)
			{
			if ((*(int (*)(void *, void *))pfnSgn)(p, pvItem) == sgnEQ)
				return(i);
			}
		}
	return(-1);
#undef ppl
}
/*----------------------------------------------------------------------------
|	PLookupPl
|
|	Searches a PL for an item
|
|	Arguments:
|		ppl		PL to search
|		pItem		item to search for
|		pfnSgn		comparison function
|
|	Returns:
|		Pointer to item, if found
|		Null, if not found
----------------------------------------------------------------------------*/
VOID *PLookupPl(pvPl, pvItem, pfnSgn)
VOID *pvPl;
VOID *pvItem;
int (*pfnSgn)();
{
	int i;

	if ((i = ILookupPl(pvPl, pvItem, pfnSgn)) == -1)
		return(NULL);
	return(&((PL *)pvPl)->rg[i * ((PL *)pvPl)->cbItem]);
}

/*----------------------------------------------------------------------------
|	FLookupSortedPl
|
|	Searches a sorted PL for an item.
|
|	Arguments:
|		hppl		PL to lookup into
|		hpItem		Item to lookup
|		pi			Index of found item (or insertion location if not)
|		pfnSgn		Comparison function
|
|	Returns:
|		index of item, if found.
|		index of location to insert if not found.
----------------------------------------------------------------------------*/
int FLookupSortedPl(hpvPl, hpvItem, pi, pfnSgn)
VOID *hpvPl;
VOID *hpvItem;
int *pi;
int (*pfnSgn)();
{
	int sgn;
	unsigned iMin, iMid, iMac;
	int cbItem;
	BYTE *hprg;
	BYTE *hpMid;
#define hppl ((PL *)hpvPl)

	if ((hppl)==NULL)
		{
		*pi = 0;
		return(fFalse);
		}

#ifdef DEBUG
	Assert(FValidPl(hppl));
#endif // DEBUG
	Assert(!hppl->fUseCount);

	sgn = 1;
	cbItem = hppl->cbItem;
	iMin = iMid = 0;
	iMac = hppl->iMac;
	hprg = hppl->rg;
	while (iMin != iMac)
		{
		iMid = iMin + (iMac-iMin)/2;
		Assert(iMid != iMac);

		hpMid = hprg + iMid*cbItem;
		if ((sgn = (*(int (*)(void *, void *))pfnSgn)(hpMid, hpvItem)) == 0)
			break;

		/* Too low, look in upper interval */
		if (sgn < 0)
			iMin = ++iMid;
		/* Too high, look in lower interval */
		else
			iMac = iMid;
		}

	/* Not found, return index of location to insert it */
	*pi = iMid;
	return(sgn == 0);
#undef hppl
}

/*----------------------------------------------------------------------------
|	IAddNewPl
|
|	Adds an item to a PL, creating the PL if it's initially NULL.
|
|	Arguments:
|		phppl		pointer to PL
|		hp		pointer to item to add
|		cbItem		size of item
|
|	Returns:
|		the index of item added, if successful
|		-1, if out-of-memory
----------------------------------------------------------------------------*/
int IAddNewPl(phpvPl, hpv, cbItem)
VOID **phpvPl;
VOID *hpv;
int cbItem;
{
	int i;

#define phppl ((PL **)phpvPl)

	Assert(((*phppl)==NULL) || !(*phppl)->fUseCount);
	i = -1;
	if ((*phppl)==NULL)
		{
		*phppl = PplAlloc(cbItem, 5, 5);
		}
	if((*phppl)!=NULL)
		{
		Assert((*phppl)->cbItem == cbItem);
		i = IAddPl((VOID **)phppl, hpv);
		}
	return(i);
#undef phppl
}

/*----------------------------------------------------------------------------
|	IAddNewPlPos
|
|	Inserts an item into a plex at a specific position.
|
|	Arguments:
|		the index of the item added, if successful
|		-1 if out-of-memory
----------------------------------------------------------------------------*/
int IAddNewPlPos(phpvPl, hpv, cbItem, i)
VOID **phpvPl;
VOID *hpv;
int cbItem;
int i;
{
	BYTE *hpT;
#define phppl ((PL **)phpvPl)

	Assert(((*phppl)==NULL) || !(*phppl)->fUseCount);
	if (IAddNewPl((VOID **)phppl, hpv, cbItem) == -1)
		return(-1);
	Assert(i < (*phppl)->iMac);
	hpT = &(*phppl)->rg[i * cbItem];
//	bltbh(hpT, hpT + cbItem, ((*phppl)->iMac - i - 1) * cbItem);
//	bltbh(hpv, hpT, cbItem);
	PbMemCopy(hpT + cbItem, hpT, ((*phppl)->iMac - i - 1) * cbItem);
	PbMemCopy(hpT, hpv, cbItem);
#ifdef DEBUG
	Assert(FValidPl(*phppl));
#endif // DEBUG
	return(i);
#undef phppl
}

int IAddPlSort(phpvPl, hpv, pfnSgn)
VOID **phpvPl;
VOID *hpv;
int (*pfnSgn)();
{
	int i;
#ifdef DEBUG
	int iOld;
#endif
	Assert((*phpvPl)!=NULL);

	if (FLookupSortedPl(*phpvPl, hpv, &i, pfnSgn))
		return(-1);

#ifdef DEBUG
	iOld = i;
#endif
	i = IAddNewPlPos(phpvPl, hpv, (*(PL **)phpvPl)->cbItem, i);
#ifdef DEBUG
	Assert(i == -1 || i == iOld);
#endif
	return(i);
}


//---------------------------------------------------------------------------
//NO CHANGES BELOW THIS LINE PLEASE
//---------------------------------------------------------------------------
#ifdef FROMEXCEL
/*---------------------------------------------------------------------------
THIS CODE IS FROM EXCEL SOURCES. ITS KEPT HERE FOR REFERENCE
---------------------------------------------------------------------------*/
#pragma hdrstop("Excel.pre")
VSZASSERT
#include "new.h"


/* This file contains routines used to manipulate the PL (pronounced:
   "plex") structures.  They should probably be moved somewhere a little
   more appropriate, like maybe alloc.c */

/*----------------------------------------------------------------------------
|	HpLookupPl
|
|	Searches a PL for an item
|
|	Arguments:
|		hppl		PL to search
|		hpItem		item to search for
|		pfnSgn		comparison function
|
|	Returns:
|		Pointer to item, if found
|		hpNull, if not found
----------------------------------------------------------------------------*/
VOID HUGE *HpLookupPl(hpvPl, hpvItem, pfnSgn)
VOID HUGE *hpvPl;
VOID HUGE *hpvItem;
int (*pfnSgn)();
{
	int i;

	if ((i = ILookupPl(hpvPl, hpvItem, pfnSgn)) == -1)
		return(hpNull);
	return(&((PL HUGE *)hpvPl)->rg[i * ((PL HUGE *)hpvPl)->cbItem]);
}

#ifndef GRAF
#ifdef MAC
#pragma alloc_text(window, HpplAlloc)
#else
#pragma alloc_text(window2, HpplAlloc)
#endif
#else
#pragma alloc_text(plgboot, HpplAlloc)
#endif
/*----------------------------------------------------------------------------
|	HpplAlloc
|
|	Allocates and initializes a PL.
|
|	Arguments:
|		cbItem		sizeof structure in the PL
|		dAlloc		number of items to allocate at a time
|		iMax		number of items in initial allocation
|		dg		memory group to allocate from
|
|	Returns:
|		Pointer to PL.
|
|	Notes:
|		May DoJmp(penvMem).
----------------------------------------------------------------------------*/
/*<<mcmain*/
#pragma NATIVE_START
VOID HUGE *HpplAlloc(cbItem, dAlloc, iMax, dg)
unsigned cbItem;
int dAlloc;
unsigned iMax;
unsigned dg;
{
	PL HUGE *hppl;
	long cb;
	int dgShift;

	if (iMax > 32767) /* not too likely, but what the heck. */
		DoJmp(penvMem, alctNoMem);

	Assert((cbItem>=1 && cbItem<=65535u) && FInRange(dAlloc, 1, 31) &&
		FInRange(BLow(dg), 1, 255));

	cb = WAlign((long) cbPL + (long) cbItem * (long) iMax);
#ifndef LARGEALLOC
	if(cb >= cbHeapMax)
		{
		ErrorNoMem();
		DoJmp(penvMem, alctNoMem);
		}
#endif

	hppl = (PL HUGE *)HpAlloc((unsigned) cb, dg);
	bltcbh(0, hppl, (unsigned) cb);
	Assert(dg!=0);
	for (dgShift = 0; !(dg & 1); dg >>= 1, dgShift++)
		;
	Assert(dgShift<8);
	hppl->cbItem = cbItem;
	hppl->dAlloc = dAlloc;
	hppl->iMax = iMax;
	hppl->fUseCount = fFalse;
	hppl->dgShift = dgShift;
#ifdef DEBUG
	Assert(FValidPl(hppl));
#endif // DEBUG
	return(hppl);
}
#pragma NATIVE_END
/*<<plex*/


#ifdef MAC
#pragma alloc_text(window, HpplUseCountAlloc)
#else
#pragma alloc_text(window2, HpplUseCountAlloc)
#endif
VOID HUGE *HpplUseCountAlloc(cbItem, dAlloc, iMax, dg)
unsigned cbItem;
int dAlloc;
unsigned iMax;
unsigned dg;
{
	PL HUGE *hppl;

	hppl = HpplAlloc(cbItem, dAlloc, iMax, dg);
	hppl->fUseCount = fTrue;
	return hppl;
}


/*----------------------------------------------------------------------------
|	FreeHppl
|
|	Frees a PL.
|
|	Arguments:
|		hppl		PL to free
|
|	Returns:
|		Nothing.
----------------------------------------------------------------------------*/
/*<<mcmain*/
#ifndef GRAF
#ifdef MAC
#pragma alloc_text(window, FreeHppl)
#else
#pragma alloc_text(window2, FreeHppl)
#endif
#endif
#pragma NATIVE_START
FreeHppl(hpvPl)
VOID HUGE *hpvPl;
{
#ifdef DEBUG
	Assert(FValidPl(hpvPl));
#endif // DEBUG
	FreeHp(hpvPl, CbPlAlloc(hpvPl));
}
#pragma NATIVE_END
/*<<plex*/

#ifndef GRAF
#ifdef MAC
#pragma alloc_text(window, ILookupPl)
#else
#pragma alloc_text(window2, ILookupPl)
#endif
#else
#pragma alloc_text(swpmisc, ILookupPl)
#endif
/*----------------------------------------------------------------------------
|	ILookupPl
|
|	Searches a PL for an item.
|
|	Arguments:
|		hppl		PL to lookup into
|		hp		item to lookup
|		pfnSgn		Comparison function
|
|	Returns:
|		index of item, if found.
|		-1 if not found.
----------------------------------------------------------------------------*/
#pragma NATIVE_START
int ILookupPl(hpvPl, hpvItem, pfnSgn)
VOID HUGE *hpvPl;
VOID HUGE *hpvItem;
int (*pfnSgn)();
{
	int i;
	BYTE HUGE *hp;
#define hppl ((PL HUGE *)hpvPl)

	if (SbFromHp(hppl) == sbNull)
		return(-1);
#ifdef DEBUG
	Assert(FValidPl(hppl));
#endif // DEBUG
	if (hppl->fUseCount)
		{
		for (i = 0, hp = hppl->rg; i < hppl->iMac; i++, hp += hppl->cbItem)
			{
			if (*(int HUGE *)hp != 0 && (*(int (*)(HP, HP))pfnSgn)(hp, hpvItem) == sgnEQ)
				return(i);
			}
		}
	else
		{
		for (i = 0, hp = hppl->rg; i < hppl->iMac; i++, hp += hppl->cbItem)
			{
			if ((*(int (*)(HP, HP))pfnSgn)(hp, hpvItem) == sgnEQ)
				return(i);
			}
		}
	return(-1);
#undef hppl
}
#pragma NATIVE_END

/*----------------------------------------------------------------------------
|	FLookupSortedPl
|
|	Searches a sorted PL for an item.
|
|	Arguments:
|		hppl		PL to lookup into
|		hpItem		Item to lookup
|		pi			Index of found item (or insertion location if not)
|		pfnSgn		Comparison function
|
|	Returns:
|		index of item, if found.
|		index of location to insert if not found.
----------------------------------------------------------------------------*/
#ifdef MAC
#pragma alloc_text(window, FLookupSortedPl)
#else
#pragma alloc_text(window2, FLookupSortedPl)
#endif
#pragma NATIVE_START
int FLookupSortedPl(hpvPl, hpvItem, pi, pfnSgn)
VOID HUGE *hpvPl;
VOID HUGE *hpvItem;
int *pi;
int (*pfnSgn)();
{
	int sgn;
	unsigned iMin, iMid, iMac;
	int cbItem;
	BYTE HUGE *hprg;
	BYTE HUGE *hpMid;
#define hppl ((PL HUGE *)hpvPl)

	if (SbFromHp(hppl) == sbNull)
		{
		*pi = 0;
		return(fFalse);
		}

#ifdef DEBUG
	Assert(FValidPl(hppl));
#endif // DEBUG
	Assert(!hppl->fUseCount);

	sgn = 1;
	cbItem = hppl->cbItem;
	iMin = iMid = 0;
	iMac = hppl->iMac;
	hprg = hppl->rg;
	while (iMin != iMac)
		{
		iMid = iMin + (iMac-iMin)/2;
		Assert(iMid != iMac);

		hpMid = hprg + iMid*cbItem;
		if ((sgn = (*(int (*)(HP, HP))pfnSgn)(hpMid, hpvItem)) == 0)
			break;

		/* Too low, look in upper interval */
		if (sgn < 0)
			iMin = ++iMid;
		/* Too high, look in lower interval */
		else
			iMac = iMid;
		}

	/* Not found, return index of location to insert it */
	*pi = iMid;
	return(sgn == 0);
#undef hppl
}
#pragma NATIVE_END

/*----------------------------------------------------------------------------
|	DeletePl
|
|	Removes an item from a PL.  The resulting PL is compacted.
|
|	Arguments:
|		phppl		pointer to PL to remove item from
|		i		index of item to remove
|
|	Returns:
|		Nothing.
----------------------------------------------------------------------------*/
DeletePl(phpvPl, i)
VOID HUGE **phpvPl;
int i;
{
#ifdef DEBUG
	Assert(FValidPl(*phpvPl));
#endif // DEBUG
	RemovePl(*phpvPl, i);
	FCompactPl(phpvPl, (*(PL HUGE **)phpvPl)->iMac == 0);
#ifdef DEBUG
	Assert(SbOfHp(*phpvPl) == sbNull || FValidPl(*phpvPl));
#endif // DEBUG
}


/*----------------------------------------------------------------------------
|	RemovePl
|
|	Removes an item from a PL.
|
|	Arguments:
|		hppl		PL to remove item from
|		i		index of item to remove
|
|	Returns:
|		fTrue if an item was removed (only fFalse for use count plexes).
----------------------------------------------------------------------------*/
BOOL RemovePl(hpvPl, i)
VOID HUGE *hpvPl;
int i;
{
	int iMac;
	int cbItem;
	BYTE HUGE *hp;
#define hppl ((PL HUGE *)hpvPl)

#ifdef DEBUG
	Assert(FValidPl(hppl) && i < hppl->iMac);
#endif // DEBUG
	iMac = hppl->iMac;
	cbItem = hppl->cbItem;
	hp = &hppl->rg[i * cbItem];

	if (hppl->fUseCount)
		{
		Assert((*(int HUGE *) hp) > 0);
		if (--(*(int HUGE *) hp) > 0)
			return fFalse;
		}
			
	if (i != iMac - 1)
		{
		bltbh(hp + cbItem, hp, (iMac - i - 1) * cbItem);
		}
	hppl->iMac = iMac - 1;
#ifdef DEBUG
	Assert(FValidPl(hppl));
#endif // DEBUG
	return fTrue;
#undef hppl
}

#ifndef GRAF
#ifdef MAC
#pragma alloc_text(window, IAddPl)
#else
#pragma alloc_text(window2, IAddPl)
#endif
#else
#pragma alloc_text(swpmisc, IAddPl)
#endif
/*----------------------------------------------------------------------------
|	IAddPl
|
|	Adds an item to a PL.
|
|	Arguments:
|		phppl		Pointer to PL.  May change if reallocated.
|		hp		New item to add.
|
|	Returns:
|		Index of new item.
|
|	Notes:
|		May DoJmp(penvMem) when reallocating.
----------------------------------------------------------------------------*/
/*<<mcmain*/
#pragma NATIVE_START
int IAddPl(phpvPl, hpv)
VOID HUGE **phpvPl;
VOID HUGE *hpv;
{
	int cbItem;
	int iMac;
	PL HUGE *hppl, HUGE *hpplNew;

	hppl = *phpvPl;
#ifdef DEBUG
	Assert(FValidPl(hppl));
#endif // DEBUG
	cbItem = hppl->cbItem;
	iMac = hppl->iMac;

	if (hppl->fUseCount)
		{
		int i;
		BYTE HUGE *hpb;

		(*(int HUGE *)hpv) = 1;

		// Search for an unused entry
		for (i = 0, hpb = hppl->rg; i < iMac; i++, hpb += cbItem)
			{
			if ((*(int HUGE *) hpb) == 0)
				{
				bltbh(hpv, hpb, cbItem);
				return i;
				}
			}
		}

#ifdef DEBUG
	if (iMac == hppl->iMax || fShakeMem)
#else
	if (iMac == hppl->iMax)
#endif
		{
		hpplNew = HpplAlloc(cbItem, hppl->dAlloc, iMac + hppl->dAlloc, 0x01<<hppl->dgShift);
		hpplNew->fUseCount = hppl->fUseCount;
		bltbh(hppl->rg, hpplNew->rg, iMac * cbItem);
	     /* hpplNew->iMac = iMac;  /* This is not needed because hppl->iMac
					  will be over-written later */
		FreeHppl(hppl);
		*phpvPl = hppl = hpplNew;
		}
	bltbh(hpv, &hppl->rg[iMac * cbItem], cbItem);
	hppl->iMac = iMac + 1;
#ifdef DEBUG
	Assert(FValidPl(*phpvPl));
#endif // DEBUG
	return(iMac);
}
#pragma NATIVE_END
/*<<plex*/


/* Not used for Mac */
#ifndef MAC
/*----------------------------------------------------------------------------
|	ILookAddPl
|
|	Searces a PL for an item and adds the item if it's not already there.
|
|	Arguments:
|		phppl	Pointer to PL.  May change if reallocated.
|		hp	Item to find/add.
|		pfnSgn	Comparison function
|
|	Returns:
|		Index of item found/added.
|
|	Notes:
|		The PL must already be created.
|		May DoJmp(penvMem) when reallocating.
----------------------------------------------------------------------------*/
#ifdef DDE
int ILookAddPl(phpvPl, hpv, pfnSgn)
VOID HUGE **phpvPl;
VOID HUGE *hpv;
int (*pfnSgn)();
{
	int i;
#define phppl ((PL HUGE **)phpvPl)

	Assert(!(*phppl)->fUseCount);
	if ((i = ILookupPl(*phpvPl, hpv, pfnSgn)) == -1)
		i = IAddPl(phpvPl, hpv);
	return(i);
#undef phppl
}
#endif
#endif

#ifndef GRAF
#ifdef MAC
#pragma alloc_text(window, IAddNewPl)
#else
#pragma alloc_text(window2, IAddNewPl)
#endif
#endif
/*----------------------------------------------------------------------------
|	IAddNewPl
|
|	Adds an item to a PL, creating the PL if it's initially NULL.
|
|	Arguments:
|		phppl		pointer to PL
|		hp		pointer to item to add
|		cbItem		size of item
|		dg		data group to alloc plex in
|
|	Returns:
|		the index of item added, if successful
|		-1, if out-of-memory
----------------------------------------------------------------------------*/
/*<<mcmain*/
#pragma NATIVE_START
int IAddNewPl(phpvPl, hpv, cbItem, dg)
VOID HUGE **phpvPl;
VOID HUGE *hpv;
int cbItem;
int dg;
{
	int i;
	ENV *penvSav, env;
#ifdef DEBUG
	BOOL fShakeMemSav = 2;
	extern BOOL fShakeMem;
#endif

#define phppl ((PL HUGE **)phpvPl)

	Assert(FNullHp(*phppl) || !(*phppl)->fUseCount);
	i = -1;
	penvSav = penvMem;
	if (SetJmp(penvMem = &env) == 0)
		{
		if (SbOfHp(*phppl) == sbNull)
			{
			*phppl = HpplAlloc(cbItem, 5, 5, dg);
#ifdef DEBUG
			/* Turn off shake mem in this case, since we don't accomplish
				any additional memory checking when we've just allocated
				the plex from scratch anyway. */

			Assert(fShakeMem != 2);
			fShakeMemSav = fShakeMem;
			fShakeMem = FALSE;
#endif /* DEBUG */
			}
		Assert((*phppl)->cbItem == cbItem);
		i = IAddPl((VOID HUGE **)phppl, hpv);
		}
	penvMem = penvSav;
#ifdef DEBUG
	if (fShakeMemSav != 2)
		fShakeMem = fShakeMemSav;
#endif /* DEBUG */
	return(i);
#undef phppl
}
#pragma NATIVE_END
/*<<plex*/

#ifndef GRAF
#ifdef MAC
#pragma alloc_text(window, IAddNewPlPos)
#else
#pragma alloc_text(window2, IAddNewPlPos)
#endif
#endif
/*----------------------------------------------------------------------------
|	IAddNewPlPos
|
|	Inserts an item into a plex at a specific position.
|
|	Arguments:
|		the index of the item added, if successful
|		-1 if out-of-memory
----------------------------------------------------------------------------*/
/*<<mcmain*/
#pragma NATIVE_START
int IAddNewPlPos(phpvPl, hpv, cbItem, i, dg)
VOID HUGE **phpvPl;
VOID HUGE *hpv;
int cbItem;
int i;
int dg;
{
	BYTE HUGE *hpT;
#define phppl ((PL HUGE **)phpvPl)

	Assert(FNullHp(*phppl) || !(*phppl)->fUseCount);
	if (IAddNewPl((VOID HUGE **)phppl, hpv, cbItem, dg) == -1)
		return(-1);
	Assert(i < (*phppl)->iMac);
	hpT = &(*phppl)->rg[i * cbItem];
	bltbh(hpT, hpT + cbItem, ((*phppl)->iMac - i - 1) * cbItem);
	bltbh(hpv, hpT, cbItem);
#ifdef DEBUG
	Assert(FValidPl(*phppl));
#endif // DEBUG
	return(i);
#undef phppl
}
#pragma NATIVE_END
/*<<plex*/

#ifdef MAC
#pragma alloc_text(window, IAddPlSort)
#else
#pragma alloc_text(window2, IAddPlSort)
#endif
int IAddPlSort(phpvPl, hpv, pfnSgn)
VOID HUGE **phpvPl;
VOID HUGE *hpv;
int (*pfnSgn)();
{
	int i;
#ifdef DEBUG
	int iOld;
#endif
	Assert(!FNullHp(*phpvPl));

	if (FLookupSortedPl(*phpvPl, hpv, &i, pfnSgn))
		return(-1);

#ifdef DEBUG
	iOld = i;
#endif
	i = IAddNewPlPos(phpvPl, hpv, (*(PL HUGE **)phpvPl)->cbItem, i, 1<<(*(PL HUGE **)phpvPl)->dgShift);
	Assert(i == -1 || i == iOld);
	return(i);
}


/*----------------------------------------------------------------------------
|	FCompactPl
|
|	Squeezes unused memory out of a PL
|
|	Arguments:
|		phppl		Plex to compact
|		fFull		fTrue if maximal compaction should be made
|
|	Returns:
|		fTrue if some memory was freed.
----------------------------------------------------------------------------*/
BOOL FCompactPl(phpvPl, fFull)
VOID HUGE **phpvPl;
BOOL fFull;
{
	int iMac, cbItem, cbFree, dAlloc;
	BYTE HUGE *hp;
	PL HUGE *hppl = *phpvPl;
	BOOL fFreed = fFalse;

	if (SbOfHp(hppl) != sbNull)
		{
#ifdef DEBUG
		Assert(FValidPl(hppl));
#endif // DEBUG
		if ((iMac = hppl->iMac) == 0 && fFull)
			{
			FreeHppl(hppl);
			fFreed = fTrue;
			*phpvPl = hpNull;
			}
		else
			{
			if (!fFull)
				{
				dAlloc = hppl->dAlloc;
				iMac = (iMac + dAlloc) / dAlloc * dAlloc;
				}
			hp = &hppl->rg[iMac * (cbItem = hppl->cbItem)];
			if (IbOfHp(hp) & 1)
				{
				/* can't free on an odd boundary */
				Assert((cbItem & 1) && (iMac & 1));
				iMac++;
				hp += cbItem;
				}
			Assert((IbOfHp(hp) & 1) == 0);
			/* must free at least 4 bytes, and it had better
			   be an even number */
			if ((cbFree = WAlign((hppl->iMax - iMac) * cbItem)) >= 4)
				{
				CbChopHp(hp, cbFree);
				fFreed = fTrue;
				hppl->iMax = iMac;
				}
			}
		}
#ifdef DEBUG
	Assert(SbOfHp(*phpvPl) == sbNull || FValidPl(*phpvPl));
#endif // DEBUG
	return(fFreed);
}

/*----------------------------------------------------------------------------
|	CbPlAlloc
|
|	Returns amount of memory allocated to the given PL
|
|	Arguments:
|		hppl		PL to return info for.
|
|	Returns:
|		memory allocated to the PL
----------------------------------------------------------------------------*/
/*<<mcmain*/
#ifndef GRAF
#ifdef MAC
#pragma alloc_text(window, CbPlAlloc)
#else
#pragma alloc_text(window2, CbPlAlloc)
#endif
#endif
#pragma NATIVE_START
int CbPlAlloc(hpvPl)
VOID HUGE *hpvPl;
{
#define hppl ((PL HUGE *)hpvPl)
	if (SbFromHp(hppl) == sbNull)
		return(0);
#ifdef DEBUG
	Assert(FValidPl(hppl));
#endif // DEBUG
	return(WAlign(cbPL + (hppl->iMax * hppl->cbItem)));
#undef hppl
}
#pragma NATIVE_END
/*<<plex*/

#ifndef GRAF
#ifdef MAC
#pragma alloc_text(window, ResizePl)
#else
#pragma alloc_text(window2, ResizePl)
#endif
#endif
/*----------------------------------------------------------------------------
|	ResizePl
|
|	Grows the given plex large enough to contain the given number
|	of items.
|
|	Arguments:
|		phppl		plex to reallocate - will change if
|				the plex is grown.
|		iMac		number of items the plex must hold.
|
|	Note:
|		DoJmp(penvMem) if out-of-memory.
----------------------------------------------------------------------------*/
/*<<mcmain*/
#pragma NATIVE_START
ResizePl(phpvPl, iMac, iIns)
VOID HUGE **phpvPl;
int iMac, iIns;
{
	int iMax;
	int cbItem;
	PL HUGE *hppl;
#define phppl ((PL HUGE **)phpvPl)

	hppl = *phppl;
	Assert(!hppl->fUseCount);		// NYI
#ifdef DEBUG
	Assert(FValidPl(hppl));
#endif // DEBUG
	cbItem = hppl->cbItem;
	if (hppl->iMax < iMac)
		{
		iMax = (iMac / (int) hppl->dAlloc + 1) * hppl->dAlloc;
		*phppl = HpplAlloc(cbItem, hppl->dAlloc, iMax,
				0x01<<hppl->dgShift);
#ifdef USECOUNTRESIZE
		(*phppl)->fUseCount = hppl->fUseCount;
#endif		
		if (iIns >= 0)
			{
			bltbh(hppl->rg, (*phppl)->rg, iIns * cbItem);
			bltbh(hppl->rg + iIns * cbItem,
				(*phppl)->rg + (iIns+(iMac-hppl->iMac)) * cbItem,
				(hppl->iMac-iIns) * cbItem);
			}
		else
			bltbh(hppl->rg, (*phppl)->rg, hppl->iMax * cbItem);
		FreeHppl(hppl);
		}
	else if (iIns >= 0)
		{
		bltbh(hppl->rg + iIns * hppl->cbItem,
			hppl->rg + (iIns+(iMac-hppl->iMac)) * cbItem,
			(hppl->iMac-iIns) * cbItem);
		}
	(*phppl)->iMac = iMac;
#ifdef DEBUG
	Assert(FValidPl(*phppl));
#endif // DEBUG
#undef phppl
}
#pragma NATIVE_END
/*<<plex*/


#ifdef MAC
#pragma alloc_text(window, IIncUseCountPl)
#else
#pragma alloc_text(window2, IIncUseCountPl)
#endif
int IIncUseCountPl(hpvPl, i)
VOID HUGE *hpvPl;
int i;
	{
#define hppl ((PL HUGE *)hpvPl)
#ifdef DEBUG
	Assert(FValidPl(hppl));
#endif // DEBUG
	Assert(i < hppl->iMac);
	return ++(*(int HUGE *)&hppl->rg[i*hppl->cbItem]);
#undef hppl
	}

#pragma NATIVE_START
int IDecUseCountPl(hpvPl, i)
VOID HUGE *hpvPl;
int i;
	{
#define hppl ((PL HUGE *)hpvPl)
#ifdef DEBUG
	Assert(FValidPl(hppl));
#endif // DEBUG
	Assert(i < hppl->iMac);
	Assert((*(int HUGE *)&hppl->rg[i*hppl->cbItem]) != 0);
	return --(*(int HUGE *)&hppl->rg[i*hppl->cbItem]);
#undef hppl
	}
#pragma NATIVE_END

int IAddUseCountPl(phpvPl, hpv)
VOID HUGE **phpvPl;
VOID HUGE *hpv;
	{
	BYTE HUGE *hpb;
	int cbItem;
	int i;
	int iMac;
	PL HUGE *hppl;

	hppl = *phpvPl;
#ifdef DEBUG
	Assert(FValidPl(hppl));
#endif // DEBUG
	Assert(hppl->fUseCount);
	cbItem = hppl->cbItem;
	iMac = hppl->iMac;
	// Search for an unused entry
	for (i = 0, hpb = hppl->rg; i < iMac; i++, hpb += cbItem)
		{
		if ((*(int HUGE *) hpb) == 0)
			{
			bltbh(hpv, hpb, cbItem);
			(*(int HUGE *) hpb) = 1;
			return i;
			}
		}
	return IAddPl(phpvPl, hpv);
	}

#ifdef DEBUG
/*----------------------------------------------------------------------------
|	FValidPl
|
|	Checks for a valid PL structure.
|
|	Arguments:
|		hppl		PL to check
|
|	Returns:
|		fTrue if the PL looks reasonable.
----------------------------------------------------------------------------*/
BOOL FValidPl(hpvPl)
VOID HUGE *hpvPl;
{
#define hppl ((PL HUGE *)hpvPl)
	if (SbOfHp(hppl) == sbNull ||
			hppl->cbItem == 0 ||
			hppl->iMac < 0 ||
			hppl->iMax < 0 ||
			hppl->iMax < hppl->iMac)
		return(fFalse);
	return(fTrue);
#undef hppl
}
#endif

/*----------------------------------------------------------------------------
END OF THE CODE FROM EXCEL
----------------------------------------------------------------------------*/
#endif