tri11paragon
/
COSC_4P82_Assignment_1
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
COSC_4P82_Assignment_1/lib/lilgp/kernel_c/tree.c

1116 lines
30 KiB
C
Raw Normal View History

init
2024-02-13 21:21:51 -05:00
/* lil-gp Genetic Programming System, version 1.0, 11 July 1995
* Copyright (C) 1995 Michigan State University
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*
* Douglas Zongker (zongker@isl.cps.msu.edu)
* Dr. Bill Punch (punch@isl.cps.msu.edu)
*
* Computer Science Department
* A-714 Wells Hall
* Michigan State University
* East Lansing, Michigan 48824
* USA
*
*/
#include <lilgp.h>
/*
* note: that almost all these functions that recurse through the tree
* come in two parts: the wrapper and the recursive part. the "standard"
* method of traversing a tree like this is to set up a pointer to the
* first node in the tree, then subsequent recursive calls step the
* pointer forward, traversing the tree in preorder. the wrapper function
* sets up this pointer, then passes the address of that pointer [that's
* an (lnode **)] to the recursive part.
*
* the first function in this file [tree_size()] is commented in detail,
* others (which are just variations on this theme) are rather glossed over.
*
* note: when I refer to a tree's "size" I almost always mean "how many
* lnodes the tree takes to store", NOT how many nodes are in the tree.
* watch out for this. (the major exception is, of course, "tree_size()"
* which returns the node count.)
*/
/*
* tree_nodes: return the number of nodes in the tree.
*/
int tree_nodes ( lnode *tree )
{
lnode *l = tree;
return tree_nodes_recurse ( &l );
}
int tree_nodes_recurse ( lnode **l )
{
/*
* *l always points at a function node here; save the function.
*/
function *f = (**l).f;
int i, j = 1;
/* step the pointer over the function. */
++*l;
/* if the function is a terminal, then the recursion bottoms out. */
if ( f->arity == 0 )
{
/* skip the pointer over the ERC value if this node has one. */
if ( f->ephem_gen )
++*l;
/* return this subtree size. */
return 1;
}
else
{
/* function is not a terminal, so add up its subtrees and return
* the total.
*/
switch ( f->type )
{
case FUNC_DATA:
case EVAL_DATA:
for ( i = 0; i < f->arity; ++i )
j += tree_nodes_recurse ( l );
break;
case FUNC_EXPR:
case EVAL_EXPR:
for ( i = 0; i < f->arity; ++i )
{
/* skip the pointer over the skipsize node. */
++*l;
/* add this subtree's size to the total. */
j += tree_nodes_recurse ( l );
}
break;
}
}
return j;
}
/*
* tree_nodes_internal: return number of internal (function) nodes in the
* tree.
*/
int tree_nodes_internal ( lnode *data )
{
lnode *l = data;
return tree_nodes_internal_recurse ( &l );
}
int tree_nodes_internal_recurse ( lnode **l )
{
function *f = (**l).f;
int i, j = 1;
++*l;
if ( f->arity == 0 )
{
if ( f->ephem_gen )
++*l;
return 0;
}
else
{
switch ( f->type )
{
case FUNC_DATA:
case EVAL_DATA:
for ( i = 0; i < f->arity; ++i )
j += tree_nodes_internal_recurse ( l );
break;
case FUNC_EXPR:
case EVAL_EXPR:
for ( i = 0; i < f->arity; ++i )
{
++*l;
j += tree_nodes_internal_recurse ( l );
}
break;
}
}
return j;
}
/*
* tree_nodes_external: return number of external (terminal) nodes in the
* tree.
*/
int tree_nodes_external ( lnode *data )
{
lnode *l = data;
return tree_nodes_external_recurse ( &l );
}
int tree_nodes_external_recurse ( lnode **l )
{
function *f = (**l).f;
int i, j = 0;
++*l;
if ( f->arity == 0 )
{
if ( f->ephem_gen )
++*l;
return 1;
}
else
{
switch ( f->type )
{
case FUNC_DATA:
case EVAL_DATA:
for ( i = 0; i < f->arity; ++i )
j += tree_nodes_external_recurse ( l ) ;
break;
case FUNC_EXPR:
case EVAL_EXPR:
for ( i = 0; i < f->arity; ++i )
{
++*l;
j += tree_nodes_external_recurse ( l ) ;
}
break;
}
}
return j;
}
/*
* print_tree_array: print the tree, as an array, on stdout. primarily
* for debugging.
*/
void print_tree_array ( lnode *data )
{
lnode *l = data;
int i = 0;
print_tree_array_recurse ( &l, &i );
}
void print_tree_array_recurse ( lnode **l, int *index )
{
function *f = (**l).f;
int i;
fprintf ( stderr, "%3d: function: \"%s\"\n", *index, f->string );
++*l;
++*index;
if ( f->arity == 0 )
{
if ( f->ephem_gen )
{
fprintf ( stderr, "%3d: value: %s\n", *index, (f->ephem_str)((**l).d->d) );
++*l;
++*index;
}
}
else
{
switch ( f->type )
{
case FUNC_DATA:
case EVAL_DATA:
for ( i = 0; i < f->arity; ++i )
{
print_tree_array_recurse ( l, index );
}
break;
case FUNC_EXPR:
case EVAL_EXPR:
for ( i = 0; i < f->arity; ++i )
{
fprintf ( stderr, "%3d: {skip %d}\n", *index, (**l).s );
++*l;
++*index;
print_tree_array_recurse ( l, index );
}
break;
}
}
}
/*
* print_tree: print the tree, as a LISP S-expression, to the given FILE *.
*/
void print_tree ( lnode *data, FILE *fil )
{
lnode *c = data;
print_tree_recurse ( &c, fil );
fprintf ( fil, "\n" );
}
void print_tree_recurse ( lnode **l, FILE *fil )
{
function *f;
int i;
f = (**l).f;
fprintf ( fil, " " );
if ( f->arity != 0 )
fprintf ( fil, "(" );
++*l;
if ( f->ephem_gen )
{
fprintf ( fil, "%s", (f->ephem_str)((**l).d->d) );
#ifdef DEBUG
fprintf ( fil, " <%d>", (**l).d->refcount );
#endif
++*l;
}
else
fprintf ( fil, "%s", f->string );
switch ( f->type )
{
case FUNC_DATA:
case EVAL_DATA:
for ( i = 0; i < f->arity; ++i )
{
print_tree_recurse ( l, fil );
}
break;
case FUNC_EXPR:
case EVAL_EXPR:
for ( i = 0; i < f->arity; ++i )
{
#ifdef DEBUG
fprintf ( fil, " {skip %d}", (**l).s );
#endif
++*l;
print_tree_recurse ( l, fil );
}
break;
}
if ( f->arity != 0 )
fprintf ( fil, ")" );
}
/*
* generate_random_full_tree: generates, in the given generation space,
* a random full tree of the specified depth.
*/
int generate_random_full_tree ( int space, int depth, function_set *fset, int return_type )
{
int i, j;
int save, used_save, is_expr;
int c_nval, *f_used, f_num_used, f_this;
int notvalid = 0;
/* Reached maximum depth so choose terminal */
if ( depth == 0 )
{
/* Check if a terminal exists for this type */
if ( fset->terminal_count_by_type[return_type] == 0 )
return 1;
/* Randomly select the terminal and add it to the tree */
i = random_int(&globrand, fset->terminal_count_by_type[return_type])+
(fset->function_count_by_type[return_type]);
gensp_next(space)->f = (fset->cset_by_type[return_type])+i;
/* if this terminal is an ERC, then generate one and store it. */
if ( (fset->cset_by_type[return_type])[i].ephem_gen )
gensp_next(space)->d = new_ephemeral_const
( (fset->cset_by_type[return_type])+i );
/* Tree is OK */
return 0;
}
/* Check if a function of this type exists */
if ( fset->function_count_by_type[return_type] == 0 )
return 1;
/* Possible function so init function used array */
f_used = (int *) malloc ((fset->function_count_by_type[return_type]) * sizeof(int));
for ( i = 0; i < fset->function_count_by_type[return_type]; ++i )
f_used[i] = 0;
f_num_used = 0;
/* Get a ptr to the next free lnode */
f_this = gensp_next_int(space);
/* Save our position in the genspace */
used_save = gensp[space].used;
/* Try to generate a tree to attach to parent node */
do
{
/* Reset to possibly valid */
notvalid = 0;
/* Check if any more functions exist */
if ( f_num_used >= fset->function_count_by_type[return_type] )
{
/* Unuse the function we recieved */
--gensp[space].used;
return 1;
}
/* Generate unique function (not at depth 0) */
do {
i = random_int(&globrand, fset->function_count_by_type[return_type]);
} while ( f_used[i] );
/* Mark function used */
f_used[i] = 1;
++f_num_used;
/* Setup function in genspace */
gensp[space].data[f_this].f = (fset->cset_by_type[return_type])+i;
/* Check if this is a EXPR type function */
is_expr = gensp[space].data[f_this].f->type;
is_expr = (is_expr == FUNC_EXPR || is_expr == EVAL_EXPR);
/* now generate the node's children. */
for ( j = 0; j < gensp[space].data[f_this].f->arity; ++j )
{
/* if this is a EXPR function then get a location for the skip node */
if ( is_expr )
save = gensp_next_int ( space );
/* generate a full tree of depth [depth-1]. */
c_nval = generate_random_full_tree ( space, depth - 1, fset,
gensp[space].data[f_this].f->argument_type[j]);
/* save the size of the subtree in the skip node, if we need to. */
if ( is_expr )
gensp[space].data[save].s = gensp[space].used - save - 1;
/* if one child is not creatable then quit */
if ( c_nval )
{
/* Roll back in genspace to before children created */
gensp[space].used = used_save;
notvalid = 1;
break;
}
}
} while ( notvalid );
/* Tree is OK */
return 0;
}
/*
* generate_random_grow_tree: grow a random tree, of (maximum) depth [depth].
* works just like genereate_random_full_tree, except that a node with
* depth > 0 can be a terminal.
*/
int generate_random_grow_tree ( int space, int depth, function_set *fset, int return_type )
{
int i, j;
int save, used_save, is_expr;
int c_nval, *f_used, f_num_used, f_this;
int notvalid = 0;
int num_node = fset->function_count_by_type[return_type]+fset->terminal_count_by_type[return_type];
int num_func = fset->function_count_by_type[return_type];
int sel_term = 0;
/* Calculate whether a function or terminal is selected */
if ( random_double ( &globrand ) >= (double) num_func / (double) num_node )
sel_term = 1;
/* Reached maximum depth so choose terminal */
if ( depth == 0 || sel_term )
{
/* Check if a terminal exists for this type */
if ( fset->terminal_count_by_type[return_type] == 0 )
return 1;
i = random_int(&globrand, fset->terminal_count_by_type[return_type])+
(fset->function_count_by_type[return_type]);
gensp_next(space)->f = (fset->cset_by_type[return_type])+i;
if ( (fset->cset_by_type[return_type])[i].ephem_gen )
gensp_next(space)->d = new_ephemeral_const ( (fset->cset_by_type[return_type])+i );
/* Tree OK */
return 0;
}
/* Check if a function of this type exists */
if ( fset->function_count_by_type[return_type] == 0 )
return 1;
/* Possible function so init function used array */
f_used = (int *) malloc ((fset->function_count_by_type[return_type]) * sizeof(int));
for ( i = 0; i < fset->function_count_by_type[return_type]; ++i )
f_used[i] = 0;
f_num_used = 0;
/* Get a ptr to the next free lnode */
f_this = gensp_next_int(space);
/* Save our position in the genspace */
used_save = gensp[space].used;
/* Try to generate a tree to attach to parent node */
do
{
/* Reset to possibly valid */
notvalid = 0;
/* Check if any more functions exist */
if ( f_num_used >= fset->function_count_by_type[return_type] )
{
/* Unuse the function we recieved */
--gensp[space].used;
return 1;
}
/* Generate unique function (not at depth 0) */
do {
i = random_int(&globrand, fset->function_count_by_type[return_type]);
} while ( f_used[i] );
/* Mark function used */
f_used[i] = 1;
++f_num_used;
/* Setup function in genspace */
gensp[space].data[f_this].f = (fset->cset_by_type[return_type])+i;
/* Check if this is a EXPR type function */
is_expr = gensp[space].data[f_this].f->type;
is_expr = (is_expr == FUNC_EXPR || is_expr == EVAL_EXPR);
/* now generate the node's children. */
for ( j = 0; j < gensp[space].data[f_this].f->arity; ++j )
{
/* if this is a EXPR function then get a location for the skip node */
if ( is_expr )
save = gensp_next_int ( space );
/* generate a full tree of depth [depth-1]. */
c_nval = generate_random_grow_tree ( space, depth - 1, fset,
gensp[space].data[f_this].f->argument_type[j]);
/* save the size of the subtree in the skip node, if we need to. */
if ( is_expr )
gensp[space].data[save].s = gensp[space].used - save - 1;
/* if one child is not creatable then quit */
if ( c_nval )
{
/* Roll back in genspace to before children created */
gensp[space].used = used_save;
notvalid = 1;
break;
}
}
} while ( notvalid );
/* Tree OK */
return 0;
}
/*
* tree_depth: return the depth of the tree. a tree with one node has
* depth 0.
*/
int tree_depth ( lnode *data )
{
lnode *l = data;
return tree_depth_recurse ( &l );
}
int tree_depth_recurse ( lnode **l )
{
function *f = (**l).f;
int i, j, k = 0;
++*l;
if ( f->arity == 0 )
{
/* a terminal node; advance the pointer and return 0. */
if ( f->ephem_gen )
++*l;
return 0;
}
/* a nonterminal; find the deepest child and return its depth plus one. */
switch ( f->type )
{
case FUNC_DATA:
case EVAL_DATA:
for ( i = 0; i < f->arity; ++i )
{
j = tree_depth_recurse ( l );
if ( j > k )
k = j;
}
break;
case FUNC_EXPR:
case EVAL_EXPR:
for ( i = 0; i < f->arity; ++i )
{
++*l;
j = tree_depth_recurse ( l );
if ( j > k )
k = j;
}
break;
}
return k+1;
}
int tree_depth_to_subtree ( lnode *data, lnode *sub )
{
lnode *l = data;
return tree_depth_to_subtree_recurse ( &l, sub, 0 );
}
int tree_depth_to_subtree_recurse ( lnode **l, lnode *sub, int depth )
{
function *f = (**l).f;
int i, j;
if ( *l == sub )
return depth;
++*l;
if ( f->arity == 0 )
{
if ( f->ephem_gen )
++*l;
return -1;
}
switch ( f->type )
{
case FUNC_DATA:
case EVAL_DATA:
for ( i = 0; i < f->arity; ++i )
{
j = tree_depth_to_subtree_recurse ( l, sub, depth+1 );
if ( j != -1 )
return j;
}
break;
case FUNC_EXPR:
case EVAL_EXPR:
for ( i = 0; i < f->arity; ++i )
{
++*l;
j = tree_depth_to_subtree_recurse ( l, sub, depth+1 );
if ( j != -1 )
return j;
}
break;
}
return -1;
}
/*
* get_subtree: returns the start'th subtree of the tree, where start
* ranges from 0..(nodecount-1). the zeroth subtree is the tree itself.
* the subtrees are returned in preorder.
*/
lnode *get_subtree ( lnode *data, int start )
{
lnode *l = data;
/* initialize a counter with start. the counter is passed by address,
* and so is shared across all recursive calls. it is decremented once
* for every node in the tree -- the current node when it reaches zero
* is returned.
*/
int c = start;
return get_subtree_recurse ( &l, &c );
}
lnode *get_subtree_recurse ( lnode **l, int *c )
{
function *f = (**l).f;
lnode *r;
int i;
/* if the counter is zero, return the current subtree. */
if ( *c == 0 )
return *l;
++*l;
--*c;
if ( f->arity == 0 )
{
/* skip over the terminal nodes. */
if ( f->ephem_gen )
++*l;
}
else
{
/* recurse into this node's children. if one of them returns
* non-NULL, it means that the subtree has been found and the
* return value is immediately propagated up the call chain.
* if all of them return NULL, then the desired subtree is
* not in this subtree and we return NULL. */
switch ( f->type )
{
case FUNC_DATA:
case EVAL_DATA:
for ( i = 0; i < f->arity; ++i )
{
r = get_subtree_recurse ( l, c );
if ( r != NULL )
return r;
}
break;
case FUNC_EXPR:
case EVAL_EXPR:
for ( i = 0; i < f->arity; ++i )
{
++*l;
r = get_subtree_recurse ( l, c );
if ( r != NULL )
return r;
}
break;
}
}
return NULL;
}
/*
* get_subtree_internal: just like get_subtree, but only selects nonterminal
* points. start should range from 0..(internalnodecount-1).
*/
lnode *get_subtree_internal ( lnode *data, int start )
{
lnode *l = data;
int c = start;
return get_subtree_internal_recurse ( &l, &c );
}
lnode *get_subtree_internal_recurse ( lnode **l, int *c )
{
function *f = (**l).f;
int i;
lnode *r;
/* if the current subtree is a terminal node, skip it immediately. */
if ( f->arity == 0 )
{
if ( f->ephem_gen )
++*l;
++*l;
}
else
{
if ( *c == 0 )
return *l;
++*l;
--*c;
switch ( f->type )
{
case FUNC_DATA:
case EVAL_DATA:
for ( i = 0; i < f->arity; ++i )
{
r = get_subtree_internal_recurse ( l, c );
if ( r != NULL )
return r;
}
break;
case FUNC_EXPR:
case EVAL_EXPR:
for ( i = 0; i < f->arity; ++i )
{
++*l;
r = get_subtree_internal_recurse ( l, c );
if ( r != NULL )
return r;
}
break;
}
}
return NULL;
}
/*
* get_subtree_external: just like get_subtree, but only selects terminal
* nodes (that is, 1-node subtrees). start ranges from
* 0..(externalnodecount-1).
*/
lnode *get_subtree_external ( lnode *data, int start )
{
lnode *l = data;
int c = start;
return get_subtree_external_recurse ( &l, &c );
}
lnode *get_subtree_external_recurse ( lnode **l, int *c )
{
function *f = (**l).f;
int i;
lnode *r;
if ( f->arity == 0 )
{
if ( *c == 0 )
return *l;
++*l;
--*c;
if ( f->ephem_gen )
++*l;
}
else
{
++*l;
switch ( f->type )
{
case FUNC_DATA:
case EVAL_DATA:
for ( i = 0; i < f->arity; ++i )
{
r = get_subtree_external_recurse ( l, c );
if ( r != NULL )
return r;
}
break;
case FUNC_EXPR:
case EVAL_EXPR:
for ( i = 0; i < f->arity; ++i )
{
++*l;
r = get_subtree_external_recurse ( l, c );
if ( r != NULL )
return r;
}
break;
}
}
return NULL;
}
/*
* copy_tree: allocates space for and makes a copy of a tree.
*/
void copy_tree ( tree *to, tree *from )
{
to->data = (lnode *)MALLOC ( from->size * sizeof ( lnode ) );
to->size = from->size;
to->nodes = from->nodes;
memcpy ( to->data, from->data, from->size * sizeof ( lnode ) );
}
/*
* free_tree: frees the memory allocated by a tree, and resets variables.
*/
void free_tree ( tree *t )
{
FREE ( t->data );
t->data = NULL;
t->size = -1;
t->nodes = -1;
}
/*
* tree_size: returns the number of lnodes used to store the tree.
* this is equal to
* (node count)+(ERC count)+(conditionally evaluated subtree count).
*/
int tree_size ( lnode *data )
{
lnode *l = data;
return tree_size_recurse ( &l );
}
int tree_size_recurse ( lnode **l )
{
function *f = (**l).f;
int i, j = 1;
++*l;
if ( f->arity == 0 )
{
if ( f->ephem_gen )
{
++*l;
++j;
}
}
else
{
switch ( f->type )
{
case FUNC_DATA:
case EVAL_DATA:
for ( i = 0; i < f->arity; ++i )
j += tree_size_recurse ( l );
break;
case FUNC_EXPR:
case EVAL_EXPR:
for ( i = 0; i < f->arity; ++i )
{
++*l;
++j;
j += tree_size_recurse ( l );
}
break;
}
}
return j;
}
/*
* copy_tree_replace_many: copies a tree, replacing some of its subtrees
* with other subtrees. arguments:
*
* space - the generation space to put the new tree in
* parent - the tree to copy from
* replace - a list of subtrees to replace
* with - a list of subtrees to replace them with
* count - the size of the replace and width arrays
* repcount - returns the number of subtrees replaced
*
* this function starts to recursively copy the "parent" tree to "dest".
* when the recursive copy hits any subtree in the "replace" array,
* the corresponding subtree in the "with" array is copied in its
* place. repcount returns the number of subtrees that were hit and
* replaced. this can be less than count, as some subtrees may never
* be found (if, for instance, one of the subtrees in the "replace"
* array is the subtree of another).
*/
void copy_tree_replace_many ( int space, lnode *parent, lnode **replace,
lnode **with, int count, int *repcount )
{
lnode *lp = parent;
gensp_reset ( space );
*repcount = 0;
copy_tree_replace_many_recurse ( space, &lp, replace,
with, count, repcount );
}
void copy_tree_replace_many_recurse ( int space, lnode **lp, lnode **lr,
lnode **lw, int count, int *repcount )
{
function *f = (**lp).f;
int i;
int save;
lnode *new;
/* only do the comparison if the lr is non-NULL. */
if ( lr )
{
/* check the current subtree against everything in the lr array. */
for ( i = 0; i < count; ++i )
if ( *lp == lr[i] )
{
/* we have a match! */
/* increment the replacement count. */
++*repcount;
/* copy the new tree into the destination. note that the
* lr and lw arguments are passed as NULL to prevent
* further replacement within the replacement tree.
*/
new = lw[i];
copy_tree_replace_many_recurse ( space, &new, NULL,
NULL, count, repcount );
/* now skip the lp pointer over the lr subtree. */
skip_over_subtree ( lp );
return;
}
}
/* copy the node from the parent to the destination. */
gensp_next(space)->f = (**lp).f;
++*lp;
if ( f->arity == 0 )
{
if ( f->ephem_gen )
{
/* copy the ERC pointer. */
gensp_next(space)->d = (**lp).d;
++*lp;
}
}
else
{
switch ( f->type )
{
case FUNC_DATA:
case EVAL_DATA:
for ( i = 0; i < f->arity; ++i )
{
copy_tree_replace_many_recurse ( space, lp, lr, lw,
count, repcount );
}
break;
case FUNC_EXPR:
case EVAL_EXPR:
for ( i = 0; i < f->arity; ++i )
{
/* note that we just can't copy the skip value, since
* replacement within the subtree may change it. we
* have to save where it is needed and fill it in
* afterwards, just like generate_random_full_tree(). */
save = gensp_next_int ( space );
++*lp;
copy_tree_replace_many_recurse ( space, lp, lr, lw,
count, repcount );
gensp[space].data[save].s = gensp[space].used-save-1;
}
break;
}
}
return;
}
/*
* skip_over_subtree: takes a traversal pointer and skips it over the
* subtree it points to.
*/
void skip_over_subtree ( lnode **l )
{
function *f = (**l).f;
int i;
++*l;
if ( f->arity == 0 )
{
if ( f->ephem_gen )
++*l;
}
else
{
switch ( f->type )
{
case FUNC_DATA:
case EVAL_DATA:
for ( i = 0; i < f->arity; ++i )
skip_over_subtree ( l );
break;
case FUNC_EXPR:
case EVAL_EXPR:
for ( i = 0; i < f->arity; ++i )
{
++*l;
skip_over_subtree ( l );
}
break;
}
}
return;
}
/*
* reference_ephem_constants: traverses a tree, adding "count" to the
* refcount of each ERC that is used within the tree.
*/
void reference_ephem_constants ( lnode *data, int count )
{
lnode *l = data;
reference_ephem_constants_recurse ( &l, count );
}
void reference_ephem_constants_recurse ( lnode **l, int count )
{
function *f = (**l).f;
int i;
++*l;
if ( f->arity == 0 )
{
if ( f->ephem_gen )
{
if ( (**l).d )
{
(**l).d->refcount += count;
++*l;
}
else
error ( E_FATAL_ERROR, "aarg: this can't happen." );
}
}
else
{
switch ( f->type )
{
case FUNC_DATA:
case EVAL_DATA:
for ( i = 0; i < f->arity; ++i )
reference_ephem_constants_recurse ( l, count );
break;
case FUNC_EXPR:
case EVAL_EXPR:
for ( i = 0; i < f->arity; ++i )
{
++*l;
reference_ephem_constants_recurse ( l, count );
}
break;
}
}
}