VOID BMFree ( HMEM hv ) {
#ifdef BMHANDLES // {
CVEnterCritSection(icsBm);
if ( hv < hvCur ) {
hvCur = hv;
}
_ffree ( LpvFromHmem ( hv ) );
LpvFromHmem ( hv ) = NULL;
#ifdef DEBUGVER
LckFromHmem ( hv ) = 0;
#endif
CVLeaveCritSection(icsBm);
#else // } else !BMHANDLES {
_ffree((VOID FAR *)hv);
#endif // }
}
VOID FreeMappings(PMAP Tree)
{
while (Tree != NULL) {
PMAP ToDel = Tree;
Tree = Tree->Next;
if (ToDel->Name != NULL) _ffree(ToDel->Name);
if (ToDel->InputDisplay != NULL) _ffree(ToDel->InputDisplay);
if (ToDel->Replace != NULL) _ffree(ToDel->Replace);
if (ToDel->InputMatch != NULL) _ffree(ToDel->InputMatch);
if (ToDel->ReplaceMap != NULL) _ffree(ToDel->ReplaceMap);
free(ToDel);
}
}
/* -------------------------------------------------------------------- */
void tutorial(char *filename)
{
int i;
char temp[14];
char oldverbose;
outFlag = OUTOK;
setio(whichIO, echo, outFlag);
if (!expert) mPrintf("\n <3J0>ump <3N0>ext <3P0>ause <3S0>top\n");
/* doCR(); */
if (changedir(cfg.helppath) == -1 ) return;
/* no bad files */
if (checkfilename(filename, 0) == ERROR)
{
mPrintf(" No helpfile %s", filename);
changedir(cfg.homepath);
return;
}
if (ambig(filename))
{
/* fill our directory array according to filename */
oldverbose = verbose;
verbose = FALSE;
filldirectory(filename);
verbose = oldverbose;
/* print out all the files */
for (i = 0; filedir[i].entry[0] &&
( dumpf(filedir[i].entry) != ERROR) ; i++);
if ( !i) mPrintf(" No helpfile %s", filename);
/* free file directory structure */
if(filedir != NULL)
_ffree((void *)filedir);
}
else
{
strcpy(temp, filename);
temp[strlen(temp)-1] = '@';
if (filexists(temp) && *term.bold)
dump(temp);
else
dumpf(filename);
}
/* go to our home-path */
changedir(cfg.homepath);
}
void convert_rdbuf_free(void) {
if (convert_rdbuf.buffer != NULL) {
#if TARGET_MSDOS == 32 || defined(LINUX)
free(convert_rdbuf.buffer - BOUNDS_ADJUST);
#else
_ffree(convert_rdbuf.buffer - BOUNDS_ADJUST);
#endif
convert_rdbuf.buffer = NULL;
convert_rdbuf.len = 0;
convert_rdbuf.pos = 0;
}
}
static void StartPopupMenu(void)
{
if (!nMenuItems) {
nMenuItemHght = GetSystemMetrics(SM_CYMENU);
nMenuHeight = GetSystemMetrics(SM_CYSCREEN);
#if defined(WIN32)
++nMenuItemHght;
#else
if (WinVersion >= MAKEWORD(95,3)) {
nMenuItemHght += 2;
nMenuHeight -= 10;
}
#endif
}
while (PopupInUse > 0) _ffree(PopupList[--PopupInUse]);
if (PopupAllocated) {
_ffree(PopupList);
PopupAllocated = 0;
}
nMenuItems = MaxLen = 0;
}
static void AppendMenuItemW(INT MenuGroup, PWSTR pString)
{ LPPOPUPLIST NewItem;
if (PopupInUse+1 /*NULL element at end*/ >= PopupAllocated) {
LPLPPOPUPLIST np;
if ((np = _fcalloc(PopupAllocated+100, sizeof(LPPOPUPLIST))) == NULL)
return;
if (PopupInUse) {
_fmemcpy(np, PopupList, PopupInUse*sizeof(LPPOPUPLIST));
_ffree(PopupList);
}
PopupList = np;
PopupAllocated += 100;
}
NewItem = _fcalloc(1, sizeof(POPUPLIST) + wcslen(pString)*sizeof(WCHAR));
if (NewItem != NULL) {
int i;
wcscpy(NewItem->Name, pString);
if ((i = wcslen(pString)) > MaxLen) MaxLen = i;
NewItem->MenuGroup = (BYTE)MenuGroup;
/*binary array search...*/
{ int i, d;
if (PopupInUse) {
BOOL Less;
for (d=PopupInUse-1; d & (d-1); d &= d-1);
/*d = largest power of 2 less than PopupInUse*/
i = d;
if (i) i += i-1;
for (;;) {
Less = i < PopupInUse
&& ( PopupList[i]->MenuGroup < MenuGroup ||
(PopupList[i]->MenuGroup == MenuGroup
&& lstrcmpiW(PopupList[i]->Name, pString) < 0));
if (Less) i += d;
else i -= d;
if (!d) break;
d >>= 1;
}
if (Less) ++i;
} else i = 0;
if (i < PopupInUse)
_fmemmove(PopupList+i+1, PopupList+i,
(PopupInUse-i)*sizeof(LPPOPUPLIST));
assert(i >= 0);
assert(i < PopupAllocated);
++PopupInUse;
PopupList[i] = NewItem;
}
void DIR_ReleaseAll(void)
{
struct DIR_rec speicher;
size_t laenge;
while (DIR_eintraege>0)
{
laenge=sizeof(speicher);
_fmemmove((void _far*)&speicher,DIR_top,laenge);
_ffree(DIR_top);
DIR_top=speicher.vorher;
DIR_eintraege--;
}
}
/******************************************************************************
** Restore a screen rectangle defined by (sx,sy):(dx,dy) from a memory buffer.
** The memory buffer is free'd here.
*/
VOID NWGFXRestoreRect(NWGPOS iSX, NWGPOS iSY, NWGPOS iDX, NWGPOS iDY, NWGFARBUF lpBuffer)
{
NWGSCNPTR lpScreen; /* Pointer to screen. */
NWGNUM iWidth, iHeight; /* Blit dimensions. */
NWGNUM iOffset; /* Next raster line offset. */
NWGNUM iTmpWidth; /* Temporary width counter. */
#ifdef DEBUG
/* Check we have a valid screen address. */
if (!lpScnOrigin)
{
printf("NWGFXRestoreRect(): Screen uninitialised.\n");
exit(1);
}
/* Validate rectangle corners. */
if ( (iSX < 0) || (iSX >= iScnWidth) || (iDX < 0) || (iDX >= iScnWidth) ||
(iSY < 0) || (iSY >= iScnHeight) || (iDY < 0) || (iDY >= iScnHeight) )
{
NWGFXSetCursorPos(0, 0);
printf("NWGFXRestoreRect(): Attempt to blit an area outside of the screen.");
return;
}
#endif
/* Calculate blit origin, dimensions and next raster line offset. */
lpScreen = lpScnOrigin + ( (iScnWidth * 2 * iSY) + (iSX * 2) );
iWidth = (iDX - iSX + 1) * 2;
iHeight = iDY - iSY + 1;
iOffset = (iScnWidth * 2) - iWidth;
/* Perfom the blit. */
while(iHeight--)
{
/* Fetch the line width in bytes. */
iTmpWidth = iWidth;
/* Blit a line. */
while(iTmpWidth--)
*lpScreen++ = *lpBuffer++;
/* Move to next line. */
lpScreen += iOffset;
}
/* Free far memory buffer. */
_ffree(lpBuffer);
}
void DisableUndo(void)
{
while (FirstUndo) {
LastUndo = FirstUndo->Next;
if (FirstUndo->Flags&UD_GLOBALMEM && FirstUndo->DelMem)
GlobalFree(FirstUndo->DelMem);
_ffree(FirstUndo);
FirstUndo = LastUndo;
}
FirstUndo = LastUndo = NextSequenceUndo = NULL;
EnableToolButton(IDB_UNDO, FALSE);
UndoSequences = 0;
UndoMemUsed = 0;
Redoing = FALSE;
SetSafeForUndo(FALSE);
}
void StartUndoSequence(void)
{
if (ViewOnlyFlag) return;
if (!(GlobalUndoFlags & UD_BYUNDO) && Redoing) {
Redoing = FALSE;
if (LastUndo!=NULL && LastUndo->UndoRef!=NULL)
NextSequenceUndo = LastUndo->UndoRef;
}
if (StartWithRemove) CheckForUndoneToRelease(FALSE);
if (UndoLimit!=(ULONG)-1 && UndoMemUsed>UndoLimit && FirstUndo!=NULL) {
do {
do {
LPUNDO ToDelete = FirstUndo;
if ((FirstUndo = FirstUndo->Next) == NULL) {
LastUndo = NextSequenceUndo = NULL;
UndoSequences = 1;
}
if (ToDelete->DelFill) {
if (ToDelete->Flags & UD_GLOBALMEM) {
UndoMemUsed -= GlobalSize(ToDelete->DelMem);
GlobalFree(ToDelete->DelMem);
} else UndoMemUsed -= ToDelete->DelFill;
}
UndoMemUsed -= sizeof(UNDO);
_ffree(ToDelete);
} while (FirstUndo && !(FirstUndo->Flags & UD_NEWOP));
} while (FirstUndo!=NULL && UndoMemUsed>UndoLimit);
--UndoSequences;
if (FirstUndo) FirstUndo->Prev = NULL;
}
if (!LastUndo || !(LastUndo->Flags & UD_NEWOP)
|| LastUndo->Pos != (ULONG)-1) {
if (!NewUndo()) {
NextSequenceUndo = NULL;
return;
}
++UndoSequences;
}
LastUndo->Flags |= UD_NEWOP | GlobalUndoFlags;
GlobalUndoFlags &= UD_BYUNDO;
NextSequenceUndo = LastUndo;
}
/* ******************************************************************** */
void _ks_free(PFBYTE ptr, int num_elements, int size)
{
#if (DISPLAY_MALLOC)
DEBUG_ERROR("ks_free returns: ", DINT1, ptr, 0);
#endif
# if (defined (RTKBCPP))
/* Was done by ks_dpmi_release_all(); */
ARGSUSED_PVOID(ptr)
ARGSUSED_INT(num_elements)
ARGSUSED_INT(size)
# elif (INCLUDE_BGET)
ARGSUSED_INT(num_elements)
ARGSUSED_INT(size)
brel(ptr);
# elif (INCLUDE_WINSOCK || INCLUDE_BSDSOCK)
ARGSUSED_INT(num_elements);
ARGSUSED_INT(size);
free(ptr);
# elif (defined(SEG_IAR))
/* protected mode */
ARGSUSED_INT(num_elements);
ARGSUSED_INT(size);
free(ptr);
# elif ( defined(__BORLANDC__) ) /* real mode */
ARGSUSED_INT(num_elements);
ARGSUSED_INT(size);
_ffree(ptr);
# else
#error: ks_free needs to be implemented
# endif
}
void CheckForUndoneToRelease(BOOL EnterNewOp)
{
if (LastUndo != NextSequenceUndo) {
while (LastUndo!=NULL && LastUndo!=NextSequenceUndo) {
LPUNDO ToDelete = LastUndo;
if (LastUndo->Flags & UD_NEWOP && UndoSequences) --UndoSequences;
LastUndo = LastUndo->Prev;
if (ToDelete->DelFill) {
if (ToDelete->Flags & UD_GLOBALMEM) {
UndoMemUsed -= GlobalSize(ToDelete->DelMem);
GlobalFree(ToDelete->DelMem);
} else UndoMemUsed -= ToDelete->DelFill;
}
UndoMemUsed -= sizeof(UNDO);
_ffree(ToDelete);
}
if (LastUndo != NULL) LastUndo->Next = NULL;
else FirstUndo = NULL;
NextSequenceUndo = LastUndo;
if (EnterNewOp) StartUndoSequence();
}
}
HMEM BMRealloc ( HMEM hv, UINT cb ) {
#ifdef BMHANDLES // {
LPV lpv;
UINT cbOld;
CVEnterCritSection(icsBm);
lpv = LpvFromHmem ( hv );
assert ( LPV );
cbOld = _fmsize ( LPV );
if ( cbOld != cb ) {
LPV lpvNew = _fmalloc ( cb );
if ( LPV && lpvNew) {
_fmemcpy ( lpvNew, lpv, min ( cb, cbOld ) );
_ffree ( LPV );
LpvFromHmem ( hv ) = lpvNew;
}
else {
hv = hmemNull;
}
}
CVLeaveCritSection(icsBm);
return hv;
#else // } else !BMHANDLES {
return (HMEM) _frealloc((VOID FAR *)hv, cb);
#endif // }
}
void my_free( void FAR_PTR *chunk )
{
_ffree( chunk );
}
BOOL DoDeleteSectors(DWORD dwStart, DWORD dwSize ,BYTE btDisk)
{
BYTE *pBuf;
int i;
BOOL bVerify = FALSE;
pBuf = NULL;
pBuf = (BYTE *) _fmalloc(DATA_BUFFER_SIZE);
if(!pBuf)
{
ErrorMessageBox(NO_MEMORY);
return FALSE;
}
switch(g_nMethod)
{
case 0:
g_dTotalSize = dwSize;
InitDelBuf(pBuf,0,0,0,FALSE,TRUE);
bVerify = TRUE;
WriteSecsWithBuf(dwStart,dwSize,btDisk,pBuf,bVerify);
break;
case 1:
g_dTotalSize = dwSize;
InitDelBuf(pBuf,0xFF,0,0,FALSE,TRUE);
bVerify = TRUE;
WriteSecsWithBuf(dwStart,dwSize,btDisk,pBuf,bVerify);
break;
case 2:
g_dTotalSize = dwSize;
InitDelBuf(pBuf,0,0,0,TRUE,TRUE);
bVerify = TRUE;
WriteSecsWithBuf(dwStart,dwSize,btDisk,pBuf,bVerify);
break;
case 3:
g_dTotalSize = (double)dwSize*3;
for(i=0; i<3; i++)
{
switch(i)
{
case 0:
case 1:
InitDelBuf(pBuf,0,0,0,TRUE,TRUE);
break;
case 2:
bVerify = TRUE;
InitDelBuf(pBuf,0,0,0,FALSE,TRUE);
break;
}
if(!WriteSecsWithBuf(dwStart,dwSize,btDisk,pBuf,bVerify))
break;
}
break;
case 4:
g_dTotalSize = (double)dwSize*4;
for(i=0; i<4; i++)
{
switch(i)
{
case 0:
case 2:
InitDelBuf(pBuf,0,0,0,FALSE,TRUE);
break;
case 1:
InitDelBuf(pBuf,0XFF,0,0,FALSE,TRUE);
break;
case 3:
bVerify = TRUE;
InitDelBuf(pBuf,0XFF,0,0,FALSE,TRUE);
break;
}
if(!WriteSecsWithBuf(dwStart,dwSize,btDisk,pBuf,bVerify))
break;
}
break;
case 5:
g_dTotalSize = (double)dwSize*3;
for(i=0; i<3; i++)
{
switch(i)
{
case 0:
InitDelBuf(pBuf,0,0,0,FALSE,TRUE);
break;
case 1:
InitDelBuf(pBuf,0XFF,0,0,FALSE,TRUE);
break;
case 2:
bVerify = TRUE;
InitDelBuf(pBuf,0X35,0XCA,0X97,FALSE,FALSE);
break;
}
if(!WriteSecsWithBuf(dwStart,dwSize,btDisk,pBuf,bVerify))
break;
}
break;
case 6:
g_dTotalSize = (double)dwSize*7;
for(i=0; i<7; i++)
{
switch(i)
{
case 0:
case 2:
case 4:
InitDelBuf(pBuf,0,0,0,FALSE,TRUE);
break;
case 1:
case 3:
case 5:
InitDelBuf(pBuf,0XFF,0,0,FALSE,TRUE);
break;
case 6:
bVerify = TRUE;
InitDelBuf(pBuf,0X35,0XCA,0X97,FALSE,FALSE);
break;
}
if(!WriteSecsWithBuf(dwStart,dwSize,btDisk,pBuf,bVerify))
break;
}
break;
case 7:
g_dTotalSize = (double)dwSize*35;
for(i=0; i<35; i++)
{
switch(i)
{
case 0:
case 1:
case 2:
case 3:
case 31:
case 32:
case 33:
InitDelBuf(pBuf,0,0,0,TRUE,TRUE);
break;
case 34:
bVerify = TRUE;
InitDelBuf(pBuf,0,0,0,TRUE,TRUE);
break;
case 4:
InitDelBuf(pBuf,0X55,0,0,FALSE,TRUE);
break;
case 5:
InitDelBuf(pBuf,0XAA,0,0,FALSE,TRUE);
break;
case 6:
case 25:
InitDelBuf(pBuf,0X92,0X49,0X24,FALSE,FALSE);
break;
case 7:
case 26:
InitDelBuf(pBuf,0X49,0X24,0X92,FALSE,FALSE);
break;
case 8:
case 27:
InitDelBuf(pBuf,0X24,0X92,0X49,FALSE,FALSE);
break;
case 9:
InitDelBuf(pBuf,0,0,0,FALSE,TRUE);
break;
case 10:
InitDelBuf(pBuf,0X11,0,0,FALSE,TRUE);
break;
case 11:
InitDelBuf(pBuf,0X22,0,0,FALSE,TRUE);
break;
case 12:
InitDelBuf(pBuf,0X33,0,0,FALSE,TRUE);
break;
case 13:
InitDelBuf(pBuf,0X44,0,0,FALSE,TRUE);
break;
case 14:
InitDelBuf(pBuf,0X55,0,0,FALSE,TRUE);
break;
case 15:
InitDelBuf(pBuf,0X66,0,0,FALSE,TRUE);
break;
case 16:
InitDelBuf(pBuf,0x77,0,0,FALSE,TRUE);
break;
case 17:
InitDelBuf(pBuf,0X88,0,0,FALSE,TRUE);
break;
case 18:
InitDelBuf(pBuf,0X99,0,0,FALSE,TRUE);
break;
case 19:
InitDelBuf(pBuf,0XAA,0,0,FALSE,TRUE);
break;
case 20:
InitDelBuf(pBuf,0XBB,0,0,FALSE,TRUE);
break;
case 21:
InitDelBuf(pBuf,0XCC,0,0,FALSE,TRUE);
break;
case 22:
InitDelBuf(pBuf,0XDD,0,0,FALSE,TRUE);
break;
case 23:
InitDelBuf(pBuf,0XEE,0,0,FALSE,TRUE);
break;
case 24:
InitDelBuf(pBuf,0XFF,0,0,FALSE,TRUE);
break;
case 28:
InitDelBuf(pBuf,0X6D,0XB6,0XDB,FALSE,FALSE);
break;
case 29:
InitDelBuf(pBuf,0XB6,0XDB,0X6D,FALSE,FALSE);
break;
case 30:
InitDelBuf(pBuf,0XDB,0X6D,0XB6,FALSE,FALSE);
break;
}
if(!WriteSecsWithBuf(dwStart,dwSize,btDisk,pBuf,bVerify))
break;
}
break;
}
_ffree(pBuf);
return TRUE;
}
VOID PMfrWriteClipbrdBmp(HAB hab)
{
HDC hdcClip; /* memory DC and PS to extract from the clipboard */
HPS hpsClip;
HBITMAP hbmClip;
SIZEL sizl;
BITMAPINFOHEADER bmp;
ULONG _far *alRGBColors;
LONG errorcode;
char _far *fp1;
char _far *fp2;
int i;
if (WinOpenClipbrd(hab))
{
/* get the memory DC and PS to copy the bitmap */
hdcClip = DevOpenDC (hab, OD_MEMORY, "*", 0L, NULL, NULL) ;
sizl.cx = cp.cx; sizl.cy = cp.cy;
hpsClip = GpiCreatePS (hab, hdcClip, &sizl,
PU_PELS | GPIF_DEFAULT | GPIT_MICRO | GPIA_ASSOC);
bmp.cbFix = sizeof bmp;
bmp.cx = cp.cx;
bmp.cy = cp.cy;
bmp.cPlanes = cp.cPlanes;
bmp.cBitCount = cp.cBitCount;
hbmClip = GpiCreateBitmap (hpsClip, &bmp, 0L, NULL, NULL);
GpiSetBitmap(hpsClip, hbmClip);
/* initialize and black out the bitmap */
alRGBColors = (ULONG _far *) _fmalloc(sizeof(ULONG) * cp.colors);
/* beginning of source array */
fp2 = (char _far *) &cp.pbmiMemory->argbColor[0];
/* beginning of dest array */
fp1 = (char _far *) &alRGBColors[0];
for (i = 0; i < cp.colors; i++)
{ /* copy base bytes for number of screen colors */
alRGBColors[i] = 0;
_fmemcpy(fp1, fp2, sizeof(RGB) );
fp1 += sizeof(ULONG);
fp2 += sizeof(RGB);
}
GpiSetMix ( hpsClip, FM_OVERPAINT) ;
GpiSetBackMix (hpsClip, BM_LEAVEALONE) ;
GpiCreateLogColorTable(hpsClip, LCOL_RESET | LCOL_REALIZABLE,
LCOLF_CONSECRGB, 0L, cp.colors, alRGBColors);
/* now copy the bits */
cp.pbmiMemory->cx = cp.cx;
cp.pbmiMemory->cy = cp.cy;
cp.pbmiMemory->cPlanes = cp.cPlanes;
cp.pbmiMemory->cBitCount = cp.cBitCount;
errorcode = GpiSetBitmapBits(hpsClip, 0L, (LONG) cp.cy,
cp.pixels, cp.pbmiMemory);
/* unlink the new bitmap */
GpiSetBitmap(hpsClip, (HBITMAP) NULL);
/* write to the clipboard */
WinEmptyClipbrd (hab);
WinSetClipbrdData (hab, (ULONG) hbmClip, CF_BITMAP, CFI_HANDLE);
/* now clean up */
_ffree(alRGBColors);
GpiDestroyPS(hpsClip);
DevCloseDC(hdcClip);
WinCloseClipbrd(hab);
}
}
int GptWriteHeader(HGPT hGPT)
{
int i;
int iErr;
char far *lpArray = (char far *)NULL;
char far *lpc;
int iEntryArraySize;
int nSect;
QWORD qwLBA;
#ifdef _DEBUG
if (iDebug) printf("GptWriteHeader(hBlockDev=%p)\n", hGPT->hBlockDev);
#endif
// Compute the entire entry array CRC, and update the header.
iEntryArraySize = (int)(hGPT->pGptHdr->NumberOfPartitionEntries) * sizeof(EFI_PARTITION_ENTRY);
nSect = (iEntryArraySize + hGPT->iSectorSize - 1) / hGPT->iSectorSize;
lpArray = (char far *)_fmalloc(nSect * hGPT->iSectorSize);
if (!lpArray) GptWriteHeaderFail(1);
for (lpc=lpArray, i=0, qwLBA=hGPT->pGptHdr->PartitionEntryLBA; i<nSect; i++, lpc+=hGPT->iSectorSize, qwLBA++)
{
iErr = GptBlockRead(hGPT, qwLBA, 1, lpc);
if (iErr) GptWriteHeaderFail(2);
}
hGPT->pGptHdr->PartitionEntryArrayCRC32 = crc32(lpArray, iEntryArraySize);
// Write the backup GPT header
// Exchange the main and alternate LBA addresses.
qwLBA = hGPT->pGptHdr->AlternateLBA;
hGPT->pGptHdr->AlternateLBA = hGPT->pGptHdr->MyLBA;
hGPT->pGptHdr->MyLBA = qwLBA;
// Update the header CRC
SetCrc(&(hGPT->pGptHdr->Header));
// Write the backup GPT header
iErr = GptBlockWrite(hGPT, hGPT->pGptHdr->MyLBA, 1, hGPT->pGptHdr);
if (iErr)
{
#ifdef _DEBUG
if (iVerbose) printf("Error %d writing the GPT backup header.\n", iErr);
#endif
GptWriteHeaderFail(3);
}
// Write the main GPT header
// Exchange the main and alternate LBA addresses.
qwLBA = hGPT->pGptHdr->AlternateLBA;
hGPT->pGptHdr->AlternateLBA = hGPT->pGptHdr->MyLBA;
hGPT->pGptHdr->MyLBA = qwLBA;
// Update the header CRC
SetCrc(&(hGPT->pGptHdr->Header));
#ifdef _DEBUG
if (iVerbose) DumpBuf(hGPT->pGptHdr, 0, (WORD)hGPT->pGptHdr->Header.HeaderSize);
#endif
// Write the main GPT header
iErr = GptBlockWrite(hGPT, hGPT->pGptHdr->MyLBA, 1, hGPT->pGptHdr);
if (iErr)
{
#ifdef _DEBUG
if (iVerbose) printf("Error %d writing the GPT header.\n", iErr);
#endif
GptWriteHeaderFail(4);
}
header_return:
_ffree(lpArray);
return iErr;
}
VOID NEAR OutputFuncs
(
ICreateTypeInfo FAR* lpdtinfo,
LPENTRY pEntry,
LPFUNC pFuncList,
TYPEKIND tkind
)
{
LPFUNC pFunc;
LPELEM pArg;
HRESULT res;
UINT iFunc = 0; // function index
LPOLESTR lpszDllName;
LPSTR lpszProcName;
SHORT i;
FUNCDESC FuncDesc;
LPOLESTR FAR* lplpszArgName;
if (pFuncList == NULL) // just return if no functions to output
return;
FuncDesc.lprgelemdescParam = rgFuncArgs; // set up array of args
pFunc = (LPFUNC)ListFirst(pFuncList); // point to first entry
#if FV_UNICODE_OLE
lpszDllName = (pEntry->attr.fAttr & fDLLNAME ? ToNewW(pEntry->attr.lpszDllName) : NULL);
#else
lpszDllName = pEntry->attr.lpszDllName;
#endif
for (;;)
{
// Fill in the FUNCDESC structure with the function's info
// set up funckind
switch (tkind) {
case TKIND_MODULE:
FuncDesc.funckind = FUNC_STATIC;
break;
case TKIND_INTERFACE:
FuncDesc.funckind = FUNC_PUREVIRTUAL;
break;
case TKIND_DISPATCH:
FuncDesc.funckind = FUNC_DISPATCH;
break;
default:
Assert(FALSE);
}
// set up invkind
FuncDesc.invkind = INVOKE_FUNC; // default
if (pFunc->func.attr.fAttr & fPROPGET)
FuncDesc.invkind = INVOKE_PROPERTYGET;
else if (pFunc->func.attr.fAttr & fPROPPUT)
FuncDesc.invkind = INVOKE_PROPERTYPUT;
else if (pFunc->func.attr.fAttr & fPROPPUTREF)
FuncDesc.invkind = INVOKE_PROPERTYPUTREF;
// set up callconv
if (pFunc->func.attr.fAttr2 & f2PASCAL)
// CC_MACPASCAL if /mac specified, CC_MSCPASCAL otherwise
FuncDesc.callconv = (CALLCONV)(SysKind == SYS_MAC ? CC_MACPASCAL: CC_MSCPASCAL);
else if (pFunc->func.attr.fAttr2 & f2CDECL)
FuncDesc.callconv = CC_CDECL;
else if (pFunc->func.attr.fAttr2 & f2STDCALL)
FuncDesc.callconv = CC_STDCALL;
#ifdef DEBUG
else Assert(FALSE);
#endif //DEBUG
FuncDesc.wFuncFlags = 0;
if (pFunc->func.attr.fAttr & fRESTRICTED)
FuncDesc.wFuncFlags |= (WORD)FUNCFLAG_FRESTRICTED;
if (pFunc->func.attr.fAttr & fSOURCE)
FuncDesc.wFuncFlags |= (WORD)FUNCFLAG_FSOURCE;
if (pFunc->func.attr.fAttr & fBINDABLE)
FuncDesc.wFuncFlags |= (WORD)FUNCFLAG_FBINDABLE;
if (pFunc->func.attr.fAttr & fREQUESTEDIT)
FuncDesc.wFuncFlags |= (WORD)FUNCFLAG_FREQUESTEDIT;
if (pFunc->func.attr.fAttr & fDISPLAYBIND)
FuncDesc.wFuncFlags |= (WORD)FUNCFLAG_FDISPLAYBIND;
if (pFunc->func.attr.fAttr & fDEFAULTBIND)
FuncDesc.wFuncFlags |= (WORD)FUNCFLAG_FDEFAULTBIND;
if (pFunc->func.attr.fAttr & fHIDDEN)
FuncDesc.wFuncFlags |= (WORD)FUNCFLAG_FHIDDEN;
// set up cParams & cParamsOpt
FuncDesc.cParams = pFunc->cArgs;
FuncDesc.cParamsOpt = pFunc->cOptArgs;
//NOTE: cParamsOpt can be set to -1, to note that last parm is a
//NOTE: [safe] array of variant args. This corresponds to the
//NOTE: 'vararg' attribute in the input description. If this was
//NOTE: specified, the parser set pFunc->cOptArgs to -1 for us.
// set up misc unused stuff
FuncDesc.oVft = 0; // only used for FUNC_VIRTUAL
FuncDesc.cScodes = -1; // list of SCODEs unknown
FuncDesc.lprgscode = NULL;
// set id field if 'id' attribute specified
if (pFunc->func.attr.fAttr & fID)
FuncDesc.memid = pFunc->func.attr.lId;
else
FuncDesc.memid = DISPID_UNKNOWN;
// set up elemdescFunc
// Contains the ID, name, and return type of the function
LoadElemDesc(lpdtinfo, &(FuncDesc.elemdescFunc), &pFunc->func);
// save function name
lplpszArgName = rgszFuncArgNames;
*lplpszArgName++ = ToNewW(pFunc->func.szElemName);
SETITEMCUR(pFunc->func.szElemName);
// set up the lprgelemdescParam array of info for each parameter
pArg = pFunc->argList; // point to last arg, if any
for (i = 0; i < pFunc->cArgs; i++)
{
pArg = pArg->pNext; // point to next arg (first arg
// first time through loop)
LoadElemDesc(lpdtinfo, &(FuncDesc.lprgelemdescParam[i]), pArg);
*lplpszArgName++ = ToNewW(pArg->szElemName); // save arg name
}
// Define the function item:
CHECKRESULT(lpdtinfo->AddFuncDesc(iFunc, &FuncDesc));
// set the names of the function and the parameters
Assert(i == pFunc->cArgs);
// don't set the name of the last param for proput/putref functions
if (pFunc->func.attr.fAttr & (fPROPPUT | fPROPPUTREF)) {
i--;
}
CHECKRESULT(lpdtinfo->SetFuncAndParamNames(iFunc, rgszFuncArgNames, i+1));
#if FV_UNICODE_OLE
// free the unicode function & param names
lplpszArgName = rgszFuncArgNames;
for (i = 0; i <= pFunc->cArgs; i++) {
_ffree(*lplpszArgName); // done with unicode name
lplpszArgName++;
}
#endif //FV_UNICODE_OLE
// Set the function item's remaining attributes:
if (pFunc->func.attr.fAttr & fHELPSTRING)
CHECKRESULT(lpdtinfo->SetFuncDocString(iFunc, ToW(pFunc->func.attr.lpszHelpString)));
if (pFunc->func.attr.fAttr & fHELPCONTEXT)
CHECKRESULT(lpdtinfo->SetFuncHelpContext(iFunc, pFunc->func.attr.lHelpContext));
// Handle case of a DLL entrypoint
if (pFunc->func.attr.fAttr & fENTRY)
{
// If high word of name is zero, then call by ordnal
// If high word of name is non-zero, then call by name
// (same as GetProcAddress)
lpszProcName = pFunc->func.attr.lpszProcName;
#if FV_UNICODE_OLE
if (HIWORD(lpszProcName)) {
lpszProcName = (LPSTR)ToW(lpszProcName);
}
#endif //FV_UNICODE_OLE
CHECKRESULT(lpdtinfo->DefineFuncAsDllEntry(iFunc, lpszDllName, (LPOLESTR)lpszProcName));
}
// advance to next entry if not all done
if (pFunc == (LPFUNC)ListLast(pFuncList))
break; // exit if all done
pFunc = (LPFUNC)pFunc->func.pNext;
iFunc++; // advance function counter
}
#if FV_UNICODE_OLE
if (lpszDllName)
_ffree(lpszDllName); // done with unicode name
#endif //FV_UNICODE_OLE
}
// For each library entry, creates a typeinfo in the typelib,
// and fills it in.
VOID NEAR OutputTypeInfos
(
ICreateTypeLib FAR * lpdtlib
)
{
LPENTRY pEntry;
TYPEKIND tkind;
HRESULT res;
ICreateTypeInfo FAR* lpdtinfo;
WORD wTypeFlags;
// First allocate an array of ELEMDESCs to hold the max # of
// args of any function we need to describe.
rgFuncArgs = (ELEMDESC FAR*)_fmalloc(cArgsMax * sizeof(ELEMDESC));
rgszFuncArgNames = (LPOLESTR FAR *)_fmalloc((cArgsMax+1) * sizeof(LPOLESTR));
if (rgFuncArgs == NULL || rgszFuncArgNames == NULL)
ParseError(ERR_OM);
// pass 1 -- create the typeinfo's
pEntry = (LPENTRY)ListFirst(typlib.pEntry); // point to first entry
for (;;)
{
// determine if we are going to create a typeinfo for this guy
switch (pEntry->type.tentrykind)
{
case tTYPEDEF:
if (pEntry->attr.fAttr) // create lpdtinfo only if
break; // this is a 'PUBLIC' typedef
NoTypeInfos:
pEntry->lpdtinfo = NULL; // no lpdtinfo for this
case tREF: // no typeinfo's made for these
case tINTRINSIC:
goto Next_Entry1;
default:
// no typeinfo's made for forward declarations
if (pEntry->type.tentrykind & tFORWARD)
goto NoTypeInfos;
if (pEntry->type.tentrykind & tIMPORTED)
goto Next_Entry1; // nothing for imported types
break;
}
// 1. determine kind of typeinfo to create
tkind = rgtkind[pEntry->type.tentrykind];
// 2. Create type library entry (TypeInfo) of a given name/and
// type, getting a pointer to the ICreateTypeInfo interface
SETITEMCUR(pEntry->type.szName);
CHECKRESULT(lpdtlib->CreateTypeInfo(ToW(pEntry->type.szName), tkind, &lpdtinfo));
pEntry->lpdtinfo = lpdtinfo;
// 3. Set the item's attributes:
if (pEntry->attr.fAttr & fUUID)
CHECKRESULT(lpdtinfo->SetGuid(*pEntry->attr.lpUuid));
if (pEntry->attr.fAttr & fHELPSTRING)
CHECKRESULT(lpdtinfo->SetDocString(ToW(pEntry->attr.lpszHelpString)));
if (pEntry->attr.fAttr & fHELPCONTEXT)
CHECKRESULT(lpdtinfo->SetHelpContext(pEntry->attr.lHelpContext));
if (pEntry->attr.fAttr & fVERSION)
CHECKRESULT(lpdtinfo->SetVersion(pEntry->attr.wVerMajor, pEntry->attr.wVerMinor));
// 4. save lptinfo for this guy in case somebody references it
CHECKRESULT(lpdtinfo->QueryInterface(IID_ITypeInfo, (VOID FAR* FAR*)&pEntry->type.lptinfo));
// if this type has a forward declaration
if (pEntry->lpEntryForward)
{
// copy "real" type info over top of forward declaration,
// because folks have pointers to the forward declaration
pEntry->lpEntryForward->type.tdesc = pEntry->type.tdesc;
pEntry->lpEntryForward->type.lptinfo = pEntry->type.lptinfo;
// Only need to copy these 2 fields from the type (the
// others aren't referenced at type creation time.
}
Next_Entry1:
// advance to next entry if not all done
if (pEntry == (LPENTRY)ListLast(typlib.pEntry))
break; // exit if all done
pEntry = (LPENTRY)pEntry->type.pNext;
}
// pass 2 -- process each entry
pEntry = (LPENTRY)ListFirst(typlib.pEntry); // point to first entry
for (;;)
{
// 1. Get our lpdtinfo again if we have one
switch (pEntry->type.tentrykind)
{
case tREF:
case tINTRINSIC:
goto Next_Entry2; // these guys don't have lpdtinfo field
default:
if (pEntry->type.tentrykind & tIMPORTED)
goto Next_Entry2; // no lpdtinfo field
break;
}
lpdtinfo = pEntry->lpdtinfo;
if (lpdtinfo == NULL) // skip if no lpdtinfo created
goto Next_Entry2; // (forward decl or non-public typedef)
// set up for error reporting
SETITEMCUR(pEntry->type.szName);
// 2. determine kind of typeinfo we're dealing with
tkind = rgtkind[pEntry->type.tentrykind];
// 2a. Set the typeinfo flags
wTypeFlags = 0;
if (tkind == TKIND_COCLASS) {
// COCLASSs always have FCANCREATE bit set
wTypeFlags |= TYPEFLAG_FCANCREATE;
// these are only valid on COCLASSs
if (pEntry->attr.fAttr & fAPPOBJECT)
wTypeFlags |= (WORD)TYPEFLAG_FAPPOBJECT;
if (pEntry->attr.fAttr & fLICENSED)
wTypeFlags |= (WORD)TYPEFLAG_FLICENSED;
if (pEntry->attr.fAttr & fPREDECLID)
wTypeFlags |= (WORD)TYPEFLAG_FPREDECLID;
}
if (pEntry->attr.fAttr & fHIDDEN)
wTypeFlags |= (WORD)TYPEFLAG_FHIDDEN;
if (pEntry->attr.fAttr2 & f2CONTROL)
wTypeFlags |= (WORD)TYPEFLAG_FCONTROL;
if (pEntry->attr.fAttr2 & f2NONEXTENSIBLE)
wTypeFlags |= (WORD)TYPEFLAG_FNONEXTENSIBLE;
if (pEntry->attr.fAttr2 & f2DUAL) // DUAL implies OLEAUTOMATION
wTypeFlags |= (WORD)(TYPEFLAG_FDUAL | TYPEFLAG_FOLEAUTOMATION);
if (pEntry->attr.fAttr2 & f2OLEAUTOMATION)
wTypeFlags |= (WORD)TYPEFLAG_FOLEAUTOMATION;
CHECKRESULT(lpdtinfo->SetTypeFlags(wTypeFlags));
// 3. now process each kind of entry
switch (tkind)
{
case TKIND_ALIAS:
OutputAlias(lpdtinfo, pEntry->type.td.ptypeAlias);
break;
case TKIND_RECORD: // struct's, enum's, and union's are
case TKIND_ENUM: // all very similar
case TKIND_UNION:
OutputElems(lpdtinfo, pEntry->type.structenum.elemList, tkind);
break;
case TKIND_MODULE:
OutputFuncs(lpdtinfo, pEntry, pEntry->module.funcList, tkind);
OutputElems(lpdtinfo, pEntry->module.constList, tkind);
break;
case TKIND_INTERFACE:
OutputInterface(lpdtinfo, pEntry);
break;
case TKIND_DISPATCH:
OutputDispinter(lpdtinfo, pEntry);
break;
case TKIND_COCLASS:
OutputClass(lpdtinfo, pEntry);
break;
#if FV_PROPSET
case TKIND_PROPSET:
// CONSIDER: (FV_PROPSET) do something with base_propset name
OutputElems(lpdtinfo, pEntry->propset.propList, tkind);
break;
#endif //FV_PROPSET
default:
Assert(FALSE);
};
// 3a. Set the alignment for this TypeInfo. Must be done before
// Layout().
CHECKRESULT(lpdtinfo->SetAlignment(iAlignMax));
// 4. Compile this typeinfo we've just created.
SETITEMCUR(pEntry->type.szName);
CHECKRESULT(lpdtinfo->LayOut());
// 5. Cleanup. All done with lpdtinfo.
lpdtinfo->Release();
Next_Entry2:
// advance to next entry if not all done
if (pEntry == (LPENTRY)ListLast(typlib.pEntry))
break; // exit if all done
pEntry = (LPENTRY)pEntry->type.pNext;
}
// now clean up everything else
_ffree(rgFuncArgs); // done with function args we allocated
_ffree(rgszFuncArgNames);
}
BOOL MacrosCallback(HWND hDlg, UINT uMsg, WPARAM wPar, LPARAM lPar)
{ HWND ListBox;
CHAR Buf[256];
PMAP ThisMapping, m, *MapPtr;
INT i, k;
PARAM_NOT_USED(lPar);
switch (uMsg) {
case WM_INITDIALOG:
FreeMappings(NewMappings);
NewMappings = NULL;
ListBox = GetDlgItem(hDlg, IDC_MACROLIST);
if (ListBox) {
MapPtr = &NewMappings;
SendMessage(ListBox, LB_RESETCONTENT, 0, 0);
for (m = FirstMapping; m != NULL; m = m->Next) {
if ((ThisMapping = DupMapping(m)) != NULL) {
SendMessage(ListBox, LB_ADDSTRING, 0, (LPARAM)m->Name);
*MapPtr = ThisMapping;
MapPtr = &ThisMapping->Next;
} else ErrorBox(MB_ICONSTOP, 300, 6);
}
SetDlgItemText(hDlg, IDC_MACRONAME, "");
SetDlgItemText(hDlg, IDC_MACROINPUT, "");
SetDlgItemText(hDlg, IDC_MACROREPLACE, "");
SendDlgItemMessage(hDlg, IDC_MACRONAME, EM_LIMITTEXT,
sizeof(Buf)/2 - 1, 0);
SendDlgItemMessage(hDlg, IDC_MACROINPUT, EM_LIMITTEXT,
sizeof(Buf) - 1, 0);
SendDlgItemMessage(hDlg, IDC_MACROREPLACE, EM_LIMITTEXT,
sizeof(Buf) - 1, 0);
EnableWindow(GetDlgItem(hDlg, IDC_DELMACRO), FALSE);
}
CheckDlgButton(hDlg, IDC_INSERTMODE, TRUE);
CheckDlgButton(hDlg, IDC_COMMANDMODE, TRUE);
CheckDlgButton(hDlg, IDC_COMMANDLINE, TRUE);
CheckRadioButton(hDlg, IDC_MAP, IDC_ABBREV, IDC_MAP);
break;
case WM_COMMAND:
ListBox = GetDlgItem(hDlg, IDC_MACROLIST);
if (!ListBox) break;
switch (COMMAND) {
static BOOL InitialString = FALSE;
case IDC_MACROLIST:
if (NOTIFICATION != LBN_SELCHANGE) break;
i = SendMessage(ListBox, LB_GETCURSEL, 0, 0);
if (i == LB_ERR) m = NULL;
else {
SendMessage(ListBox, LB_GETTEXT, i, (LPARAM)(LPSTR)Buf);
for (m = NewMappings;
m != NULL && lstrcmp(m->Name, Buf);
m = m->Next);
}
if (m != NULL) {
InitialString = TRUE;
SetDlgItemText(hDlg, IDC_MACRONAME, Buf);
SetDlgItemText(hDlg, IDC_MACROINPUT, m->InputDisplay);
SetDlgItemText(hDlg, IDC_MACROREPLACE, m->Replace);
CheckRadioButton(hDlg, IDC_MAP, IDC_ABBREV,
m->Flags & M_ABBREVIATION
? IDC_ABBREV : IDC_MAP);
CheckDlgButton(hDlg, IDC_INSERTMODE,
(m->Flags & M_INSERTMODE) !=0);
CheckDlgButton(hDlg, IDC_COMMANDMODE,
(m->Flags & M_COMMANDMODE)!=0);
CheckDlgButton(hDlg, IDC_COMMANDLINE,
(m->Flags & M_COMMANDLINE)!=0);
EnableWindow(GetDlgItem(hDlg, IDC_COMMANDMODE),
(m->Flags & M_ABBREVIATION) ==0);
InitialString = FALSE;
} else {
/*should not occur, set empty name to indicate error*/
SetDlgItemText(hDlg, IDC_MACRONAME, "");
}
EnableWindow(GetDlgItem(hDlg, IDC_DELMACRO),
m != NULL);
DefaultOkButton(hDlg);
break;
case IDC_MACRONAME:
case IDC_MACROINPUT:
if (NOTIFICATION != EN_CHANGE) break;
GetDlgItemText(hDlg, IDC_MACRONAME, Buf, sizeof(Buf));
for (k = 0; k < 2; ++k) {
LPWORD CmpMapping;
DWORD f;
i = FindMacroName(ListBox, Buf);
if (i != -1 || k) break;
/*same name not found, try to find same input...*/
GetDlgItemText(hDlg, IDC_MACROINPUT, Buf, sizeof(Buf));
if (!TranslateMapping(&CmpMapping, Buf)) break;
f = 0;
if (IsDlgButtonChecked(hDlg, IDC_ABBREV))
f |= M_ABBREVIATION;
if (IsDlgButtonChecked(hDlg, IDC_INSERTMODE))
f |= M_INSERTMODE;
if (IsDlgButtonChecked(hDlg, IDC_COMMANDMODE))
f |= M_COMMANDMODE;
if (IsDlgButtonChecked(hDlg, IDC_COMMANDLINE))
f |= M_COMMANDLINE;
for (m = NewMappings; m != NULL; m = m->Next)
if (IsMappingEqual(m->InputMatch, CmpMapping)
&& (m->Flags & f) == m->Flags)
break;
_ffree(CmpMapping);
if (m == NULL) break;
lstrcpy(Buf, m->Name);
}
SendMessage(ListBox, LB_SETCURSEL, i, 0);
EnableWindow(GetDlgItem(hDlg, IDC_DELMACRO), i >= 0);
/*FALLTHROUGH*/
case IDC_MACROREPLACE:
if (NOTIFICATION != EN_CHANGE || InitialString) break;
/*FALLTHROUGH*/
case IDC_INSERTMODE:
case IDC_COMMANDMODE:
case IDC_COMMANDLINE:
case IDC_MAP:
case IDC_ABBREV:
if (COMMAND == IDC_ABBREV || COMMAND == IDC_MAP) {
if (COMMAND == IDC_ABBREV)
CheckDlgButton(hDlg, IDC_COMMANDMODE, FALSE);
EnableWindow(GetDlgItem(hDlg, IDC_COMMANDMODE),
COMMAND == IDC_MAP);
}
if (GetDlgItemText(hDlg, IDC_MACRONAME, Buf, sizeof(Buf)) &&
GetDlgItemText(hDlg, IDC_MACROINPUT,Buf, sizeof(Buf))) {
SendMessage(hwndSettings, DM_SETDEFID, 102, 0);
SendMessage(hDlg, DM_SETDEFID, IDC_SETMACRO, 0);
}
break;
case IDC_SETMACRO:
ThisMapping = calloc(1, sizeof(*ThisMapping));
if (ThisMapping != NULL) {
PMAP *pmNew, *pmFree = NULL;
/*create a new entry...*/
GetDlgItemText(hDlg, IDC_MACROINPUT, Buf, sizeof(Buf));
if (!AllocStringA (&ThisMapping->InputDisplay,Buf) ||
!TranslateMapping(&ThisMapping->InputMatch, Buf)) {
FreeMappings(ThisMapping);
break;
}
GetDlgItemText(hDlg, IDC_MACROREPLACE,Buf,sizeof(Buf));
if (!AllocStringA (&ThisMapping->Replace, Buf) ||
!TranslateMapping(&ThisMapping->ReplaceMap, Buf)) {
FreeMappings(ThisMapping);
break;
}
GetDlgItemText(hDlg, IDC_MACRONAME, Buf, sizeof(Buf));
if (!AllocStringA(&ThisMapping->Name, Buf)) {
FreeMappings(ThisMapping);
break;
}
ThisMapping->Flags = 0;
if (IsDlgButtonChecked(hDlg, IDC_ABBREV))
ThisMapping->Flags |= M_ABBREVIATION;
if (IsDlgButtonChecked(hDlg, IDC_INSERTMODE))
ThisMapping->Flags |= M_INSERTMODE;
if (IsDlgButtonChecked(hDlg, IDC_COMMANDMODE))
ThisMapping->Flags |= M_COMMANDMODE;
if (IsDlgButtonChecked(hDlg, IDC_COMMANDLINE))
ThisMapping->Flags |= M_COMMANDLINE;
/*find old entry to delete and new position to enter..*/
for (MapPtr = pmNew = &NewMappings;
(m = *MapPtr) != NULL;
MapPtr = &m->Next) {
if ((i = lstrcmp(m->Name, Buf)) >= 0) {
if (i == 0) {
pmFree = MapPtr;
break;
}
} else pmNew = &m->Next;
if (IsMappingEqual(m->InputMatch,
ThisMapping->InputMatch) &&
(m->Flags & ThisMapping->Flags) == m->Flags)
pmFree = MapPtr;
}
/*delete old entry*/
if (pmFree != NULL) {
PMAP ToFree = *pmFree;
if ((i = FindMacroName(ListBox, ToFree->Name)) >= 0)
SendMessage(ListBox, LB_DELETESTRING, i, 0);
*pmFree = ToFree->Next;
if (pmNew == &ToFree->Next) pmNew = pmFree;
ToFree->Next = NULL;
FreeMappings(ToFree);
}
/*enter new entry...*/
i = SendMessage(ListBox, LB_ADDSTRING, 0,
(LPARAM)ThisMapping->Name);
SendMessage(ListBox, LB_SETCURSEL, i, 0);
ThisMapping->Next = *pmNew;
*pmNew = ThisMapping;
}
EnableWindow(GetDlgItem(hDlg, IDC_DELMACRO), TRUE);
DefaultOkButton(hDlg);
break;
case IDC_DELMACRO:
i = SendMessage(ListBox, LB_GETCURSEL, 0, 0);
if (i != LB_ERR) {
SendMessage(ListBox, LB_GETTEXT, i, (LPARAM)(LPSTR)Buf);
for (MapPtr = &NewMappings;
*MapPtr != NULL
&& lstrcmp((*MapPtr)->Name, Buf);
MapPtr = &(*MapPtr)->Next);
if ((ThisMapping = *MapPtr) != NULL) {
HWND DelButton = GetDlgItem(hDlg, IDC_DELMACRO);
*MapPtr = ThisMapping->Next;
ThisMapping->Next = NULL;
FreeMappings(ThisMapping);
SendMessage(ListBox, LB_DELETESTRING, i, 0);
DefaultOkButton(hDlg);
EnableWindow(DelButton, FALSE);
SendMessage(DelButton, BM_SETSTYLE, (WPARAM)BS_PUSHBUTTON, 1);
SetFocus(ListBox);
}
}
break;
case IDOK:
case ID_APPLY:
case IDC_STORE:
FreeMappings(FirstMapping);
FirstMapping = NewMappings;
NewMappings = NULL;
DlgResult = TRUE;
if (COMMAND == IDC_STORE) SaveMappingSettings();
if (COMMAND == IDOK) EndDialog(hDlg, 0);
else MacrosCallback(hDlg, WM_INITDIALOG, 0, 0);
break;
case IDCANCEL:
FreeMappings(NewMappings);
NewMappings = NULL;
EndDialog(hDlg, 0);
break;
}
break;
default:
return (FALSE);
}
return (TRUE);
}
void freeTables(void)
{
_ffree((void far *)logTab);
#ifdef NEWMSGTAB
destroyMsgTab();
#else
_ffree((void far *)msgTab_mtmsgflags);
_ffree((void far *)msgTab_mtmsgLocLO);
_ffree((void far *)msgTab_mtmsgLocHI);
_ffree((void far *)msgTab_mtroomno);
_ffree((void far *)msgTab_mttohash);
_ffree((void far *)msgTab_mtauthhash);
_ffree((void far *)msgTab_mtomesg);
#endif
_ffree((void far *)roomPos );
_ffree((void far *)msgBuf2 );
_ffree((void far *)msgBuf );
_ffree((void far *)roomTab );
_ffree((void far *)extrn );
_ffree((void far *)hallBuf );
_ffree((void far *)edit );
_ffree((void far *)doors );
_ffree((void far *)talleyBuf);
_ffree((void far *)lBuf2 );
}