le * evaluateNode( lithp_burrito * lb, le * node)
{
le * temp;
le * value;
if (node->branch) {
if( node->quoted ) {
value = leDup( node->branch );
} else {
value = evaluateBranch( lb, node->branch );
}
} else {
temp = variableGet( lb->defunList, node->data );
if (temp) {
value = evaluateDefun( lb, temp, node->list_next );
} else {
temp = variableGet( lb->mainVarList, node->data );
if (temp) {
value = leDup( temp );
} else {
value = leNew( node->data );
}
}
}
return( value );
}
le * eval_cb_prog( lithp_burrito * lb, const int argc, le * branch, int returnit )
{
le * curr;
le * retval = NULL;
le * tempval = NULL;
int current = 0;
if (!branch || argc < (returnit +1) ) return( leNew( "NIL" ));
curr = branch->list_next;
while (curr)
{
++current;
if ( tempval ) leWipe (tempval);
tempval = evaluateNode( lb, curr );
if (current == returnit) retval = leDup( tempval );
curr = curr->list_next;
}
if (!retval) retval = tempval;
return( retval );
}
le * evaluateDefun( lithp_burrito *lb, le * fcn, le * params )
{
le * function;
le * thisparam;
le * result;
int count;
/* make sure both lists exist */
if (!fcn) return( leNew( "NIL" ));
/* check for the correct number of parameters */
if (countNodes(fcn->branch) > countNodes(params))
return( leNew( "NIL" ));
/* allocate another function definition, since we're gonna hack it */
function = leDup(fcn);
/* pass 1: tag each node properly.
for each parameter: (fcn)
- look for it in the tree, tag those with the value
*/
count = 0;
thisparam = fcn->branch;
while (thisparam)
{
leTagData(function, thisparam->data, count);
thisparam = thisparam->list_next;
count++;
}
/* pass 2: replace
for each parameter: (param)
- evaluate the passed in value
- replace it in the tree
*/
count = 0;
thisparam = params;
while (thisparam)
{
result = evaluateNode( lb, thisparam );
leTagReplace(function, count, result);
thisparam = thisparam->list_next;
leWipe(result);
count++;
}
/* then evaluate the resulting tree */
result = evaluateBranch( lb, function->list_next );
/* free any space allocated */
leWipe( function );
/* return the evaluation */
return( result );
}
void variableSet(le **varlist, char *key, le *value)
{
if (key && value) {
le *temp = variableFind(*varlist, key);
if (temp)
leWipe(temp->branch);
else {
temp = leNew(key);
*varlist = leAddHead(*varlist, temp);
}
temp->branch = leDup(value);
}
}
le * eval_cb_set_helper(
enum setfcn function,
lithp_burrito * lb, const int argc,
le * branch
)
{
le * newkey = NULL;
le * newvalue = NULL;
le * current = NULL;
if (!branch || argc < 3) return( leNew( "NIL" ) );
current = branch->list_next;
while ( current ) {
if (!current->list_next) {
newvalue = leNew( "NIL" );
} else {
newvalue = evaluateNode(lb, current->list_next);
}
if ( function == S_SET ) newkey = evaluateNode(lb, current);
lb->mainVarList = variableSet(
lb->mainVarList,
( function == S_SET )? newkey->data : current->data,
newvalue
);
if ( function == S_SET ) leWipe(newkey);
if (!current->list_next) {
current = NULL;
} else {
current = current->list_next->list_next;
}
}
return( leDup(newvalue) );
}
static le *
evaluateNode (le * node)
{
le *value;
if (node == NULL)
return leNIL;
if (node->branch != NULL)
{
if (node->quoted)
value = leDup (node->branch);
else
value = evaluateBranch (node->branch);
}
else
{
const char *s = get_variable (node->data);
value = leNew (s ? s : node->data);
}
return value;
}
