globle void IfFunction(
DATA_OBJECT_PTR returnValue)
{
int numArgs;
/*============================================*/
/* Check for the correct number of arguments. */
/*============================================*/
if ((numArgs = ArgRangeCheck("if",2,3)) == -1)
{
returnValue->type = SYMBOL;
returnValue->value = FalseSymbol;
return;
}
/*=========================*/
/* Evaluate the condition. */
/*=========================*/
RtnUnknown(1,returnValue);
if ((BreakFlag == TRUE) || (ReturnFlag == TRUE))
{ return; }
/*=========================================*/
/* If the condition evaluated to FALSE and */
/* an "else" portion exists, evaluate it */
/* and return the value. */
/*=========================================*/
if ((returnValue->value == FalseSymbol) &&
(returnValue->type == SYMBOL) &&
(numArgs == 3))
{
RtnUnknown(3,returnValue);
return;
}
/*===================================================*/
/* Otherwise if the symbol evaluated to a non-FALSE */
/* value, evaluate the "then" portion and return it. */
/*===================================================*/
else if ((returnValue->value != FalseSymbol) ||
(returnValue->type != SYMBOL))
{
RtnUnknown(2,returnValue);
return;
}
/*=========================================*/
/* Return FALSE if the condition evaluated */
/* to FALSE and there is no "else" portion */
/* of the if statement. */
/*=========================================*/
returnValue->type = SYMBOL;
returnValue->value = FalseSymbol;
return;
}
globle void WhileFunction(
DATA_OBJECT_PTR returnValue)
{
DATA_OBJECT theResult;
/*====================================================*/
/* Evaluate the body of the while loop as long as the */
/* while condition evaluates to a non-FALSE value. */
/*====================================================*/
CurrentEvaluationDepth++;
RtnUnknown(1,&theResult);
while (((theResult.value != FalseSymbol) ||
(theResult.type != SYMBOL)) &&
(HaltExecution != TRUE))
{
if ((BreakFlag == TRUE) || (ReturnFlag == TRUE))
break;
RtnUnknown(2,&theResult);
CurrentEvaluationDepth--;
if (ReturnFlag == TRUE)
{ PropagateReturnValue(&theResult); }
PeriodicCleanup(FALSE,TRUE);
CurrentEvaluationDepth++;
if ((BreakFlag == TRUE) || (ReturnFlag == TRUE))
break;
RtnUnknown(1,&theResult);
}
CurrentEvaluationDepth--;
/*=====================================================*/
/* Reset the break flag. The return flag is not reset */
/* because the while loop is probably contained within */
/* a deffunction or RHS of a rule which needs to be */
/* returned from as well. */
/*=====================================================*/
BreakFlag = FALSE;
/*====================================================*/
/* If the return command was issued, then return that */
/* value, otherwise return the symbol FALSE. */
/*====================================================*/
if (ReturnFlag == TRUE)
{
returnValue->type = theResult.type;
returnValue->value = theResult.value;
returnValue->begin = theResult.begin;
returnValue->end = theResult.end;
}
else
{
returnValue->type = SYMBOL;
returnValue->value = FalseSymbol;
}
}
globle void PrognFunction(
DATA_OBJECT_PTR returnValue)
{
int numa, i;
numa = RtnArgCount();
if (numa == 0)
{
returnValue->type = SYMBOL;
returnValue->value = FalseSymbol;
return;
}
i = 1;
while ((i <= numa) && (GetHaltExecution() != TRUE))
{
RtnUnknown(i,returnValue);
if ((BreakFlag == TRUE) || (ReturnFlag == TRUE))
break;
i++;
}
if (GetHaltExecution() == TRUE)
{
returnValue->type = SYMBOL;
returnValue->value = FalseSymbol;
return;
}
return;
}
/**
* CLIPS function that is responsible for calling
* ruby objects
*/
void cl_rcall()
{
int argc = RtnArgCount();
// Sanity check
if(argc < 2) return;
// Get object and method
char *s_obj = RtnLexeme(1);
char *s_mtd = RtnLexeme(2);
// Get variant as I need them
VALUE obj; sscanf(s_obj, "%lx", &obj);
ID mtd = rb_intern(s_mtd);
if(argc == 2)
{
rb_funcall(obj, mtd, 0);
} else {
VALUE argv[argc - 2];
int i;
for(i = 3; i <= argc; i++)
{
DATA_OBJECT argument;
RtnUnknown(i, &argument);
argv[i - 3] = cl_generic_convert_dataobject(argument);
}
rb_funcall2(obj, mtd, argc-2, argv);
}
}
globle void ReturnFunction(
DATA_OBJECT_PTR result)
{
if (RtnArgCount() == 0)
{
result->type = RVOID;
result->value = FalseSymbol;
}
else
RtnUnknown(1,result);
ReturnFlag = TRUE;
}
globle void LoopForCountFunction(
DATA_OBJECT_PTR loopResult)
{
DATA_OBJECT arg_ptr;
long iterationEnd;
LOOP_COUNTER_STACK *tmpCounter;
tmpCounter = get_struct(loopCounterStack);
tmpCounter->loopCounter = 0L;
tmpCounter->nxt = LoopCounterStack;
LoopCounterStack = tmpCounter;
if (ArgTypeCheck("loop-for-count",1,INTEGER,&arg_ptr) == FALSE)
{
loopResult->type = SYMBOL;
loopResult->value = FalseSymbol;
LoopCounterStack = tmpCounter->nxt;
rtn_struct(loopCounterStack,tmpCounter);
return;
}
tmpCounter->loopCounter = DOToLong(arg_ptr);
if (ArgTypeCheck("loop-for-count",2,INTEGER,&arg_ptr) == FALSE)
{
loopResult->type = SYMBOL;
loopResult->value = FalseSymbol;
LoopCounterStack = tmpCounter->nxt;
rtn_struct(loopCounterStack,tmpCounter);
return;
}
iterationEnd = DOToLong(arg_ptr);
while ((tmpCounter->loopCounter <= iterationEnd) &&
(HaltExecution != TRUE))
{
if ((BreakFlag == TRUE) || (ReturnFlag == TRUE))
break;
CurrentEvaluationDepth++;
RtnUnknown(3,&arg_ptr);
CurrentEvaluationDepth--;
if (ReturnFlag == TRUE)
{ PropagateReturnValue(&arg_ptr); }
PeriodicCleanup(FALSE,TRUE);
if ((BreakFlag == TRUE) || (ReturnFlag == TRUE))
break;
tmpCounter->loopCounter++;
}
BreakFlag = FALSE;
if (ReturnFlag == TRUE)
{
loopResult->type = arg_ptr.type;
loopResult->value = arg_ptr.value;
loopResult->begin = arg_ptr.begin;
loopResult->end = arg_ptr.end;
}
else
{
loopResult->type = SYMBOL;
loopResult->value = FalseSymbol;
}
LoopCounterStack = tmpCounter->nxt;
rtn_struct(loopCounterStack,tmpCounter);
}
static void StrOrSymCatFunction(
DATA_OBJECT_PTR returnValue,
unsigned short returnType)
{
DATA_OBJECT theArg;
int numArgs, i, total, j;
char *theString;
SYMBOL_HN **arrayOfStrings;
SYMBOL_HN *hashPtr;
char *functionName;
/*============================================*/
/* Determine the calling function name. */
/* Store the null string or the symbol nil as */
/* the return value in the event of an error. */
/*============================================*/
SetpType(returnValue,returnType);
if (returnType == STRING)
{
functionName = "str-cat";
SetpValue(returnValue,(void *) AddSymbol(""));
}
else
{
functionName = "sym-cat";
SetpValue(returnValue,(void *) AddSymbol("nil"));
}
/*===============================================*/
/* Determine the number of arguments as create a */
/* string array which is large enough to store */
/* the string representation of each argument. */
/*===============================================*/
numArgs = RtnArgCount();
arrayOfStrings = (SYMBOL_HN **) gm1((int) sizeof(SYMBOL_HN *) * numArgs);
for (i = 0; i < numArgs; i++)
{ arrayOfStrings[i] = NULL; }
/*=============================================*/
/* Evaluate each argument and store its string */
/* representation in the string array. */
/*=============================================*/
total = 1;
for (i = 1 ; i <= numArgs ; i++)
{
RtnUnknown(i,&theArg);
switch(GetType(theArg))
{
case STRING:
#if OBJECT_SYSTEM
case INSTANCE_NAME:
#endif
case SYMBOL:
hashPtr = (SYMBOL_HN *) GetValue(theArg);
arrayOfStrings[i-1] = hashPtr;
IncrementSymbolCount(hashPtr);
break;
case FLOAT:
hashPtr = (SYMBOL_HN *) AddSymbol(FloatToString(ValueToDouble(GetValue(theArg))));
arrayOfStrings[i-1] = hashPtr;
IncrementSymbolCount(hashPtr);
break;
case INTEGER:
hashPtr = (SYMBOL_HN *) AddSymbol(LongIntegerToString(ValueToLong(GetValue(theArg))));
arrayOfStrings[i-1] = hashPtr;
IncrementSymbolCount(hashPtr);
break;
default:
ExpectedTypeError1(functionName,i,"string, instance name, symbol, float, or integer");
SetEvaluationError(TRUE);
break;
}
if (EvaluationError)
{
for (i = 0; i < numArgs; i++)
{
if (arrayOfStrings[i] != NULL)
{ DecrementSymbolCount(arrayOfStrings[i]); }
}
rm(arrayOfStrings,sizeof(SYMBOL_HN *) * numArgs);
return;
}
total += strlen(ValueToString(arrayOfStrings[i - 1]));
}
/*=========================================================*/
/* Allocate the memory to store the concatenated string or */
/* symbol, then copy the values in the string array to the */
/* memory just allocated. */
/*=========================================================*/
theString = (char *) gm2 ((sizeof(char) * total));
j = 0;
for (i = 0 ; i < numArgs ; i++)
{
sprintf(&theString[j],"%s",ValueToString(arrayOfStrings[i]));
j += strlen(ValueToString(arrayOfStrings[i]));
}
/*=========================================*/
/* Return the concatenated value and clean */
/* up the temporary memory used. */
/*=========================================*/
SetpValue(returnValue,(void *) AddSymbol(theString));
rm(theString,sizeof(char) * total);
for (i = 0; i < numArgs; i++)
{
if (arrayOfStrings[i] != NULL)
{ DecrementSymbolCount(arrayOfStrings[i]); }
}
rm(arrayOfStrings,sizeof(SYMBOL_HN *) * numArgs);
}
