WORD __EvalFunc(LPFUNC lpFunc, LISTID idArgList)
{
WORD i = FALSE;
ATOMID idName = NAME(lpFunc);
EXPID idBody;
LPEXP lpBody;
LISTID idVarList;
GLOBALHANDLE hBody;
if (NUMVARS(lpFunc) != KppListLen(idArgList))
return KppRegisterKappaMessage(hResThisDll, IDE_BADNUMARG,
idName, NULLID, NULLID);
idVarList = VARS(lpFunc);
idBody = BODY(lpFunc);
if (!idBody)
KappaReturnAtom(lpIDs->idNull);
UnwindProtect(cleanup);
if (lpKALView && lpKALView->bActive)
(*lpKALView->PushFn)(idName);
lpBody = KppCopyTempExp(idBody, (GLOBALHANDLE FAR *) &hBody);
Kpp__LoadArgs(lpBody, idVarList, idArgList);
i = Kpp_EvalExp(lpBody);
cleanup:
KppReleaseTempExp(hBody, i);
KppUnbindVars(idVarList);
if (lpKALView && lpKALView->bActive)
(*lpKALView->Pop)(TRUE);
EndProtect();
return i;
}
/* GetValue */
static short gso_get_value(ATOMID idfName, WORD wType, OBJECTID idObj,
ATOMID idSlotName, ATOMID idNoMonitors)
{
WORD wValueMulti;
ATOMID idValue;
if (idNoMonitors == lpIDs->idTrue)
{
UnwindProtect(cleanup);
KppSetNoMonitorFlag(TRUE);
idValue = Kpp_Get_SlotAnyValue(wType, idObj, idSlotName,
&wValueMulti);
cleanup:
KppSetNoMonitorFlag(FALSE);
EndProtect();
}
else
idValue = Kpp_Get_SlotAnyValue(wType, idObj, idSlotName,
&wValueMulti);
if (!idValue)
KappaReturnError;
if (!wValueMulti)
KappaReturnAtom(idValue);
KappaReturnList(idValue);
}
static BOOL InvokeRemoteSlotOP(OBJECTID idObj, ATOMID idSlotName,
BOOL *bMulti, SLOTID idSlot, LPSLOT lpSlot,
ITEMID *idValue, remote_op op)
{
UnwindProtect(cleanup);
if (lpSlot)
SLOTFLAGS(lpSlot) &= ~REMOTESLOT;
switch (op) {
case REMOTE_GET_VALUE:
*idValue = KppKrpGetValueOrValuesCB(idObj, idSlotName,
bMulti, TRUE);
break;
case REMOTE_SET_VALUE:
*idValue = KppKrpSetValueCB(idObj, idSlotName, *idValue, *bMulti);
break;
default:
*idValue = NULL;
}
cleanup:
if (lpSlot)
{
SLOTFLAGS(lpSlot) |= REMOTESLOT;
KppReleaseItem(SLOT, idSlot);
}
EndProtect();
return *idValue != NULLID;
}
short PEXPORT KppEvalFuncName(ATOMID idFuncName, LISTID idArgList,
BOOL bRemoveUnusedArgs)
{
WORD wCode = 0, wType = 0;
FUNCID idFunc = GetFunc(idFuncName);
CKAPPROC pFunc;
if (!idFunc)
{
pFunc = KppGetKappaFunction(idFuncName, &wType, &wCode);
if (pFunc)
{
#ifdef RUNTIME
if (KppbKappaPresent())
KppEvalCFuncCB(pFunc, idFuncName, idArgList,
(LPSTR) lpKALView, wType);
else
NoKappaEvalCFunc(pFunc, idFuncName, idArgList,
(LPSTR) lpKALView, wType);
#else
KppEvalCFuncCB(pFunc, idFuncName, idArgList,
(LPSTR) lpKALView, wType);
#endif
return TRUE;
}
else
return KppRegisterKappaMessage(hResThisDll,
IDE_ERRORINFUNC, idFuncName,
NULLID, NULLID);
}
{
LPFUNC lpFunc = (LPFUNC) KppGetItem(FUNC, idFunc);
WORD i = FALSE;
if (lpFunc && bRemoveUnusedArgs)
{
WORD wVars = NUMVARS(lpFunc);
WORD wArgs = KppListLen(idArgList);
while (wArgs > wVars)
{
KppDeleteElem(idArgList, wArgs, kPOSITIONMODE);
wArgs--;
}
}
UnwindProtect (cleanup);
i = __EvalFunc(lpFunc, idArgList);
cleanup:
KppReleaseItem(FUNC, idFunc);
EndProtect();
return i;
}
}
/* Add to KnowledgeTools */
KppAddItemCB(FUNC, -1);
return TRUE;
}
WORD PEXPORT KppEvalFunc(ITEMID idFunc, LISTID idArgList)
{
LPFUNC lpFunc = (LPFUNC) KppGetItem(FUNC, idFunc);
ATOMID idName;
LPEXP lpBody;
EXPID idBody;
LISTID idVarList;
GLOBALHANDLE hBody;
WORD i;
if (!lpFunc)
return KppRegisterKappaMessage(hResThisDll, IDE_ERRORINFUNC,
lpIDs->idError, NULLID, NULLID);
if (NUMVARS(lpFunc) != KppListLen(idArgList))
{
idName = NAME(lpFunc);
KppReleaseItem (FUNC, idFunc);
return KppRegisterKappaMessage(hResThisDll, IDE_BADNUMARG, idName,
NULLID, NULLID);
}
idVarList = VARS(lpFunc);
idBody = BODY(lpFunc);
KppReleaseItem(FUNC, idFunc);
if (!idBody)
KappaReturnAtom(lpIDs->idNull);
UnwindProtect(cleanup);
if (lpKALView && lpKALView->bActive)
(*lpKALView->PushFn)(idName);
lpBody = KppCopyTempExp(idBody, (GLOBALHANDLE FAR *)&hBody);
Kpp__LoadArgs(lpBody, idVarList, idArgList);
i = Kpp_EvalExp(lpBody);
cleanup:
KppReleaseTempExp(hBody, i);
KppUnbindVars(idVarList);
if (lpKALView && lpKALView->bActive)
(*lpKALView->Pop)(TRUE);
EndProtect();
return i;
}
WORD __EvalFunc(LPFUNC lpFunc, LISTID idArgList)
{
WORD i = FALSE;
ATOMID idName = NAME(lpFunc);
EXPID idBody;
LPEXP lpBody;
LISTID idVarList;
GLOBALHANDLE hBody;
if (NUMVARS(lpFunc) != KppListLen(idArgList))
return KppRegisterKappaMessage(hResThisDll, IDE_BADNUMARG,
idName, NULLID, NULLID);
idVarList = VARS(lpFunc);
idBody = BODY(lpFunc);
if (!idBody)
KappaReturnAtom(lpIDs->idNull);
UnwindProtect(cleanup);
if (lpKALView && lpKALView->bActive)
(*lpKALView->PushFn)(idName);
lpBody = KppCopyTempExp(idBody, (GLOBALHANDLE FAR *) &hBody);
Kpp__LoadArgs(lpBody, idVarList, idArgList);
i = Kpp_EvalExp(lpBody);
cleanup:
KppReleaseTempExp(hBody, i);
KppUnbindVars(idVarList);
if (lpKALView && lpKALView->bActive)
(*lpKALView->Pop)(TRUE);
EndProtect();
return i;
}
#ifdef RUNTIME /* used only when no KAPPARUN around */
static short NoKappaEvalCFunc(CKAPPROC pFunc, ATOMID idFuncName,
LISTID idArgList,
LPKALVIEWINFO lpKALViewInfo, WORD wType)
{
WORD wLength = KppListLen(idArgList);
ATOMID idArg;
LPEXP lpExp, lpTmp;
GLOBALHANDLE hExp, hLoop;
LISTLOOP lpLoop;
WORD i = FALSE;
if (!wLength)
return (*(PKAPPROC) pFunc)((LPEXP) NULL);
hExp = KppMakeTempExp(wLength + 1, (LPLPSTR) &lpExp);
if (!hExp)
return KppRegisterKappaMessage(hResThisDll,
IDE_EXPTOOBIG, lpIDs->idError,
NULLID, NULLID);
lpTmp = lpExp;
EXPFLAGS(lpTmp) = EXPATOM;
CAR(lpTmp) = idFuncName;
CDR(lpTmp++) = 1;
INIT_LIST_LOOP(idArgList, hLoop, lpLoop);
while (idArg = NEXT_LIST_ELEMENT(lpLoop))
{
EXPFLAGS(lpTmp) = EXPATOM;
CAR(lpTmp) = idArg;
CDR(lpTmp++) = 1;
}
RELEASE_LIST_LOOP(hLoop, lpLoop);
CDR(lpTmp - 1) = 0;
UnwindProtect(cleanup);
if (lpKALViewInfo && lpKALViewInfo->bActive)
(*lpKALViewInfo->PushFn)(idFuncName);
i = (*(PKAPPROC) pFunc)(lpExp);
cleanup:
if (lpKALViewInfo && lpKALViewInfo->bActive)
(*lpKALViewInfo->Pop)(TRUE);
KppReleaseTempExp(hExp, TRUE);
EndProtect();
return i;
}
TANY PEXPORT KpcGetValue(OBJECTID idObj, ATOMID slot, BOOL bNoMonitors)
{
WORD wType = OBJECT_TYPE(idObj);
TANY u;
if (Kpp_GetOption(wType, idObj, slot, OPT_CARD))
{
u.type = T_LIST;
if (bNoMonitors)
{
UnwindProtect(cleanup1);
KppSetNoMonitorFlag(TRUE);
u.data.list = Kpp_Get_SlotListValue(wType, idObj, slot);
cleanup1:
KppSetNoMonitorFlag(FALSE);
EndProtect();
}
else
u.data.list = Kpp_Get_SlotListValue(wType, idObj, slot);
}
else
{
u.type = T_ATOM;
if (bNoMonitors)
{
UnwindProtect(cleanup2);
KppSetNoMonitorFlag(TRUE);
u.data.atom = Kpp_Get_SlotValue(wType, idObj, slot);
cleanup2:
KppSetNoMonitorFlag(FALSE);
EndProtect();
}
else
u.data.atom = Kpp_Get_SlotValue(wType, idObj, slot);
}
return u;
}
LISTID PEXPORT KpcClearList(OBJECTID idObj, ATOMID slot)
{
WORD wType = OBJECT_TYPE(idObj);
LISTID idList;
BOOL bBAChange;
LISTID res;
UnwindProtect(cleanup1);
KppSetNoMonitorFlag(TRUE);
idList = Kpp_Get_SlotListValue(wType, idObj, slot);
cleanup1:
KppSetNoMonitorFlag(FALSE);
EndProtect();
bBAChange = kpc_check_for_monitor(wType, idObj, slot, &idList);
res = kpc_clear_list(idList, wType, idObj, slot, bBAChange);
return res ? res : kpc_error();
}
WORD PEXPORT KppTestGoal(ITEMID idGoal)
{
#ifdef INFERENCE
WORD i = FALSE;
EXPID idBody;
LPEXP lpBody2;
LPGOAL lpGoal = (LPGOAL) KppGetItem(GOAL, idGoal);
GLOBALHANDLE hBody2;
LOGICALID (EXPORT FAR *pBody)(void);
if (!lpGoal)
return KppRegisterKappaMessage (hResThisDll,
IDE_ERRORINFUNC, lpIDs->idError, NULLID, NULLID);
if (FLAGS(lpGoal) & CBODY)
{
pBody = CBODYPTR(lpGoal);
KppReleaseItem(GOAL, idGoal);
if ( !pBody )
return KppRegisterKappaMessage (hResThisDll,
IDE_ERRORINFUNC, lpIDs->idError, NULLID, NULLID);
KappaReturnAtom( pBody() );
}
else
{
idBody = BODY(lpGoal);
KppReleaseItem(GOAL, idGoal);
if (!idBody)
KappaReturnAtom(lpIDs->idNull);
lpBody2 = KppCopyTempExp(idBody, (GLOBALHANDLE FAR *)&hBody2);
UnwindProtect (cleanup);
i = Kpp_EvalExp(lpBody2);
cleanup:
KppReleaseTempExp(hBody2, i);
EndProtect();
return i;
}
#endif
}
WORD _EvalFunc(ITEMID idFunc, LPEXP lpArgList, WORD nArg)
{
LPFUNC lpFunc = (LPFUNC) KppGetItem(FUNC, idFunc);
WORD i = FALSE;
ATOMID idName;
EXPID idBody;
LPEXP lpBody;
LISTID idVarList;
GLOBALHANDLE hBody;
if (!lpFunc)
return KppRegisterKappaMessage(hResThisDll, IDE_ERRORINFUNC,
lpIDs->idError, NULLID, NULLID);
if (NUMVARS(lpFunc) != nArg)
{
idName = NAME(lpFunc);
KppReleaseItem(FUNC, idFunc);
return KppRegisterKappaMessage(hResThisDll, IDE_BADNUMARG,
idName, NULLID, NULLID);
}
idVarList = VARS(lpFunc);
idBody = BODY(lpFunc);
KppReleaseItem(FUNC, idFunc);
if (idBody == NULLID)
KappaReturnAtom(lpIDs->idNull);
lpBody = KppCopyTempExp(idBody, (GLOBALHANDLE FAR *)&hBody);
Kpp___LoadArgs(lpBody, idVarList, lpArgList);
UnwindProtect (cleanup);
i = Kpp_EvalExp(lpBody);
cleanup:
KppReleaseTempExp (hBody, i);
KppUnbindVars(idVarList);
EndProtect();
return i;
}
void Panic(char *fmt, ...)
{
va_list args;
#ifdef SUNOS
va_start(args);
#else
va_start(args, fmt);
#endif
UnwindProtect();
if (DbgLastObj) fprintf(Log, "Panic <%s>: ", M(DbgLastObj));
else fprintf(Log, "Panic: ");
vfprintf(Log, fmt, args);
fprintf(Log, "\n");
if (DbgLastObj) fprintf(Out, "Panic <%s>: ", M(DbgLastObj));
else fprintf(Out, "Panic: ");
vfprintf(Out, fmt, args);
fprintf(Out, "\n");
va_end(args);
MemCheckPrint();
/* PANIC */
while (1) Tool_Shell_Std();
}
BOOL set_parameter_value(ATOMID idfName, LPPARAM lpParam, WORD wXParamRows)
{
switch (lpParam->wMode) {
case SQL_PARAM_INPUT:
case SQL_PARAM_INPUT_OUTPUT:
{
LPDESC lpDesc = &lpParam->desc;
ITEMID idValues;
ATOMID idValue;
BOOL bMulti;
UnwindProtect(cleanup);
KppSetNoMonitorFlag(TRUE);
idValues = Kpp_Get_SlotAnyValue(lpParam->wType, lpParam->idObj,
lpParam->idSlot, &bMulti);
cleanup:
KppSetNoMonitorFlag(FALSE);
EndProtect();
if (!idValues)
return ERROR;
if (wXParamRows && !bMulti)
return KPC_ERROR(IDE_INVALID_SLOT, lpParam->idSlot);
if (!set_bind_values(idfName, lpParam->idSlot,
bMulti, idValues, wXParamRows + 1, lpDesc))
return ERROR;
}
case SQL_PARAM_OUTPUT:
return TRUE;
default:
return ERROR;
}
}
void PEXPORT KppInitMenus(void)
{
EXPID idExp;
LISTID idVars;
/* Define cursors */
hHourGlass = LoadCursor(NULL, IDC_WAIT);
/* Global variables under Menu */
idDisplayCall = KppAddAtom(GetStringTable(IDS_DISPLAYCALL));
idInitMenu = KppAddAtom(GetStringTable(IDS_INITMENU));
idPrepareMenu = KppAddAtom(GetStringTable(IDS_PREPAREMENU));
idownerStr = KppAddAtom(GetStringTable(IDS_OWNER_STR));
idselectorStr = KppAddAtom(GetStringTable(IDS_SELECTOR_STR));
idBitmapStr = KppAddAtom(GetStringTable(IDS_BITMAPW));
idRootMenuName = KppAddAtom(GetStringTable(IDS_WIN_MENU));
idwindowStr = KppAddAtom(GetStringTable(IDS_WINDOW_STR));
/* Initialize Menu class */
idRootMenu = NULLID; /* class id of 'Menu' */
idRootMenu = Kpp_MakeClass(idRootMenuName, lpIDs->idRootClass);
MARKSYSTEMCLASS(idRootMenu);
/* Make Menu slots */
Init_MenuSlotNames();
UnwindProtect(cleanup);
KppDontSaveValues(TRUE);
MakeMenuSlot(idRootMenuName, lpMenuSNs->idXSN);
KppSetSlotValue(idRootMenuName, lpMenuSNs->idXSN, lpIDs->idNull, EXPATOM);
MakeMenuSlot(idRootMenuName, lpMenuSNs->idYSN);
KppSetSlotValue(idRootMenuName, lpMenuSNs->idYSN, lpIDs->idNull, EXPATOM);
MakeMenuSlot(idRootMenuName, lpMenuSNs->idSelectorsSN);
SetOptionMultiple(idRootMenuName, lpMenuSNs->idSelectorsSN);
MakeMenuSlot(idRootMenuName, lpMenuSNs->idSelectorTitlesSN);
SetOptionMultiple(idRootMenuName, lpMenuSNs->idSelectorTitlesSN);
MakeMenuSlot(idRootMenuName, lpMenuSNs->idCheckedSelectorsSN);
SetOptionMultiple(idRootMenuName, lpMenuSNs->idCheckedSelectorsSN);
MakeMenuSlot(idRootMenuName, lpMenuSNs->idDisabledSelectorsSN);
SetOptionMultiple(idRootMenuName, lpMenuSNs->idDisabledSelectorsSN);
MakeMenuSlot(idRootMenuName, lpMenuSNs->idDefaultMessageSN);
KppSetSlotValue(idRootMenuName, lpMenuSNs->idDefaultMessageSN,
idDisplayCall, EXPATOM);
/* Make Menu Methods */
/* InitMenu */
idExp = KppBuildExp(GetStringTable(IDS_MENU_INITMENU));
idVars = KppMakeList(0);
KppAppendElem(idVars, idownerStr);
KppMakeMethod(idRootMenuName, idInitMenu, idVars, idExp);
KppMarkSystemMethod(idRootMenuName, idInitMenu);
/* DisplayCall */
idExp = KppBuildExp(GetStringTable(IDS_MENU_DISPLAYCALL));
idVars = KppMakeList(0);
KppAppendElem(idVars, idownerStr);
KppAppendElem(idVars, idwindowStr);
KppAppendElem(idVars, idselectorStr);
KppMakeMethod(idRootMenuName, idDisplayCall, idVars, idExp);
KppMarkSystemMethod(idRootMenuName, idDisplayCall);
/* PrepareMenu */
idExp = KppBuildExp(GetStringTable(IDS_MENU_PREPAREMENU));
idPrepareMenuMethod =
KppMakeMethod(idRootMenuName, idPrepareMenu, NULLID, idExp);
KppMarkSystemMethod(idRootMenuName, idPrepareMenu);
cleanup:
KppDontSaveValues(FALSE);
EndProtect();
}
BOOL PEXPORT KppWriteKalFile(LPSTR lpPathName)
{
FARFILE interpFile, saved_value = outFile;
BOOL bRet;
LPSTR lpComment;
GLOBALHANDLE hComment;
char tempname[FILENAME_MAX];
OFSTRUCT of;
if (KppGetWriteFile())
{
KppRegisterKappaMessage(hResThisDll, IDE_FALREADYOPEN, lpIDs->idError,
lpIDs->idNull, NULLID);
PostKappaMessage();
return FALSE;
}
OpenFile(lpPathName, &of, OF_PARSE);
hComment = GLOBALALLOC(GHND | GMEM_SHARE, (DWORD) MAX_COMMENT_SIZE);
lpComment = GLOBALLOCK(hComment);
if (!KppBeforeWriteKalFileCB(of.szPathName, lpComment, MAX_COMMENT_SIZE))
{
GLOBALUNLOCK(hComment);
GLOBALFREE(hComment);
return FALSE;
}
GetTmpFileNameOnDrive(of.szPathName[0], tempname);
interpFile = fopen_share(tempname, "w");
if (!CheckFreeSpace(of.szPathName))
return FALSE;
if (!interpFile)
{
KppRegisterKappaMessage(hResThisDll, IDE_FCANTOPEN, lpIDs->idError,
KppAddAtom("Temp Save File"), NULLID);
PostKappaMessage();
return FALSE;
}
UnwindProtect(cleanup);
outFile = interpFile;
bRet = WriteKalFile(interpFile, lpComment);
cleanup:
outFile = saved_value;
GLOBALUNLOCK(hComment);
GLOBALFREE(hComment);
EndProtect();
/* Check for any potential write errors and delete the file if any *
* occurred. */
if (!bRet && ferror(interpFile))
{
KppRegisterKappaMessage(hResThisDll,
IDE_WRITEERROR, KppAddAtom(lpPathName),
NULLID, NULLID);
KppPostKappaErrorMessageCB();
KppRegisterKappaMessage(hResThisDll, IDE_WRITEERROR2,
NULLID, NULLID, NULLID);
KppPostKappaErrorMessageCB();
fclose(interpFile);
remove(tempname);
return KppAfterWriteKalFileCB(lpPathName, FALSE);
}
if (fclose(interpFile))
{
KppRegisterKappaMessage(hResThisDll, IDE_FOUTOFDISK,
KppAddAtom(of.szPathName), NULLID, NULLID);
KppPostKappaErrorMessageCB();
remove(tempname);
return FALSE;
}
if (remove(lpPathName) && errno != ENOENT ||
rename(tempname, lpPathName))
{
KppRegisterKappaMessage(hResThisDll, IDE_PERMISSION,
KppAddAtom(of.szPathName), NULLID, NULLID);
KppPostKappaErrorMessageCB();
remove(tempname);
return FALSE;
}
else
{
ATOMID idFile = KppAddAtom(lpPathName);
KppEnumItem(FUNC, KppSetItemSavedInfo, (LPSTR) (long) idFile);
KppEnumItem(METHOD, KppSetItemSavedInfo, (LPSTR) (long) idFile);
remove_temp_save_file();
KppDeleteList(idTimeStamps);
idTimeStamps = NULLID;
SaveFileTimeStamp(idFile, NULL, lpPathName);
}
return KppAfterWriteKalFileCB(lpPathName, TRUE);
}
short BAChangeMethod(ATOMID idMethodName, LPSLOT lpSlot, WORD wType,
OBJECTID idObj, ATOMID idValue, ATOMID idErr)
{
short i = TRUE;
if (idMethodName)
{
METHODID idMethod = Kpp_Get_Method(wType, idObj, idMethodName);
LPMETHOD lpMethod;
WORD wNumVars;
LPEXP lpArgList, lpTmp;
GLOBALHANDLE hArgList;
short sLen;
if (!idMethod)
return RegisterKappaMessage(IDE_NOSUCHMETHOD, idMethodName,
KppGetItemName(wType, idObj), NULLID);
lpMethod = (LPMETHOD) KppGetItem(METHOD, idMethod);
if (!lpMethod)
return RegisterKappaMessage(IDE_ERRORINFUNC,
lpIDs->idError, NULLID, NULLID);
wNumVars = NUMVARS(lpMethod);
if (!idValue)
idValue = lpIDs->idNull;
KppReleaseItem(METHOD, idMethod);
if (wNumVars > 5)
return RegisterKappaMessage(IDE_BADNUMARG, idErr, NULLID, NULLID);
if (wNumVars > 3)
{
/* Set up an LPEXP to contain the arguments. */
hArgList = KppMakeTempExp(wNumVars - 3, (LPLPSTR) &lpArgList);
if (!hArgList)
return RegisterKappaMessage(IDE_EXPTOOBIG,
lpIDs->idError, NULLID, NULLID);
lpTmp = lpArgList;
/* Add the slotname argument. */
EXPFLAGS(lpTmp) = EXPATOM;
CAR(lpTmp) = (ATOMID) NAME(lpSlot);
if (wNumVars > 4)
{
/* Add the value argument. */
CDR(lpTmp++) = 1;
if (ISOPTMULTI(lpSlot))
EXPFLAGS(lpTmp) = EXPLIST;
else
EXPFLAGS(lpTmp) = EXPATOM;
CAR(lpTmp) = (ATOMID) idValue;
CDR(lpTmp) = 0;
}
}
else /* wNumVar == 3 */
lpArgList = (LPEXP) NULL;
/* Evaluate the method. */
UnwindProtect(cleanup);
i = FALSE;
sLen = KppGet_StackLength(KppGetTraceStack());
i = Kpp__Eval_Method(wType, idObj, idMethodName, lpArgList,
wNumVars - 3);
if (!i && !KppGetKalCatchLevel())
KppPostKappaErrorNowCB(sLen);
cleanup:
if (wNumVars > 3)
KppReleaseTempExp(hArgList, TRUE);
EndProtect();
}
return i;
}
ITEMID PEXPORT Kpp_Get_SlotValue(WORD wType, ITEMID idObj,
ATOMID idSlotName)
{
SLOTID idSlot;
LPSLOT lpSlot = NULL;
ITEMID idValue, idMethod, idINMethodName, idWAMethodName, idList;
LPMETHOD lpMethod;
WORD wNumVars;
WORD i = FALSE;
BOOL bMonitor = KppGetFileMonitor();
if (IS_INTERRUPTED && !KppInvokeEscapeFn())
return ERROR;
idSlot = Kpp_Get_Slot(wType, idObj, idSlotName);
if (KppIsRemoteObject(wType, idObj) &&
IsRemoteSlot(idSlot, &lpSlot, FALSE))
{
BOOL bMulti;
ITEMID idValue;
if (!InvokeRemoteSlotOP(idObj, idSlotName,
&bMulti, idSlot, lpSlot, &idValue,
REMOTE_GET_VALUE))
return NULLID;
if (bMulti)
return RegisterKappaMessage(IDE_MUSTBESINGLE,
KppGetItemName(wType, idObj),
idSlotName, NULLID);
return idValue;
}
if (!idSlot)
return RegisterKappaMessage(IDE_PAIRNOTFOUND,
KppGetItemName(wType, idObj),
idSlotName, NULLID);
if ((lpSlot = (LPSLOT) KppGetItem(SLOT, idSlot)) == NULL)
return RegisterKappaMessage(IDE_PAIRNOTFOUND,
KppGetItemName(wType, idObj), idSlotName, NULLID);
if (ISOPTMULTI(lpSlot))
{
KppReleaseItem(SLOT, idSlot);
return RegisterKappaMessage(IDE_MUSTBESINGLE,
KppGetItemName(wType, idObj), idSlotName, NULLID);
}
if ((idValue = VALUE(lpSlot)) == NULLID)
idValue = lpIDs->idNull;
idINMethodName = OPTNEEDED(lpSlot);
idWAMethodName = OPTWACCESS(lpSlot);
KppReleaseItem(SLOT, idSlot);
if (idValue == lpIDs->idNull)
{
long lReturnSet;
/* Do the IF_NEEDED demon */
if (idINMethodName && idINMethodName != lpIDs->idNull && bMonitor)
{
if (!(idMethod = Kpp_Get_Method(wType, idObj, idINMethodName)))
return RegisterKappaMessage(IDE_NOSUCHMETHOD, idINMethodName,
KppGetItemName(wType, idObj),
NULLID);
if (!(lpMethod = (LPMETHOD) KppGetItem(METHOD, idMethod)))
return RegisterKappaMessage(IDE_NOSUCHMETHOD, idINMethodName,
KppGetItemName(wType, idObj),
NULLID);
idList = KppMakeList(0);
wNumVars = NUMVARS(lpMethod);
if (wNumVars == 4)
KppAppendElem(idList, idSlotName);
if (wNumVars > 4)
{
KppReleaseItem(METHOD, idMethod);
KppDeleteList(idList);
return RegisterKappaMessage(IDE_BADNUMARG, lpIDs->idIfNeeded,
NULLID, NULLID);
}
UnwindProtect(cleanup);
i = Kpp_Eval_Method(wType, idObj, idINMethodName, idList, FALSE);
cleanup:
KppReleaseItem(METHOD, idMethod);
KppDeleteList(idList);
EndProtect();
if (!i)
return NULLID;
lReturnSet = KppGetKappaReturnSet();
if (!(FAST_RETURNFLAGS & EXPATOM))
return RegisterKappaMessage(IDE_IFBADRETURN,
KppGetItemName(wType, idObj),
idSlotName, NULLID);
idValue = FAST_RETURNVALUE;
}
else
idValue = lpIDs->idNull;
}
/* fire the WhenAccess Method */
if (idWAMethodName && idWAMethodName != lpIDs->idNull && bMonitor)
{
long lReturnSet;
if (!(idMethod = Kpp_Get_Method(wType, idObj, idWAMethodName)))
return RegisterKappaMessage(IDE_NOSUCHMETHOD, idWAMethodName,
KppGetItemName(wType, idObj), NULLID);
if (!(lpMethod = (LPMETHOD) KppGetItem(METHOD, idMethod)))
return RegisterKappaMessage(IDE_NOSUCHMETHOD, idWAMethodName,
KppGetItemName(wType, idObj), NULLID);
idList = KppMakeList(0);
wNumVars = NUMVARS(lpMethod);
if (wNumVars >= 4)
KppAppendElem(idList, idSlotName);
if (wNumVars == 5)
KppAppendElem(idList, idValue);
if (wNumVars > 5)
{
KppReleaseItem(METHOD, idMethod);
KppDeleteList(idList);
return RegisterKappaMessage(IDE_BADNUMARG,
lpIDs->idWhenAccess, NULLID, NULLID);
}
UnwindProtect(cleanup2);
i = Kpp_Eval_Method(wType, idObj, idWAMethodName, idList, FALSE);
cleanup2:
KppReleaseItem(METHOD, idMethod);
KppDeleteList(idList);
EndProtect();
if (!i)
return NULLID;
lReturnSet = KppGetKappaReturnSet();
if (!(FAST_RETURNFLAGS & EXPATOM))
return RegisterKappaMessage(IDE_WABADRETURN,
KppGetItemName(wType, idObj),
idSlotName, NULLID);
idValue = FAST_RETURNVALUE;
}
return idValue;
}
ITEMID PEXPORT Kpp_Get_SlotListValue(WORD wType, OBJECTID idObj,
ATOMID idSlotName)
{
LPOBJECT lpObj;
ITEMID idSlot;
LPSLOT lpSlot = NULL;
ITEMID idValue = NULLID, idList, idMethod;
ATOMID idINMethodName, idWAMethodName;
LPMETHOD lpMethod;
CLASSID idClass;
WORD wNumVars;
WORD i = FALSE;
BOOL bMonitor;
idSlot = Kpp_Get_LocalSlot(wType, idObj, idSlotName);
if (KppIsRemoteObject(wType, idObj) &&
IsRemoteSlot(idSlot, &lpSlot, FALSE))
{
BOOL bMulti;
ITEMID idValue;
if (!InvokeRemoteSlotOP(idObj, idSlotName,
&bMulti, idSlot, lpSlot, &idValue,
REMOTE_GET_VALUE))
return NULLID;
if (!bMulti)
return NULLID;
return idValue;
}
if (!idSlot)
{
lpObj = (LPOBJECT) KppGetItem(wType, idObj);
if (!lpObj)
return ERROR;
idClass = CLASSOF(lpObj);
if (!idClass ||
(!(idSlot = Kpp_Copy_Slot(CLASS, idClass, idSlotName))) ||
(!(lpSlot = (LPSLOT) KppGetItem(SLOT, idSlot))))
{
KppReleaseItem(wType, idObj);
if (idSlot)
KppDeleteItem(SLOT, idSlot);
return NULLID;
}
if (!ISOPTMULTI(lpSlot))
{
KppReleaseItem(wType, idObj);
KppReleaseItem(SLOT, idSlot);
KppDeleteItem(SLOT, idSlot);
return NULLID;
}
idValue = VALUE(lpSlot);
if (!(idList = SLOTS(lpObj)))
idList = SLOTS(lpObj) = KppMakeList(0);
KppReleaseItem(wType, idObj);
KppAppendElemPair(idList, idSlotName, idSlot);
}
else
{
if (!(lpSlot = (LPSLOT) KppGetItem(SLOT, idSlot)))
return NULLID;
if (!ISOPTMULTI(lpSlot))
{
KppReleaseItem(SLOT, idSlot);
return NULLID;
}
idValue = VALUE(lpSlot);
}
idINMethodName = OPTNEEDED(lpSlot);
idWAMethodName = OPTWACCESS(lpSlot);
KppReleaseItem(SLOT, idSlot);
bMonitor = KppGetFileMonitor();
/* Do the IF_NEEDED demon */
if (!idValue || !KppListLen(idValue))
{
long lReturnSet;
if (idINMethodName && idINMethodName != lpIDs->idNull && bMonitor)
{
if (!(idMethod = Kpp_Get_Method(wType, idObj, idINMethodName)))
return RegisterKappaMessage(IDE_NOTEXIST, lpIDs->idIfNeeded,
idINMethodName, NULLID);
if (!(lpMethod = (LPMETHOD) KppGetItem(METHOD, idMethod)))
return ERROR;
idList = KppMakeList(0);
wNumVars = NUMVARS(lpMethod);
if (wNumVars == 4)
KppAppendElem(idList, idSlotName);
if (wNumVars > 4)
{
KppDeleteList(idList);
KppReleaseItem(METHOD, idMethod);
return RegisterKappaMessage(IDE_BADNUMARG, lpIDs->idIfNeeded,
NULLID, NULLID);
}
UnwindProtect(cleanup);
i = Kpp_Eval_Method(wType, idObj, idINMethodName, idList, FALSE);
cleanup:
KppReleaseItem(METHOD, idMethod);
KppDeleteList(idList);
EndProtect();
if (!i)
return NULLID;
lReturnSet = KppGetKappaReturnSet();
if (!(FAST_RETURNFLAGS & EXPLIST))
return RegisterKappaMessage(IDE_IFBADRETURN,
KppGetItemName(wType, idObj),
idSlotName, NULLID);
if (FAST_RETURNVALUE != lpIDs->idNull)
idValue = FAST_RETURNVALUE;
}
/* no IF_NEEDED method is defined and the list is empty */
else if (!idValue)
idValue = lpIDs->idNull;
}
if (idWAMethodName && idWAMethodName != lpIDs->idNull && bMonitor)
{
long lReturnSet;
if (!(idMethod = Kpp_Get_Method(wType, idObj, idWAMethodName)))
return RegisterKappaMessage(IDE_NOTEXIST, lpIDs->idWhenAccess,
idWAMethodName, NULLID);
if (!(lpMethod = (LPMETHOD) KppGetItem(METHOD, idMethod)))
return ERROR;
idList = KppMakeList(0);
wNumVars = NUMVARS(lpMethod);
if (wNumVars >= 4)
KppAppendElem(idList, idSlotName);
if (wNumVars == 5)
KppAppendElem(idList, idValue);
if (wNumVars > 5)
{
KppReleaseItem(METHOD, idMethod);
KppDeleteList(idList);
return RegisterKappaMessage(IDE_BADNUMARG,
lpIDs->idWhenAccess, NULLID, NULLID);
}
UnwindProtect(cleanup2);
i = Kpp_Eval_Method(wType, idObj, idWAMethodName, idList, FALSE);
cleanup2:
KppReleaseItem(METHOD, idMethod);
KppDeleteList(idList);
EndProtect();
if (!i)
return NULLID;
lReturnSet = KppGetKappaReturnSet();
if (!(FAST_RETURNFLAGS & EXPLIST))
return RegisterKappaMessage(IDE_WABADRETURN,
KppGetItemName(wType, idObj), idSlotName, NULLID);
if (FAST_RETURNVALUE && FAST_RETURNVALUE != lpIDs->idNull)
idValue = FAST_RETURNVALUE;
}
return idValue;
}
HDDEDATA W_CALLBACK KapDDECallBack(WORD wTran, WORD wFmt, HCONV hConv,
HSZ hsz1, HSZ hsz2, HDDEDATA hData,
DWORD dwData1, DWORD dwData2)
{
switch (wTran) {
case XTYP_ADVSTART:
case XTYP_ADVSTOP:
{
BOOL bRes = FALSE;
if (wFmt == CF_TEXT)
{
char *cl;
if (!DdeQueryString(dwDDEInst, hsz2, return_buffer,
RET_BUFFER_LEN, CP_WINANSI))
return (HDDEDATA) FALSE;
cl = strchr(return_buffer, ':');
if (cl)
{
DDEINFO ddeInfo;
ATOMID idName;
WORD wType;
cl[0] = '\0';
idName = KppAddAtom(return_buffer);
ddeInfo.idSlot = KppAddAtom(cl + 1);
ddeInfo.idObj = KppGetObjectId(idName, &wType);
ddeInfo.idApp = ddeInfo.idItem = NULLID;
ddeInfo.idTopic = HszToAtom(hsz1);
ddeInfo.hConv = hConv;
if (ddeInfo.idObj)
{
UnwindProtect(cleanup1);
requests++;
switch (wTran) {
case XTYP_ADVSTART:
if (CreateLink(&ddeInfo))
bRes = TRUE;
break;
case XTYP_ADVSTOP:
if (CloseServerLink(&ddeInfo, idName))
bRes = TRUE;
break;
}
cleanup1:
requests--;
EndProtect();
}
}
}
return (HDDEDATA) bRes;
}
case XTYP_EXECUTE:
{
DWORD dwLen;
LPBYTE lpByte = DdeAccessData(hData, &dwLen);
if (lpByte)
{
BOOL bFree = FALSE;
LPBYTE lpCopy;
if (dwLen < RET_BUFFER_LEN)
{
strcpy(return_buffer, lpByte);
lpCopy = return_buffer;
}
else
{
lpCopy = strdup(lpByte);
bFree = TRUE;
}
DdeUnaccessData(hData);
if (lpCopy)
{
UnwindProtect(cleanup2);
requests++;
if (!KppEvalExpString(lpCopy))
KppPostKappaErrorMessageCB();
cleanup2:
requests--;
if (bFree)
free(lpCopy);
EndProtect();
return (HDDEDATA) DDE_FACK;
}
}
return (HDDEDATA) DDE_FNOTPROCESSED;
}
case XTYP_CONNECT:
if (DdeQueryString(dwDDEInst, hsz1, return_buffer,
RET_BUFFER_LEN, CP_WINANSI))
{
char *dot = strrchr(return_buffer, '.');
if (dot)
dot[0] = '\0';
if (!stricmp(DDETopicName, return_buffer) ||
#ifdef MULTI
!stricmp(DDEKappaName, return_buffer) ||
S_ILOC == 0 &&
#endif
!stricmp("KAPPA", return_buffer))
return TRUE;
}
return (HDDEDATA) FALSE;
case XTYP_DISCONNECT:
UnwindProtect(cleanup3);
requests++;
DeleteDDETasks(hConv);
cleanup3:
requests--;
EndProtect();
return (HDDEDATA) NULL;
case XTYP_WILDCONNECT:
{
HSZPAIR hszPair[3];
hszPair[0].hszSvc =
DdeCreateStringHandle(dwDDEInst, DDEAppName, CP_WINANSI);
hszPair[0].hszTopic =
DdeCreateStringHandle(dwDDEInst, DDETopicName, CP_WINANSI);
hszPair[1].hszSvc =
DdeCreateStringHandle(dwDDEInst, DDEAppName, CP_WINANSI);
hszPair[1].hszTopic =
DdeCreateStringHandle(dwDDEInst, DDEKappaName, CP_WINANSI);
hszPair[2].hszSvc = hszPair[2].hszTopic = NULL;
return DdeCreateDataHandle(dwDDEInst, (LPVOID) hszPair,
sizeof(HSZPAIR) * 3, 0,
hszPair[0].hszSvc, CF_TEXT, 0);
}
case XTYP_POKE:
{
UINT flag = DDE_FNOTPROCESSED;
if (wFmt == CF_TEXT &&
DdeQueryString(dwDDEInst, hsz2, return_buffer,
RET_BUFFER_LEN, CP_WINANSI))
{
ATOMID idSlot;
OBJECTID idObj;
UnwindProtect(cleanup4);
requests++;
idObj = ObjSlotFromItem(return_buffer, &idSlot);
if (idObj && StoreData(lpIDs->idNull, hData, idObj, idSlot))
flag = DDE_FACK;
cleanup4:
requests--;
EndProtect();
}
return (HDDEDATA) flag;
}
case XTYP_REQUEST:
case XTYP_ADVREQ:
hData = (HDDEDATA) DDE_FNOTPROCESSED;
if (wFmt == CF_TEXT &&
DdeQueryString(dwDDEInst, hsz2, return_buffer,
RET_BUFFER_LEN, CP_WINANSI))
{
ATOMID idSlot;
OBJECTID idObj;
UnwindProtect(cleanup5);
requests++;
idObj = ObjSlotFromItem(return_buffer, &idSlot);
if (idObj)
{
BOOL bMulti = FALSE;
ITEMID idValue =
Kpp_Get_SlotAnyValue(OBJECT_TYPE(idObj),
idObj, idSlot, (LPWORD) &bMulti);
GLOBALHANDLE hMem = NULL;
LPBYTE lpBytes = NULL;
DWORD dwLen = ValueToString(idValue, bMulti,
&hMem, &lpBytes);
if (dwLen)
{
hData = DdeCreateDataHandle(dwDDEInst, lpBytes, dwLen,
0, hsz2, CF_TEXT, 0);
if (hMem)
{
GLOBALUNLOCK(hMem);
GLOBALFREE(hMem);
}
if (!hData)
hData = (HDDEDATA) DDE_FNOTPROCESSED;
}
}
cleanup5:
requests--;
EndProtect();
}
return hData;
case XTYP_REGISTER:
{
ATOMID idApp = HszToAtom(hsz2);
UnwindProtect(cleanup6);
requests++;
if (idApp)
{
WORD wType;
OBJECTID idService = KppGetObjectId(idApp, &wType);
if (!idService)
{
idService = KppMakeCO(OBJECT, idApp, idDDEService);
wType = OBJECT;
}
if (idService)
{
if (DdeQueryString(dwDDEInst, hsz1, return_buffer,
RET_BUFFER_LEN, CP_WINANSI))
Kpp_Set_SlotValue(wType, idService, Slot(idService),
KppAddAtom(return_buffer), EXPATOM);
else
Kpp_Set_SlotValue(wType, idService, Slot(idService),
lpIDs->idNull, EXPATOM);
}
}
cleanup6:
requests--;
EndProtect();
return (HDDEDATA) NULL;
}
case XTYP_ADVDATA:
UnwindProtect(cleanup7);
requests++;
if (wFmt == CF_TEXT)
{
CONVINFO ci;
ATOMID idApp, idItem, idName;
OBJECTID idLink;
memset(&ci, 0, sizeof(CONVINFO));
ci.cb = sizeof(CONVINFO);
DdeQueryConvInfo(hConv, QID_SYNC, &ci);
idApp = HszToAtom(ci.hszSvcPartner);
idItem = HszToAtom(hsz2);
idName = LinkName(idApp, idItem);
idLink = FindLink(idName);
if (idLink)
{
WORD wDestType;
ATOMID idDest = Kpp_Get_SlotValue(OBJECT, idLink,
Slot(idDDEObject));
ATOMID idSlot = Kpp_Get_SlotValue(OBJECT, idLink,
Slot(idDDESlot));
OBJECTID idDestObj = KppGetObjectId(idDest, &wDestType);
StoreData(lpIDs->idNull, hData, idDestObj, idSlot);
}
}
cleanup7:
requests--;
EndProtect();
return (HDDEDATA) DDE_FACK;
case XTYP_XACT_COMPLETE:
{
char name[20];
OBJECTID idTask;
ATOMID idName;
WORD wType;
UnwindProtect(cleanup8);
requests++;
task_name(name, hConv, dwData1);
idName = KppAddAtom(name);
idTask = KppGetObjectId(idName, &wType);
if (idTask)
{
CONVINFO ci;
memset(&ci, 0, sizeof(CONVINFO));
ci.cb = sizeof(CONVINFO);
DdeQueryConvInfo(hConv, dwData1, &ci);
switch (ci.wType) {
case XTYP_REQUEST:
if (wFmt == CF_TEXT)
{
WORD wDestType;
ATOMID idDest = Kpp_Get_SlotValue(wType, idTask,
Slot(idDDEObject));
ATOMID idSlot = Kpp_Get_SlotValue(wType, idTask,
Slot(idDDESlot));
OBJECTID idDestObj = KppGetObjectId(idDest,
&wDestType);
StoreData(lpIDs->idNull, hData, idDestObj, idSlot);
DdeDisconnect(hConv);
}
break;
case XTYP_POKE:
case XTYP_EXECUTE:
DdeDisconnect(hConv);
break;
case (XTYP_ADVSTART | XTYPF_ACKREQ):
{
ATOMID idDest =
Kpp_Get_SlotValue(wType, idTask, Slot(idDDEObject));
WORD wDestType;
DDEINFO ddeInfo;
ddeInfo.hConv = hConv;
ddeInfo.idApp = Kpp_Get_SlotValue(wType, idTask,
Slot(idService));
ddeInfo.idTopic = Kpp_Get_SlotValue(wType, idTask,
Slot(idTopic));
ddeInfo.idItem = Kpp_Get_SlotValue(wType, idTask,
Slot(idItem));
ddeInfo.idObj = KppGetObjectId(idDest, &wDestType);
ddeInfo.idSlot = Kpp_Get_SlotValue(wType, idTask,
Slot(idDDESlot));
CreateLink(&ddeInfo);
break;
}
}
DeleteDDETask(lpIDs->idNull, wType, idTask, (LPVOID) &hConv);
}
cleanup8:
requests--;
EndProtect();
return (HDDEDATA) NULL;
}
default:
return (HDDEDATA) NULL;
}
}
WORD TestRule(ITEMID idRule)
{
WORD i = FALSE, nVars;
WORD wLength;
LISTID idMatchList;
LISTID idVarList;
EXPID idBody;
GLOBALHANDLE hCopy1, hCopy2;
LPEXP lpCopy1, lpCopy2;
LPRULE lpRule = (LPRULE) KppGetItem(RULE, idRule);
if (!lpRule)
return ERROR;
if ((idBody = BODY(lpRule)) == NULLID)
{
KppReleaseItem(RULE, idRule);
return ERROR;
}
nVars = NUMVARS(lpRule);
idVarList = VARS(lpRule);
if (nVars > 0)
{
if (MATCHES(lpRule) != NULLID)
KppDeleteMatchList(MATCHES(lpRule));
idMatchList = MATCHES(lpRule) = KppMakeList(0);
}
KppReleaseItem(RULE, idRule);
if (nVars <= 0)
{
lpCopy1 = KppCopyTempExp(idBody, (GLOBALHANDLE FAR *)&hCopy1);
UnwindProtect (cleanup_1);
i = Kpp_EvalExp(lpCopy1 + 2);
cleanup_1:
KppReleaseTempExp (hCopy1, i);
EndProtect();
return i;
}
else
{
KppEnumList(idVarList, KppLoadInstances, (LPSTR)(LONG)idMatchList);
/* loop only if all classes have valid instances */
if (KppSelectElem(idMatchList, KppIsListEmpty, 0L) == NULLID)
{
lpCopy1 = (LPEXP)KppGetExp(idBody, &wLength);
KppReleaseExp(idBody);
lpCopy1 = KppCopyTempExp(idBody, (GLOBALHANDLE FAR *)&hCopy1);
lpCopy2 = KppCopyTempExp(idBody, (GLOBALHANDLE FAR *)&hCopy2);
UnwindProtect (cleanup_2);
i = KppEvalAllMappings(lpCopy1,lpCopy2, wLength, idVarList,
idMatchList, nVars, 0, TestARule, wSELECT);
cleanup_2:
KppReleaseTempExp (hCopy1,i);
KppReleaseTempExp (hCopy2, i);
EndProtect();
return i;
}
KappaReturnFalse;
}
}
static BOOL InterpretKal(FILE *fpFile, LPSTR lpFileName, LPSTR lpComment,
BOOL bMode, ATOMID idAsk)
{
LPEXP lpExp;
GLOBALHANDLE hExp = KppMakeTempExp(READ_EXP_SIZE, (LPLPSTR) &lpExp);
WORD wDummy = EXP_NORMAL_MODE;
DWORD dwInputLineNumberSave;
ITEMID idExpStackElemSave;
BOOL bExpStackSave, bRet = TRUE;
ATOMID idFileName = KppAddAtom(lpFileName);
BOOL bSaveInterp = bInterpreterOn;
LPSTR lpSaveFile = lpFileBeingInterpreted;
BOOL bFirst = TRUE;
ATOMID idOldAsk = KppGetOverrideMode();
SaveFileTimeStamp(idFileName, fpFile, NULL);
if (!hExp)
return ERROR;
/* Clear the key */
INIT_INTERRUPT;
/* prepare the parser */
idExpStackElemSave = KppGetExpStackElem();
bExpStackSave = KppGetExpStackState();
dwInputLineNumberSave = KppGetInputLineNumber();
KppSetInputLineNumber(1);
KppSetExpStackState(FALSE);
/* Attempt reading the Application Comment */
Read_KAL_App_Comment(fpFile, lpComment);
/* while not end of file */
UnwindProtect(cleanup);
KppSetOverrideMode(idAsk);
while (!feof(fpFile)) {
unsigned long lBegin = ftell(fpFile);
if (IS_INTERRUPTED)
{
if (!KppInvokeEscapeFn())
{
KppPostKappaErrorMessageCB();
if (InterpError(lpFileName) == IDNO)
{
bRet = FALSE;
break;
}
}
}
SetFileBeingInterpreted(lpFileName);
if (!KppFillExpNew3(lpExp, 0, fpFile, NULL, NULL,
EXP_NORMAL_MODE, &wDummy, READ_EXP_SIZE,
bFirst ? (long *) &lBegin : NULL))
{
PostKappaMessage();
if (InterpError(lpFileName) == IDNO)
{
bRet = FALSE;
break;
}
else
continue;
}
if (bMode)
KppInterpretationEchoCB((LPSTR) lpExp, 0, 0);
SetInterpretationFlag(TRUE);
KppSetItemSkipped(FALSE);
if (!Kpp_EvalExp(lpExp))
{
if (!TrapImageSlotError())
{
KppPostKappaErrorMessageCB();
if (InterpError(lpFileName) == IDNO)
{
SetInterpretationFlag(FALSE);
bRet = FALSE;
break;
}
}
else
KppClearTraceStack();
}
else if (!KppGetItemSkipped())
KppSetItemFileInfo(lpExp, idFileName, lBegin, ftell(fpFile));
SetInterpretationFlag(TRUE);
if (bMode)
KppInterpretationEchoCB((LPSTR) lpExp, RETURNFLAGS, RETURNVALUE);
bFirst = FALSE;
}
cleanup:
KppSetOverrideMode(idOldAsk);
KppSetExpStackElem(idExpStackElemSave);
KppSetExpStackState(bExpStackSave);
KppSetInputLineNumber(dwInputLineNumberSave);
KppReleaseTempExp(hExp, TRUE);
SetInterpretationFlag(bSaveInterp);
SetFileBeingInterpreted(lpSaveFile);
EndProtect();
return bRet;
}
