void SaveExecutionInformation()
{
HKEY hKey;
DWORD lpdwDisposition;
struct ExecutionInformation executionInfo;
if (RegCreateKeyEx(HKEY_CURRENT_USER,TEXT("Software\\CLIPS\\CLIPSWin"),0,"",0,
KEY_READ | KEY_WRITE,NULL,&hKey,&lpdwDisposition) != ERROR_SUCCESS)
{ return; }
executionInfo.salienceEvaluation = EnvGetSalienceEvaluation(GlobalEnv);
executionInfo.strategy = EnvGetStrategy(GlobalEnv);
executionInfo.staticConstraintChecking = (boolean) EnvGetStaticConstraintChecking(GlobalEnv);
executionInfo.dynamicConstraintChecking = (boolean) EnvGetDynamicConstraintChecking(GlobalEnv);
executionInfo.autoFloatDividend = (boolean) EnvGetAutoFloatDividend(GlobalEnv);
executionInfo.resetGlobals = (boolean) EnvGetResetGlobals(GlobalEnv);
executionInfo.factDuplication = (boolean) EnvGetFactDuplication(GlobalEnv);
executionInfo.incrementalReset = (boolean) EnvGetIncrementalReset(GlobalEnv);
executionInfo.sequenceOperatorRecognition = (boolean) EnvGetSequenceOperatorRecognition(GlobalEnv);
if (RegSetValueEx(hKey,"Execution",0,REG_BINARY,(BYTE *) &executionInfo,
sizeof(struct ExecutionInformation)) != ERROR_SUCCESS)
{
RegCloseKey(hKey);
return;
}
RegCloseKey(hKey);
}
globle void WriteNeededConstraints(
void *theEnv,
FILE *fp)
{
int i;
unsigned short theIndex = 0;
unsigned long int numberOfUsedConstraints = 0;
CONSTRAINT_RECORD *tmpPtr;
BSAVE_CONSTRAINT_RECORD bsaveConstraints;
/*================================*/
/* Get the number of constraints. */
/*================================*/
for (i = 0; i < SIZE_CONSTRAINT_HASH; i++)
{
for (tmpPtr = ConstraintData(theEnv)->ConstraintHashtable[i];
tmpPtr != NULL;
tmpPtr = tmpPtr->next)
{
tmpPtr->bsaveIndex = theIndex++;
numberOfUsedConstraints++;
}
}
/*=============================================*/
/* If dynamic constraint checking is disabled, */
/* then no constraints are saved. */
/*=============================================*/
if ((! EnvGetDynamicConstraintChecking(theEnv)) && (numberOfUsedConstraints != 0))
{
numberOfUsedConstraints = 0;
PrintWarningID(theEnv,"CSTRNBIN",1,FALSE);
EnvPrintRouter(theEnv,WWARNING,"Constraints are not saved with a binary image\n");
EnvPrintRouter(theEnv,WWARNING," when dynamic constraint checking is disabled.\n");
}
/*============================================*/
/* Write out the number of constraints in the */
/* constraint table followed by each of the */
/* constraints in the constraint table. */
/*============================================*/
GenWrite(&numberOfUsedConstraints,(unsigned long) sizeof(unsigned long int),fp);
if (numberOfUsedConstraints == 0) return;
for (i = 0 ; i < SIZE_CONSTRAINT_HASH; i++)
{
for (tmpPtr = ConstraintData(theEnv)->ConstraintHashtable[i];
tmpPtr != NULL;
tmpPtr = tmpPtr->next)
{
CopyToBsaveConstraintRecord(theEnv,tmpPtr,&bsaveConstraints);
GenWrite(&bsaveConstraints,
(unsigned long) sizeof(BSAVE_CONSTRAINT_RECORD),fp);
}
}
}
globle int GDCCommand(
void *theEnv)
{
int oldValue;
oldValue = EnvGetDynamicConstraintChecking(theEnv);
if (EnvArgCountCheck(theEnv,"get-dynamic-constraint-checking",EXACTLY,0) == -1)
{ return(oldValue); }
return(oldValue);
}
globle void PrintConstraintReference(
void *theEnv,
FILE *fp,
CONSTRAINT_RECORD *cPtr,
int imageID,
int maxIndices)
{
if ((cPtr == NULL) || (! EnvGetDynamicConstraintChecking(theEnv)))
{ fprintf(fp,"NULL"); }
else fprintf(fp,"&C%d_%d[%d]",imageID,
(int) (cPtr->bsaveIndex / maxIndices) + 1,
(int) cPtr->bsaveIndex % maxIndices);
}
globle int SDCCommand(
void *theEnv)
{
int oldValue;
DATA_OBJECT arg_ptr;
oldValue = EnvGetDynamicConstraintChecking(theEnv);
if (EnvArgCountCheck(theEnv,"set-dynamic-constraint-checking",EXACTLY,1) == -1)
{ return(oldValue); }
EnvRtnUnknown(theEnv,1,&arg_ptr);
if ((arg_ptr.value == EnvFalseSymbol(theEnv)) && (arg_ptr.type == SYMBOL))
{ EnvSetDynamicConstraintChecking(theEnv,FALSE); }
else
{ EnvSetDynamicConstraintChecking(theEnv,TRUE); }
return(oldValue);
}
globle int ConstraintsToCode(
void *theEnv,
char *fileName,
int fileID,
FILE *headerFP,
int imageID,
int maxIndices)
{
int i, j, count;
int newHeader = TRUE;
FILE *fp;
int version = 1;
int arrayVersion = 1;
unsigned short numberOfConstraints = 0;
CONSTRAINT_RECORD *tmpPtr;
/*===============================================*/
/* Count the total number of constraint records. */
/*===============================================*/
for (i = 0 ; i < SIZE_CONSTRAINT_HASH; i++)
{
for (tmpPtr = ConstraintData(theEnv)->ConstraintHashtable[i];
tmpPtr != NULL;
tmpPtr = tmpPtr->next)
{ tmpPtr->bsaveIndex = numberOfConstraints++; }
}
/*=====================================================*/
/* If dynamic constraint checking is disabled, then */
/* contraints won't be saved. If there are constraints */
/* which could be saved, then issue a warning message. */
/*=====================================================*/
if ((! EnvGetDynamicConstraintChecking(theEnv)) && (numberOfConstraints != 0))
{
numberOfConstraints = 0;
PrintWarningID(theEnv,"CSTRNCMP",1,FALSE);
EnvPrintRouter(theEnv,WWARNING,"Constraints are not saved with a constructs-to-c image\n");
EnvPrintRouter(theEnv,WWARNING," when dynamic constraint checking is disabled.\n");
}
if (numberOfConstraints == 0) return(-1);
/*=================================================*/
/* Print the extern definition in the header file. */
/*=================================================*/
for (i = 1; i <= (numberOfConstraints / maxIndices) + 1 ; i++)
{ fprintf(headerFP,"extern CONSTRAINT_RECORD C%d_%d[];\n",imageID,i); }
/*==================*/
/* Create the file. */
/*==================*/
if ((fp = NewCFile(theEnv,fileName,fileID,version,FALSE)) == NULL) return(-1);
/*===================*/
/* List the entries. */
/*===================*/
j = 0;
count = 0;
for (i = 0; i < SIZE_CONSTRAINT_HASH; i++)
{
for (tmpPtr = ConstraintData(theEnv)->ConstraintHashtable[i];
tmpPtr != NULL;
tmpPtr = tmpPtr->next)
{
if (newHeader)
{
fprintf(fp,"CONSTRAINT_RECORD C%d_%d[] = {\n",imageID,arrayVersion);
newHeader = FALSE;
}
fprintf(fp,"{%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d",
tmpPtr->anyAllowed,
tmpPtr->symbolsAllowed,
tmpPtr->stringsAllowed,
tmpPtr->floatsAllowed,
tmpPtr->integersAllowed,
tmpPtr->instanceNamesAllowed,
tmpPtr->instanceAddressesAllowed,
tmpPtr->externalAddressesAllowed,
tmpPtr->factAddressesAllowed,
0, /* void allowed */
tmpPtr->anyRestriction,
tmpPtr->symbolRestriction,
tmpPtr->stringRestriction,
tmpPtr->floatRestriction,
tmpPtr->integerRestriction,
tmpPtr->instanceNameRestriction,
tmpPtr->multifieldsAllowed,
tmpPtr->singlefieldsAllowed);
fprintf(fp,",0,"); /* bsaveIndex */
PrintHashedExpressionReference(theEnv,fp,tmpPtr->restrictionList,imageID,maxIndices);
fprintf(fp,",");
PrintHashedExpressionReference(theEnv,fp,tmpPtr->minValue,imageID,maxIndices);
fprintf(fp,",");
PrintHashedExpressionReference(theEnv,fp,tmpPtr->maxValue,imageID,maxIndices);
fprintf(fp,",");
PrintHashedExpressionReference(theEnv,fp,tmpPtr->minFields,imageID,maxIndices);
fprintf(fp,",");
PrintHashedExpressionReference(theEnv,fp,tmpPtr->maxFields,imageID,maxIndices);
/* multifield slot */
fprintf(fp,",NULL");
/* next slot */
if (tmpPtr->next == NULL)
{ fprintf(fp,",NULL,"); }
else
{
if ((j + 1) >= maxIndices)
{ fprintf(fp,",&C%d_%d[%d],",imageID,arrayVersion + 1,0); }
else
{ fprintf(fp,",&C%d_%d[%d],",imageID,arrayVersion,j + 1); }
}
fprintf(fp,"%d,%d",tmpPtr->bucket,tmpPtr->count + 1);
count++;
j++;
if ((count == numberOfConstraints) || (j >= maxIndices))
{
fprintf(fp,"}};\n");
GenClose(fp);
j = 0;
version++;
arrayVersion++;
if (count < numberOfConstraints)
{
if ((fp = NewCFile(theEnv,fileName,1,version,FALSE)) == NULL) return(0);
newHeader = TRUE;
}
}
else
{ fprintf(fp,"},\n"); }
}
}
return(version);
}
/*******************************************************************************
Name: UpdateOptionsMenu
Description: Set menu item mark on options selected
Arguments: None
Returns: None
*******************************************************************************/
void UpdateOptionsMenu()
{
int i;
unsigned n = 0;
void *theEnv = GetCurrentEnvironment();
XtSetArg(TheArgs[n], XtNleftBitmap, None);n++;
for(i = 0; i <= RANDOM_STRATEGY;i++)
XtSetValues(strategy_widgets[i], TheArgs, n);
for(i = 0; i <= EVERY_CYCLE;i++)
XtSetValues(sal_opt_widgets[i],TheArgs,n);
n = 0;
XtSetArg(TheArgs[n], XtNleftBitmap, checker);n++;
XtSetValues(strategy_widgets[EnvGetStrategy(theEnv)],TheArgs,n);
XtSetValues(sal_opt_widgets[EnvGetSalienceEvaluation(theEnv)],TheArgs,n);
n = 0;
if (EnvGetFactDuplication(theEnv))
{
XtSetArg(TheArgs[n], XtNstate,True);n++;
XtSetValues(option_widgets[INT_FACT_DUPLICATION], TheArgs, n);
}
else
{
XtSetArg(TheArgs[n], XtNstate,False);n++;
XtSetValues(option_widgets[INT_FACT_DUPLICATION], TheArgs, n);
}
n = 0;
if (EnvGetDynamicConstraintChecking(theEnv))
{
XtSetArg(TheArgs[n], XtNstate,True);n++;
XtSetValues(option_widgets[INT_DYN_CONSTRAINT_CHK], TheArgs, n);
}
else
{
XtSetArg(TheArgs[n], XtNstate,False);n++;
XtSetValues(option_widgets[INT_DYN_CONSTRAINT_CHK], TheArgs, n);
}
n = 0;
if (EnvGetStaticConstraintChecking(theEnv))
{
XtSetArg(TheArgs[n], XtNstate,True);n++;
XtSetValues(option_widgets[INT_STA_CONSTRAINT_CHK], TheArgs, n);
}
else
{
XtSetArg(TheArgs[n], XtNstate,False);n++;
XtSetValues(option_widgets[INT_STA_CONSTRAINT_CHK], TheArgs, n);
}
n = 0;
if (EnvGetSequenceOperatorRecognition(theEnv))
{
XtSetArg(TheArgs[n], XtNstate,True);n++;
XtSetValues(option_widgets[INT_SEQUENCE_OPT_REG], TheArgs, n);
}
else
{
XtSetArg(TheArgs[n], XtNstate,False);n++;
XtSetValues(option_widgets[INT_SEQUENCE_OPT_REG], TheArgs, n);
}
n = 0;
if (EnvGetAutoFloatDividend(theEnv))
{
XtSetArg(TheArgs[n], XtNstate,True);n++;
XtSetValues(option_widgets[INT_AUTO_FLOAT_DIV], TheArgs, n);
}
else
{
XtSetArg(TheArgs[n], XtNstate,False);n++;
XtSetValues(option_widgets[INT_AUTO_FLOAT_DIV], TheArgs, n);
}
n = 0;
if (EnvGetIncrementalReset(theEnv))
{
XtSetArg(TheArgs[n], XtNstate,True);n++;
XtSetValues(option_widgets[INT_INCREMENTAL_RESET], TheArgs, n);
}
else
{
XtSetArg(TheArgs[n], XtNstate,False);n++;
XtSetValues(option_widgets[INT_INCREMENTAL_RESET], TheArgs, n);
}
n = 0;
if (EnvGetResetGlobals(theEnv))
{
XtSetArg(TheArgs[n], XtNstate,True);n++;
XtSetValues(option_widgets[INT_RESET_GLOBALS], TheArgs, n);
}
else
{
XtSetArg(TheArgs[n], XtNstate,False);n++;
XtSetValues(option_widgets[INT_RESET_GLOBALS], TheArgs, n);
}
}
globle intBool GetDynamicConstraintChecking()
{
return EnvGetDynamicConstraintChecking(GetCurrentEnvironment());
}
void CheckTemplateFact(
void *theEnv,
struct fact *theFact)
{
struct field *sublist;
int i;
struct deftemplate *theDeftemplate;
struct templateSlot *slotPtr;
DATA_OBJECT theData;
char thePlace[20];
int rv;
if (! EnvGetDynamicConstraintChecking(theEnv)) 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;
SetDOBegin(theData,1);
SetDOEnd(theData,((struct multifield *) sublist[i].value)->multifieldLength);
i++;
}
/*=============================================*/
/* Call the constraint checking routine to see */
/* if a constraint violation occurred. */
/*=============================================*/
rv = ConstraintCheckDataObject(theEnv,&theData,slotPtr->constraints);
if (rv != NO_VIOLATION)
{
gensprintf(thePlace,"fact f-%-5lld ",theFact->factIndex);
PrintErrorID(theEnv,"CSTRNCHK",1,true);
EnvPrintRouter(theEnv,WERROR,"Slot value ");
PrintDataObject(theEnv,WERROR,&theData);
EnvPrintRouter(theEnv,WERROR," ");
ConstraintViolationErrorMessage(theEnv,NULL,thePlace,false,0,slotPtr->slotName,
0,rv,slotPtr->constraints,true);
EnvSetHaltExecution(theEnv,true);
return;
}
}
return;
}
