/*
NAME {* fdd\_makeset *}
SECTION {* fdd *}
SHORT {* creates a variable set for N finite domain blocks *}
PROTO {* BDD fdd_makeset(int *varset, int varnum) *}
DESCR {* Returns a BDD defining all the variable sets used to define
the variable blocks in the array {\tt varset}. The argument
{\tt varnum} defines the size of {\tt varset}. *}
RETURN {* The correct BDD or the constant false on errors. *}
ALSO {* fdd\_ithset, bdd\_makeset *}
*/
BDD fdd_makeset(int *varset, int varnum)
{
BDD res=bddtrue, tmp;
int n;
if (!bddrunning)
{
bdd_error(BDD_RUNNING);
return bddfalse;
}
for (n=0 ; n<varnum ; n++)
if (varset[n] < 0 || varset[n] >= fdvarnum)
{
bdd_error(BDD_VAR);
return bddfalse;
}
for (n=0 ; n<varnum ; n++)
{
bdd_addref(res);
tmp = bdd_apply(domain[varset[n]].var, res, bddop_and);
bdd_delref(res);
res = tmp;
}
return res;
}
void fdd_fprintset(FILE *ofile, BDD r)
{
int *set;
if (!bddrunning)
{
bdd_error(BDD_RUNNING);
return;
}
if (r < 2)
{
fprintf(ofile, "%s", r == 0 ? "F" : "T");
return;
}
set = (int *)malloc(sizeof(int)*bddvarnum);
if (set == NULL)
{
bdd_error(BDD_MEMORY);
return;
}
memset(set, 0, sizeof(int) * bddvarnum);
fdd_printset_rec(ofile, r, set);
free(set);
}
/*
NAME {* fdd\_intaddvarblock *}
SECTION {* fdd *}
SHORT {* adds a new variable block for reordering *}
PROTO {* int fdd_intaddvarblock(int first, int last, int fixed) *}
DESCR {* Works exactly like {\tt bdd\_addvarblock} except that
{\tt fdd\_intaddvarblock} takes a range of FDD variables
instead of BDD variables. *}
RETURN {* Zero on success, otherwise a negative error code. *}
ALSO {* bdd\_addvarblock, bdd\_intaddvarblock, bdd\_reorder *}
*/
int fdd_intaddvarblock(int first, int last, int fixed)
{
bdd res = bddtrue, tmp;
int n, err;
if (!bddrunning)
return bdd_error(BDD_RUNNING);
if (first > last || first < 0 || last >= fdvarnum)
return bdd_error(BDD_VARBLK);
for (n=first ; n<=last ; n++)
{
bdd_addref(res);
tmp = bdd_apply(domain[n].var, res, bddop_and);
bdd_delref(res);
res = tmp;
}
bdd_addref(res); /* Added by Jaco van de Pol, 25 march 2010 */
err = bdd_addvarblock(res, fixed);
bdd_delref(res);
return err;
}
int bdd_load(FILE *ifile, BDD *root)
{
int n, vnum, tmproot;
while (1) {
int c = getc(ifile);
if (c == '#') {
char s[10000];
fgets(s, 10000, ifile);
} else {
ungetc(c, ifile);
break;
}
}
if (fscanf(ifile, "%d %d", &lh_nodenum, &vnum) != 2)
return bdd_error(BDD_FORMAT);
/* Check for constant true / false */
if (lh_nodenum==0 && vnum==0)
{
fscanf(ifile, "%d", root);
return 0;
}
if ((loadvar2level=(int*)malloc(sizeof(int)*vnum)) == NULL)
return bdd_error(BDD_MEMORY);
for (n=0 ; n<vnum ; n++)
fscanf(ifile, "%d", &loadvar2level[n]);
if (vnum > bddvarnum)
bdd_setvarnum(vnum);
if ((lh_table=(LoadHash*)malloc(lh_nodenum*sizeof(LoadHash))) == NULL)
return bdd_error(BDD_MEMORY);
for (n=0 ; n<lh_nodenum ; n++)
{
lh_table[n].first = -1;
lh_table[n].next = n+1;
}
lh_table[lh_nodenum-1].next = -1;
lh_freepos = 0;
tmproot = bdd_loaddata(ifile);
for (n=0 ; n<lh_nodenum ; n++)
bdd_delref(lh_table[n].data);
free(lh_table);
free(loadvar2level);
*root = 0;
if (tmproot < 0)
return tmproot;
else
*root = tmproot;
return 0;
}
/*
NAME {* fdd\_varnum *}
SECTION {* fdd *}
SHORT {* binary size of a finite domain block *}
PROTO {* int fdd_varnum(int var) *}
DESCR {* Returns the number of BDD variables used for the finite domain
block {\tt var}. *}
RETURN {* The number of variables or a negative error code *}
ALSO {* fdd\_vars *}
*/
int fdd_varnum(int v)
{
if (!bddrunning)
return bdd_error(BDD_RUNNING);
if (v >= fdvarnum || v < 0)
return bdd_error(BDD_VAR);
return domain[v].binsize;
}
/*
NAME {* fdd\_domainsize *}
SECTION {* fdd *}
SHORT {* real size of a finite domain block *}
PROTO {* int fdd_domainsize(int var) *}
DESCR {* Returns the size of the domain for the finite domain
block {\tt var}. *}
RETURN {* The size or a negative error code *}
ALSO {* fdd\_domainnum *}
*/
int fdd_domainsize(int v)
{
if (!bddrunning)
return bdd_error(BDD_RUNNING);
if (v < 0 || v >= fdvarnum)
return bdd_error(BDD_VAR);
return domain[v].realsize;
}
/*
NAME {* bdd\_addref *}
SECTION {* kernel *}
SHORT {* increases the reference count on a node *}
PROTO {* BDD bdd_addref(BDD r) *}
DESCR {* Reference counting is done on externaly referenced nodes only
and the count for a specific node {\tt r} can and must be
increased using this function to avoid loosing the node in the next
garbage collection. *}
ALSO {* bdd\_delref *}
RETURN {* The BDD node {\tt r}. *}
*/
BDD bdd_addref(BDD root)
{
if (root < 2 || !bddrunning)
return root;
if (root >= bddnodesize)
return bdd_error(BDD_ILLBDD);
if (LOW(root) == -1)
return bdd_error(BDD_ILLBDD);
INCREF(root);
return root;
}
BDD bdd_addref_nc(BDD root)
{
#ifndef NDEBUG
if (!bddrunning)
return root;
if (root < 2 || root >= bddnodesize)
return bdd_error(BDD_ILLBDD);
if (LOW(root) == -1)
return bdd_error(BDD_ILLBDD);
#endif
INCREF(root);
return root;
}
/*
NAME {* bdd\_addref *}
SECTION {* kernel *}
SHORT {* increases the reference count on a node *}
PROTO {* BDD bdd_addref(BDD r) *}
DESCR {* Reference counting is done on externaly referenced nodes only
and the count for a specific node {\tt r} can and must be
increased using this function to avoid loosing the node in the next
garbage collection. *}
ALSO {* bdd\_delref *}
RETURN {* The BDD node {\tt r}. *}
*/
BDD bdd_addref(BDD root)
{
BUDDY_PROLOGUE;
ADD_ARG1(T_BDD,root);
if (root < 2 || !bddrunning)
RETURN_BDD(root);
if (root >= bddnodesize)
RETURN_BDD(bdd_error(BDD_ILLBDD));
if (LOW(root) == INVALID_BDD)
RETURN_BDD(bdd_error(BDD_ILLBDD));
INCREF(root);
RETURN_BDD(root);
}
/*
NAME {* bdd\_delref *}
SECTION {* kernel *}
SHORT {* decreases the reference count on a node *}
PROTO {* BDD bdd_delref(BDD r) *}
DESCR {* Reference counting is done on externaly referenced nodes only
and the count for a specific node {\tt r} can and must be
decreased using this function to make it possible to reclaim the
node in the next garbage collection. *}
ALSO {* bdd\_addref *}
RETURN {* The BDD node {\tt r}. *}
*/
BDD bdd_delref(BDD root)
{
if (root < 2 || !bddrunning)
return root;
if (root >= bddnodesize)
return bdd_error(BDD_ILLBDD);
if (LOW(root) == -1)
return bdd_error(BDD_ILLBDD);
/* if the following line is present, fails there much earlier */
if (!HASREF(root)) bdd_error(BDD_BREAK); /* distinctive */
DECREF(root);
return root;
}
/*
NAME {* fdd\_scanset *}
SECTION {* fdd *}
SHORT {* scans a variable set *}
PROTO {* int fdd_scanset(BDD r, int **varset, int *varnum) *}
DESCR {* Scans the BDD {\tt r} to find all occurences of FDD variables
and then stores these in {\tt varset}. {\tt varset} will be set
to point to an array of size {\tt varnum} which will contain
the indices of the found FDD variables. It is the users
responsibility to free {\tt varset} after use. *}
RETURN {* Zero on success or a negative error code on error. *}
ALSO {* fdd\_makeset *}
*/
int fdd_scanset(BDD r, int **varset, int *varnum)
{
int *fv, fn;
int num,n,m,i;
if (!bddrunning)
return bdd_error(BDD_RUNNING);
if ((n=bdd_scanset(r, &fv, &fn)) < 0)
return n;
for (n=0,num=0 ; n<fdvarnum ; n++)
{
int found=0;
for (m=0 ; m<domain[n].binsize && !found ; m++)
{
for (i=0 ; i<fn && !found ; i++)
if (domain[n].ivar[m] == fv[i])
{
num++;
found=1;
}
}
}
if ((*varset=(int*)malloc(sizeof(int)*num)) == NULL)
return bdd_error(BDD_MEMORY);
for (n=0,num=0 ; n<fdvarnum ; n++)
{
int found=0;
for (m=0 ; m<domain[n].binsize && !found ; m++)
{
for (i=0 ; i<fn && !found ; i++)
if (domain[n].ivar[m] == fv[i])
{
(*varset)[num++] = n;
found=1;
}
}
}
*varnum = num;
return 0;
}
/*
NAME {* fdd\_vars *}
SECTION {* fdd *}
SHORT {* all BDD variables associated with a finite domain block *}
PROTO {* int *fdd_vars(int var) *}
DESCR {* Returns an integer array containing the BDD variables used to
define the finite domain block {\tt var}. The size of the array
is the number of variables used to define the finite domain block.
The array will have the Least Significant Bit at pos 0. The
array must {\em not} be deallocated. *}
RETURN {* Integer array contaning the variable numbers or NULL if
{\tt v} is an unknown block. *}
ALSO {* fdd\_varnum *}
*/
int *fdd_vars(int v)
{
if (!bddrunning)
{
bdd_error(BDD_RUNNING);
return NULL;
}
if (v >= fdvarnum || v < 0)
{
bdd_error(BDD_VAR);
return NULL;
}
return domain[v].ivar;
}
/*
NAME {* bdd\_scanset *}
SECTION {* kernel *}
SHORT {* returns an integer representation of a variable set *}
PROTO {* int bdd_scanset(BDD r, int **v, int *n) *}
DESCR {* Scans a variable set {\tt r} and copies the stored variables into
an integer array of variable numbers. The argument {\tt v} is
the address of an integer pointer where the array is stored and
{\tt n} is a pointer to an integer where the number of elements
are stored. It is the users responsibility to make sure the
array is deallocated by a call to {\tt free(v)}. The numbers
returned are guaranteed to be in ascending order. *}
ALSO {* bdd\_makeset *}
RETURN {* Zero on success, otherwise a negative error code. *}
*/
int bdd_scanset(BDD r, int **varset, int *varnum)
{
int n, num;
CHECK(r);
if (r < 2)
{
*varnum = 0;
*varset = NULL;
return 0;
}
for (n=r, num=0 ; n > 1 ; n=HIGH(n))
num++;
if (((*varset) = (int *)malloc(sizeof(int)*num)) == NULL)
return bdd_error(BDD_MEMORY);
for (n=r, num=0 ; n > 1 ; n=HIGH(n))
(*varset)[num++] = bddlevel2var[LEVEL(n)];
*varnum = num;
return 0;
}
/*
NAME {* fdd\_ithset *}
SECTION {* fdd *}
SHORT {* the variable set for the i'th finite domain block *}
PROTO {* BDD fdd_ithset(int var) *}
DESCR {* Returns the variable set that contains the variables used to
define the finite domain block {\tt var}. *}
RETURN {* The variable set or the constant false BDD on error. *}
ALSO {* fdd\_ithvar *}
*/
BDD fdd_ithset(int var)
{
if (!bddrunning)
{
bdd_error(BDD_RUNNING);
return bddfalse;
}
if (var < 0 || var >= fdvarnum)
{
bdd_error(BDD_VAR);
return bddfalse;
}
return domain[var].var;
}
/*
NAME {* fdd\_domainnum *}
SECTION {* fdd *}
SHORT {* number of defined finite domain blocks *}
PROTO {* int fdd_domainnum(void) *}
DESCR {* Returns the number of finite domain blocks define by calls to
{\tt bdd\_extdomain}. *}
RETURN {* The number of defined finite domain blocks
or a negative error code *}
ALSO {* fdd\_domainsize, fdd\_extdomain *}
*/
int fdd_domainnum(void)
{
if (!bddrunning)
return bdd_error(BDD_RUNNING);
return fdvarnum;
}
int bdd_duplicatevar(int var) {
int newVar, lev, i, bdv;
if (var < 0 || var >= bddvarnum) {
bdd_error(BDD_VAR);
return bddfalse;
}
bdd_disable_reorder();
newVar = bddvarnum;
lev = bddvar2level[var];
bdd_setvarnum(bddvarnum+1);
insert_level(lev);
dup_level(lev, 0);
for (i = 0; i < bddvarnum; ++i) {
if (bddvar2level[i] > lev && bddvar2level[i] < bddvarnum)
++bddvar2level[i];
}
bddvar2level[newVar] = lev+1;
for (i = bddvarnum-2; i > lev; --i) {
bddlevel2var[i+1] = bddlevel2var[i];
}
bddlevel2var[lev+1] = newVar;
for (bdv = 0; bdv < bddvarnum; bdv++) {
bddvarset[bdv * 2] = PUSHREF(bdd_makenode(bddvar2level[bdv], 0, 1));
bddvarset[bdv * 2 + 1] = bdd_makenode(bddvar2level[bdv], 1, 0);
POPREF(1);
SETMAXREF(bddvarset[bdv * 2]);
SETMAXREF(bddvarset[bdv * 2 + 1]);
}
fixup_pairs(lev, newVar);
bdd_enable_reorder();
return newVar;
}
/*
NAME {* bdd\_high *}
SECTION {* info *}
SHORT {* gets the true branch of a bdd *}
PROTO {* BDD bdd_high(BDD r) *}
DESCR {* Gets the true branch of the bdd {\tt r}. *}
RETURN {* The bdd of the true branch *}
ALSO {* bdd\_low *}
*/
BDD bdd_high(BDD root)
{
CHECK(root);
if (root < 2)
return bdd_error(BDD_ILLBDD);
return (HIGH(root));
}
/*
NAME {* bdd\_low *}
SECTION {* info *}
SHORT {* gets the false branch of a bdd *}
PROTO {* BDD bdd_low(BDD r) *}
DESCR {* Gets the false branch of the bdd {\tt r}. *}
RETURN {* The bdd of the false branch *}
ALSO {* bdd\_high *}
*/
BDD bdd_low(BDD root)
{
CHECK(root);
if (root < 2)
return bdd_error(BDD_ILLBDD);
return (LOW(root));
}
/*
NAME {* bdd\_var *}
SECTION {* info *}
SHORT {* gets the variable labeling the bdd *}
PROTO {* int bdd_var(BDD r) *}
DESCR {* Gets the variable labeling the bdd {\tt r}. *}
RETURN {* The variable number. *}
*/
int bdd_var(BDD root)
{
CHECK(root);
if (root < 2)
return bdd_error(BDD_ILLBDD);
return (bddlevel2var[LEVEL(root)]);
}
/*
NAME {* fdd\_setpairs *}
SECTION {* fdd *}
SHORT {* defines N pairs for finite domain blocks *}
PROTO {* int fdd_setpairs(bddPair *pair, int *p1, int *p2, int size) *}
DESCR {* Defines each variable in all the finite domain blocks listed in
the array {\tt p1} to be paired with the corresponding variable
in {\tt p2}. The result
is stored in {\tt pair} which must be allocated using
{\tt bdd\_makeset}.*}
RETURN {* Zero on success or a negative error code on error. *}
ALSO {* bdd\_setpair *}
*/
int fdd_setpairs(bddPair *pair, int *p1, int *p2, int size)
{
int n,e;
if (!bddrunning)
return bdd_error(BDD_RUNNING);
for (n=0 ; n<size ; n++)
if (p1[n]<0 || p1[n]>=fdvarnum || p2[n]<0 || p2[n]>=fdvarnum)
return bdd_error(BDD_VAR);
for (n=0 ; n<size ; n++)
if ((e=fdd_setpair(pair, p1[n], p2[n])) < 0)
return e;
return 0;
}
int bdd_fnprintdot(char *fname, BDD r)
{
FILE *ofile = fopen(fname, "w");
if (ofile == NULL)
return bdd_error(BDD_FILE);
bdd_fprintdot(ofile, r);
fclose(ofile);
return 0;
}
/*
NAME {* bdd\_nithvar *}
SECTION {* kernel *}
SHORT {* returns a bdd representing the negation of the I'th variable *}
PROTO {* BDD bdd_nithvar(int var) *}
DESCR {* This function is used to get a bdd representing the negation of
the I'th variable (one node with the childs false and true).
The requested variable must be in the range define by
{\tt bdd\_setvarnum} starting with 0 being the first. For ease of
use then the bdd returned from {\tt bdd\_nithvar} does not have
to be referenced counted with a call to {\tt bdd\_addref}. *}
RETURN {* The negated I'th variable on succes, otherwise the constant false bdd *}
ALSO {* bdd\_setvarnum, bdd\_ithvar, bddtrue, bddfalse *}
*/
BDD bdd_nithvar(int var)
{
if (var < 0 || var >= bddvarnum)
{
bdd_error(BDD_VAR);
return bddfalse;
}
return bddvarset[var*2+1];
}
/*
NAME {* bdd\_setminfreenodes *}
SECTION {* kernel *}
SHORT {* set min. no. of nodes to be reclaimed after GBC. *}
PROTO {* int bdd_setminfreenodes(int n) *}
DESCR {* Whenever a garbage collection is executed the number of free
nodes left are checked to see if a resize of the node table is
required. If $X = (\mathit{bddfreenum}*100)/\mathit{maxnum}$
is less than or
equal to {\tt n} then a resize is initiated. The range of
{\tt X} is of course $0\ldots 100$ and has some influence
on how fast the package is. A low number means harder attempts
to avoid resizing and saves space, and a high number reduces
the time used in garbage collections. The default value is
20. *}
RETURN {* The old threshold on succes, otherwise a negative error code. *}
ALSO {* bdd\_setmaxnodenum, bdd\_setmaxincrease *}
*/
int bdd_setminfreenodes(int mf)
{
int old = minfreenodes;
if (mf<0 || mf>100)
return bdd_error(BDD_RANGE);
minfreenodes = mf;
return old;
}
/*
NAME {* bdd\_setmaxincrease *}
SECTION {* kernel *}
SHORT {* set max. number of nodes used to increase node table *}
PROTO {* int bdd_setmaxincrease(int size) *}
DESCR {* The node table is expanded by doubling the size of the table
when no more free nodes can be found, but a maximum for the
number of new nodes added can be set with {\tt bdd\_maxincrease}
to {\tt size} nodes. The default is 50000 nodes (1 Mb). *}
RETURN {* The old threshold on succes, otherwise a negative error code. *}
ALSO {* bdd\_setmaxnodenum, bdd\_setminfreenodes *}
*/
int bdd_setmaxincrease(int size)
{
int old = bddmaxnodeincrease;
if (size < 0)
return bdd_error(BDD_SIZE);
bddmaxnodeincrease = size;
return old;
}
/*
NAME {* bdd\_extvarnum *}
SECTION {* kernel *}
SHORT {* add extra BDD variables *}
PROTO {* int bdd_extvarnum(int num) *}
DESCR {* Extends the current number of allocated BDD variables with
{\tt num} extra variables. *}
RETURN {* The old number of allocated variables or a negative error code. *}
ALSO {* bdd\_setvarnum, bdd\_ithvar, bdd\_nithvar *}
*/
int bdd_extvarnum(int num)
{
int start = bddvarnum;
if (num < 0 || num > 0x3FFFFFFF)
return bdd_error(BDD_RANGE);
bdd_setvarnum(bddvarnum+num);
return start;
}
/*
NAME {* fdd\_setpair *}
SECTION {* fdd *}
SHORT {* defines a pair for two finite domain blocks *}
PROTO {* int fdd_setpair(bddPair *pair, int p1, int p2) *}
DESCR {* Defines each variable in the finite domain block {\tt p1} to
be paired with the corresponding variable in {\tt p2}. The result
is stored in {\tt pair} which must be allocated using
{\tt bdd\_makepair}. *}
RETURN {* Zero on success or a negative error code on error. *}
ALSO {* fdd\_setpairs *}
*/
int fdd_setpair(bddPair *pair, int p1, int p2)
{
int n,e;
if (!bddrunning)
return bdd_error(BDD_RUNNING);
if (p1<0 || p1>=fdvarnum || p2<0 || p2>=fdvarnum)
return bdd_error(BDD_VAR);
if (domain[p1].binsize != domain[p2].binsize)
return bdd_error(BDD_VARNUM);
for (n=0 ; n<domain[p1].binsize ; n++)
if ((e=bdd_setpair(pair, domain[p1].ivar[n], domain[p2].ivar[n])) < 0)
return e;
return 0;
}
/*
NAME {* fdd\_domain *}
SECTION {* fdd *}
SHORT {* BDD encoding of the domain of a FDD variable *}
PROTO {* BDD fdd_domain(int var) *}
DESCR {* Returns what corresponds to a disjunction of all possible
values of the variable {\tt var}.
This is more efficient than doing
{\tt fdd\_ithvar(var,0) OR fdd\_ithvar(var,1) ...} explicitely
for all values in the domain of {\tt var}. *}
RETURN {* The encoding of the domain*}
*/
BDD fdd_domain(int var)
{
int n,val;
Domain *dom;
BDD d;
if (!bddrunning)
{
bdd_error(BDD_RUNNING);
return bddfalse;
}
if (var < 0 || var >= fdvarnum)
{
bdd_error(BDD_VAR);
return bddfalse;
}
/* Encode V<=X-1. V is the variables in 'var' and X is the domain size */
dom = &domain[var];
val = dom->realsize-1;
d = bddtrue;
for (n=0 ; n<dom->binsize ; n++)
{
BDD tmp;
if (val & 0x1)
tmp = bdd_apply( bdd_nithvar(dom->ivar[n]), d, bddop_or );
else
tmp = bdd_apply( bdd_nithvar(dom->ivar[n]), d, bddop_and );
val >>= 1;
bdd_addref(tmp);
bdd_delref(d);
d = tmp;
}
return d;
}
/*
NAME {* bdd\_setmaxnodenum *}
SECTION {* kernel *}
SHORT {* set the maximum available number of bdd nodes *}
PROTO {* int bdd_setmaxnodenum(int size) *}
DESCR {* This function sets the maximal number of bdd nodes the package may
allocate before it gives up a bdd operation. The
argument {\tt size} is the absolute maximal number of nodes there
may be allocated for the nodetable. Any attempt to allocate more
nodes results in the constant false being returned and the error
handler being called until some nodes are deallocated.
A value of 0 is interpreted as an unlimited amount.
It is {\em not} possible to specify
fewer nodes than there has already been allocated. *}
RETURN {* The old threshold on succes, otherwise a negative error code. *}
ALSO {* bdd\_setmaxincrease, bdd\_setminfreenodes *}
*/
int bdd_setmaxnodenum(int size)
{
if (size > bddnodesize || size == 0)
{
int old = bddmaxnodesize;
bddmaxnodesize = size;
return old;
}
return bdd_error(BDD_NODES);
}
/*
NAME {* bdd\_delref *}
SECTION {* kernel *}
SHORT {* decreases the reference count on a node *}
PROTO {* BDD bdd_delref(BDD r) *}
DESCR {* Reference counting is done on externaly referenced nodes only
and the count for a specific node {\tt r} can and must be
decreased using this function to make it possible to reclaim the
node in the next garbage collection. *}
ALSO {* bdd\_addref *}
RETURN {* The BDD node {\tt r}. *}
*/
BDD bdd_delref(BDD root)
{
BUDDY_PROLOGUE;
ADD_ARG1(T_BDD,root);
if (root < 2 || !bddrunning)
RETURN_BDD(root);
if (root >= bddnodesize)
RETURN_BDD(bdd_error(BDD_ILLBDD));
if (LOW(root) == INVALID_BDD)
RETURN_BDD(bdd_error(BDD_ILLBDD));
/* if the following line is present, fails there much earlier */
if (!HASREF(root))
bdd_error(BDD_BREAK); /* distinctive */
DECREF(root);
if(!HASREF(root))
trace_del_bdd(T_BDD,(void *)root);
RETURN_BDD(root);
}
/*
NAME {* bdd\_high *}
SECTION {* info *}
SHORT {* gets the true branch of a bdd *}
PROTO {* BDD bdd_high(BDD r) *}
DESCR {* Gets the true branch of the bdd {\tt r}. *}
RETURN {* The bdd of the true branch *}
ALSO {* bdd\_low *}
*/
BDD bdd_high(BDD root)
{
BUDDY_PROLOGUE;
ADD_ARG1(T_BDD,root);
CHECK(root);
if (root < 2)
RETURN_BDD(bdd_error(BDD_ILLBDD));
RETURN_BDD(HIGH(root));
}
