void MyRoutingDataObjectWithLifespanCallback(WONRoutingDataObjectWithLifespan *theData, void *theUserParam)
{
printf("DataObjectWithLifespan Callback: %s\n",(char*)theUserParam);
printf("Lifespan: %d\n",theData->mLifespan);
PrintDataObject(&theData->mObject);
SetEvent(mEvent); printf("\n");
}
/***************************************************
NAME : DetermineRestrictionClass
DESCRIPTION : Finds the class of an argument in
the ProcParamArray
INPUTS : The argument data object
RETURNS : The class address, NULL if error
SIDE EFFECTS : EvaluationError set on errors
NOTES : None
***************************************************/
static DEFCLASS *DetermineRestrictionClass(
void *theEnv,
DATA_OBJECT *dobj)
{
INSTANCE_TYPE *ins;
DEFCLASS *cls;
if (dobj->type == INSTANCE_NAME)
{
ins = FindInstanceBySymbol(theEnv,(SYMBOL_HN *) dobj->value);
cls = (ins != NULL) ? ins->cls : NULL;
}
else if (dobj->type == INSTANCE_ADDRESS)
{
ins = (INSTANCE_TYPE *) dobj->value;
cls = (ins->garbage == 0) ? ins->cls : NULL;
}
else
return(DefclassData(theEnv)->PrimitiveClassMap[dobj->type]);
if (cls == NULL)
{
EnvSetEvaluationError(theEnv,true);
PrintErrorID(theEnv,"GENRCEXE",3,false);
EnvPrintRouter(theEnv,WERROR,"Unable to determine class of ");
PrintDataObject(theEnv,WERROR,dobj);
EnvPrintRouter(theEnv,WERROR," in generic function ");
EnvPrintRouter(theEnv,WERROR,EnvGetDefgenericName(theEnv,(void *) DefgenericData(theEnv)->CurrentGeneric));
EnvPrintRouter(theEnv,WERROR,".\n");
}
return(cls);
}
void MyRoutingDataObjectModificationCallback(WONRoutingDataObjectModification *theData, void *theUserParam)
{
printf("DataObjectModification Callback: %s\n",(char*)theUserParam);
printf("IsInsert: %d\n",theData->mIsInsert);
printf("Offset: %d\n",theData->mOffset);
PrintDataObject(&theData->mObject);
SetEvent(mEvent); printf("\n");
}
static void PrintDefglobalValueForm(
void *theEnv,
char *logicalName,
void *vTheGlobal)
{
struct defglobal *theGlobal = (struct defglobal *) vTheGlobal;
EnvPrintRouter(theEnv,logicalName,"?*");
EnvPrintRouter(theEnv,logicalName,ValueToString(theGlobal->header.name));
EnvPrintRouter(theEnv,logicalName,"* = ");
PrintDataObject(theEnv,logicalName,&theGlobal->current);
}
void MyRoutingReadDataObjectCallback(WONRoutingReadDataObjectResult *theObjects, void *theUserParam)
{
unsigned int i;
printf("ReadDataObject Callback: %s\n",(char*)theUserParam);
printf("Status: %d\n",theObjects->mStatus);
printf("Objects:\n\n");
for(i=0; i<theObjects->mNumObjects; i++)
{
PrintDataObject(&theObjects->mObjects[i]);
printf("\n");
}
SetEvent(mEvent); printf("\n");
}
globle void EnvGetDefglobalValueForm(
void *theEnv,
char *buffer,
unsigned bufferLength,
void *vTheGlobal)
{
struct defglobal *theGlobal = (struct defglobal *) vTheGlobal;
OpenStringDestination(theEnv,"GlobalValueForm",buffer,bufferLength);
EnvPrintRouter(theEnv,"GlobalValueForm","?*");
EnvPrintRouter(theEnv,"GlobalValueForm",ValueToString(theGlobal->header.name));
EnvPrintRouter(theEnv,"GlobalValueForm","* = ");
PrintDataObject(theEnv,"GlobalValueForm",&theGlobal->current);
CloseStringDestination(theEnv,"GlobalValueForm");
}
globle void QSetDefglobalValue(
void *theEnv,
struct defglobal *theGlobal,
DATA_OBJECT_PTR vPtr,
int resetVar)
{
/*====================================================*/
/* If the new value passed for the defglobal is NULL, */
/* then reset the defglobal to the initial value it */
/* had when it was defined. */
/*====================================================*/
if (resetVar)
{
EvaluateExpression(theEnv,theGlobal->initial,vPtr);
if (EvaluationData(theEnv)->EvaluationError)
{
vPtr->type = SYMBOL;
vPtr->value = EnvFalseSymbol(theEnv);
}
}
/*==========================================*/
/* If globals are being watch, then display */
/* the change to the global variable. */
/*==========================================*/
#if DEBUGGING_FUNCTIONS
if (theGlobal->watch)
{
EnvPrintRouter(theEnv,WTRACE,":== ?*");
EnvPrintRouter(theEnv,WTRACE,ValueToString(theGlobal->header.name));
EnvPrintRouter(theEnv,WTRACE,"* ==> ");
PrintDataObject(theEnv,WTRACE,vPtr);
EnvPrintRouter(theEnv,WTRACE," <== ");
PrintDataObject(theEnv,WTRACE,&theGlobal->current);
EnvPrintRouter(theEnv,WTRACE,"\n");
}
#endif
/*==============================================*/
/* Remove the old value of the global variable. */
/*==============================================*/
ValueDeinstall(theEnv,&theGlobal->current);
if (theGlobal->current.type == MULTIFIELD)
{ ReturnMultifield(theEnv,(struct multifield *) theGlobal->current.value); }
/*===========================================*/
/* Set the new value of the global variable. */
/*===========================================*/
theGlobal->current.type = vPtr->type;
if (vPtr->type != MULTIFIELD) theGlobal->current.value = vPtr->value;
else DuplicateMultifield(theEnv,&theGlobal->current,vPtr);
ValueInstall(theEnv,&theGlobal->current);
/*===========================================*/
/* Set the variable indicating that a change */
/* has been made to a global variable. */
/*===========================================*/
DefglobalData(theEnv)->ChangeToGlobals = TRUE;
if ((EvaluationData(theEnv)->CurrentEvaluationDepth == 0) && (! CommandLineData(theEnv)->EvaluatingTopLevelCommand) &&
(EvaluationData(theEnv)->CurrentExpression == NULL))
{ PeriodicCleanup(theEnv,TRUE,FALSE); }
}
bool RouteCommand(
void *theEnv,
const char *command,
bool printResult)
{
DATA_OBJECT result;
struct expr *top;
const char *commandName;
struct token theToken;
int danglingConstructs;
if (command == NULL)
{ return(0); }
/*========================================*/
/* Open a string input source and get the */
/* first token from that source. */
/*========================================*/
OpenStringSource(theEnv,"command",command,0);
GetToken(theEnv,"command",&theToken);
/*=====================*/
/* Evaluate constants. */
/*=====================*/
if ((theToken.type == SYMBOL) || (theToken.type == STRING) ||
(theToken.type == FLOAT) || (theToken.type == INTEGER) ||
(theToken.type == INSTANCE_NAME))
{
CloseStringSource(theEnv,"command");
if (printResult)
{
PrintAtom(theEnv,STDOUT,theToken.type,theToken.value);
EnvPrintRouter(theEnv,STDOUT,"\n");
}
return(1);
}
/*=====================*/
/* Evaluate variables. */
/*=====================*/
if ((theToken.type == GBL_VARIABLE) ||
(theToken.type == SF_VARIABLE) ||
(theToken.type == MF_VARIABLE))
{
CloseStringSource(theEnv,"command");
top = GenConstant(theEnv,theToken.type,theToken.value);
EvaluateExpression(theEnv,top,&result);
rtn_struct(theEnv,expr,top);
if (printResult)
{
PrintDataObject(theEnv,STDOUT,&result);
EnvPrintRouter(theEnv,STDOUT,"\n");
}
return(1);
}
/*========================================================*/
/* If the next token isn't the beginning left parenthesis */
/* of a command or construct, then whatever was entered */
/* cannot be evaluated at the command prompt. */
/*========================================================*/
if (theToken.type != LPAREN)
{
PrintErrorID(theEnv,"COMMLINE",1,false);
EnvPrintRouter(theEnv,WERROR,"Expected a '(', constant, or variable\n");
CloseStringSource(theEnv,"command");
return(0);
}
/*===========================================================*/
/* The next token must be a function name or construct type. */
/*===========================================================*/
GetToken(theEnv,"command",&theToken);
if (theToken.type != SYMBOL)
{
PrintErrorID(theEnv,"COMMLINE",2,false);
EnvPrintRouter(theEnv,WERROR,"Expected a command.\n");
CloseStringSource(theEnv,"command");
return(0);
}
commandName = ValueToString(theToken.value);
/*======================*/
/* Evaluate constructs. */
/*======================*/
#if (! RUN_TIME) && (! BLOAD_ONLY)
{
int errorFlag;
errorFlag = ParseConstruct(theEnv,commandName,"command");
if (errorFlag != -1)
{
CloseStringSource(theEnv,"command");
if (errorFlag == 1)
{
EnvPrintRouter(theEnv,WERROR,"\nERROR:\n");
PrintInChunks(theEnv,WERROR,GetPPBuffer(theEnv));
EnvPrintRouter(theEnv,WERROR,"\n");
}
DestroyPPBuffer(theEnv);
if (errorFlag) return 0;
else return 1;
}
}
#endif
/*========================*/
/* Parse a function call. */
/*========================*/
danglingConstructs = ConstructData(theEnv)->DanglingConstructs;
CommandLineData(theEnv)->ParsingTopLevelCommand = true;
top = Function2Parse(theEnv,"command",commandName);
CommandLineData(theEnv)->ParsingTopLevelCommand = false;
ClearParsedBindNames(theEnv);
/*================================*/
/* Close the string input source. */
/*================================*/
CloseStringSource(theEnv,"command");
/*=========================*/
/* Evaluate function call. */
/*=========================*/
if (top == NULL)
{
ConstructData(theEnv)->DanglingConstructs = danglingConstructs;
return false;
}
ExpressionInstall(theEnv,top);
CommandLineData(theEnv)->EvaluatingTopLevelCommand = true;
CommandLineData(theEnv)->CurrentCommand = top;
EvaluateExpression(theEnv,top,&result);
CommandLineData(theEnv)->CurrentCommand = NULL;
CommandLineData(theEnv)->EvaluatingTopLevelCommand = false;
ExpressionDeinstall(theEnv,top);
ReturnExpression(theEnv,top);
ConstructData(theEnv)->DanglingConstructs = danglingConstructs;
/*=================================================*/
/* Print the return value of the function/command. */
/*=================================================*/
if ((result.type != RVOID) && printResult)
{
PrintDataObject(theEnv,STDOUT,&result);
EnvPrintRouter(theEnv,STDOUT,"\n");
}
return true;
}
globle void CheckTemplateFact(
struct fact *theFact)
{
struct field *sublist;
int i;
struct deftemplate *theDeftemplate;
struct templateSlot *slotPtr;
DATA_OBJECT theData;
char thePlace[20];
int rv;
if (! GetDynamicConstraintChecking()) return;
sublist = theFact->theProposition.theFields;
/*========================================================*/
/* If the deftemplate corresponding to the first field of */
/* of the fact cannot be found, then the fact cannot be */
/* checked against the deftemplate format. */
/*========================================================*/
theDeftemplate = theFact->whichDeftemplate;
if (theDeftemplate == NULL) return;
if (theDeftemplate->implied) return;
/*=============================================*/
/* Check each of the slots of the deftemplate. */
/*=============================================*/
i = 0;
for (slotPtr = theDeftemplate->slotList;
slotPtr != NULL;
slotPtr = slotPtr->next)
{
/*================================================*/
/* Store the slot value in the appropriate format */
/* for a call to the constraint checking routine. */
/*================================================*/
if (slotPtr->multislot == FALSE)
{
theData.type = sublist[i].type;
theData.value = sublist[i].value;
i++;
}
else
{
theData.type = MULTIFIELD;
theData.value = (void *) sublist[i].value;
theData.begin = 0;
theData.end = ((struct multifield *) sublist[i].value)->multifieldLength-1;
i++;
}
/*=============================================*/
/* Call the constraint checking routine to see */
/* if a constraint violation occurred. */
/*=============================================*/
rv = ConstraintCheckDataObject(&theData,slotPtr->constraints);
if (rv != NO_VIOLATION)
{
sprintf(thePlace,"fact f-%-5ld ",theFact->factIndex);
PrintErrorID("CSTRNCHK",1,TRUE);
PrintRouter(WERROR,"Slot value ");
PrintDataObject(WERROR,&theData);
PrintRouter(WERROR," ");
ConstraintViolationErrorMessage(NULL,thePlace,FALSE,0,slotPtr->slotName,
0,rv,slotPtr->constraints,TRUE);
SetHaltExecution(TRUE);
return;
}
}
return;
}
void MyRoutingDataObjectCallback(WONRoutingDataObject *theData, void *theUserParam)
{
printf("DataObject Callback: %s\n",(char*)theUserParam);
PrintDataObject(theData);
SetEvent(mEvent); printf("\n");
}
HDDEDATA CALLBACK DDECallBack(
UINT uType,
UINT uFmt,
HCONV hconv,
HSZ hsz1,
HSZ hsz2,
HDDEDATA hData,
DWORD dwData1,
DWORD dwData2)
{
#if MAC_MCW || WIN_MCW || MAC_XCD
#pragma unused(hconv)
#pragma unused(dwData1)
#pragma unused(dwData2)
#endif
extern HSZ hszService;
extern char CompleteString[255];
DWORD size;
HWND hWnd;
char *TheData;
char *Data;
char *theString;
void *theEnv = GetCurrentEnvironment();
/*
char theBuffer[100];
DWORD cb;
PSTR pszTopicName;
*/
switch (uType)
{
case XTYP_ADVDATA:
case XTYP_POKE:
return ((HDDEDATA) DDE_FNOTPROCESSED);
case XTYP_ADVREQ:
case XTYP_WILDCONNECT:
return ((HDDEDATA) NULL);
case XTYP_ADVSTART:
case XTYP_ADVSTOP:
case XTYP_CONNECT_CONFIRM:
case XTYP_DISCONNECT:
case XTYP_ERROR:
case XTYP_REGISTER:
case XTYP_UNREGISTER:
case XTYP_XACT_COMPLETE:
return ((HDDEDATA) FALSE);
case XTYP_MONITOR:
return ((HDDEDATA) TRUE);
case XTYP_CONNECT:
/*
cb = DdeQueryString(idInst,hsz1,(LPSTR) NULL, 0,CP_WINANSI) + 1;
pszTopicName = (PSTR) LocalAlloc(LPTR, (UINT) cb);
DdeQueryString(idInst,hsz1, pszTopicName,cb,CP_WINANSI);
cb = DdeQueryString(idInst,hsz2,(LPSTR) NULL, 0,CP_WINANSI) + 1;
pszTopicName = (PSTR) LocalAlloc(LPTR, (UINT) cb);
DdeQueryString(idInst,hsz2, pszTopicName,cb,CP_WINANSI);
*/
DDE_RV.type = RVOID;
if (hsz2 != hszService)
{ return ((HDDEDATA) FALSE); }
return((HDDEDATA) TRUE);
/*--------------------------------------------------+
| Get completed command and return result to client |
+--------------------------------------------------*/
case XTYP_REQUEST:
if (uFmt != CF_TEXT)
{ return(NULL); }
/* sprintf(theBuffer,"XTYP_REQUEST uFmt = %d\n",(int) uFmt);
PrintRouter(WDISPLAY,theBuffer); */
hData = NULL;
if (hsz1 == hszCommand)
{
theString = DataObjectToString(GetCurrentEnvironment(),&DDE_RV);
hData = DdeCreateDataHandle (idInst,
(unsigned char *) theString,
strlen(theString)+1,
0L, hsz2,CF_TEXT,0);
}
return (hData);
case XTYP_EXECUTE:
SetFocus(DialogWindow);
if (CommandLineData(GetCurrentEnvironment())->EvaluatingTopLevelCommand ||
BatchActive(GetCurrentEnvironment()) )
{ return ((HDDEDATA) DDE_FBUSY ); }
Data = (char *) DdeAccessData ( hData, NULL);
size = strlen((char *) Data) + 1;
TheData = (char *) genalloc ( GetCurrentEnvironment(),(unsigned) size );
DdeGetData ( hData, (LPBYTE)TheData, size, 0L );
EnvPrintRouter(theEnv,WPROMPT,TheData);
EnvPrintRouter(theEnv,WPROMPT,"\n");
EnvEval(theEnv,TheData,&DDE_RV);
if (DDE_RV.type != RVOID)
{
PrintDataObject(GetCurrentEnvironment(),"stdout",&DDE_RV);
EnvPrintRouter(theEnv,"stdout","\n");
}
PrintPrompt(theEnv);
DdeUnaccessData(hData);
hWnd = FindWindow("ClipsEditWClass", NULL);
SetFocus (hWnd);
return ((HDDEDATA) DDE_FACK);
}
return ( (HDDEDATA) TRUE );
}