static ord_RESULT rpos_MulGreaterEqual(TERM T1, TERM T2)
/**************************************************************
INPUT: Two terms with equal top symbols and multiset status.
RETURNS: ord_GREATER_THAN if <T1> is greater than <T2>,
ord_EQUAL if both terms are equal and
ord_UNCOMPARABLE otherwise.
***************************************************************/
{
LIST l1, l2;
l1 = rpos_MultisetDifference(T1, T2);
if (list_Empty(l1))
/* If |M| = |N| and M-N = {} then N-M = {} */
return ord_Equal(); /* Terms are equal */
else {
LIST scan;
BOOL greater;
l2 = rpos_MultisetDifference(T2, T1);
for (greater = TRUE; !list_Empty(l2) && greater; l2 = list_Pop(l2)) {
for (scan = l1, greater = FALSE; !list_Empty(scan) && !greater; scan = list_Cdr(scan))
greater = rpos_Greater(list_Car(scan), list_Car(l2));
}
list_Delete(l1); /* l2 was freed in the outer for loop */
if (greater)
return ord_GreaterThan();
else
return ord_Uncomparable();
}
}
static ord_RESULT rpos_MulGreaterEqual(TERM T1, TERM T2, BOOL VarIsConst)
/**************************************************************
INPUT: Two terms with equal top symbols and multiset status.
RETURNS: ord_GREATER_THAN if <T1> is greater than <T2>,
ord_EQUAL if both terms are equal and
ord_UNCOMPARABLE otherwise.
CAUTION: If <VarIsConst> is set then variables are interpreted as constants
with lowest precedence. They are ranked to each other using
their variable index.
***************************************************************/
{
LIST l1, l2;
l1 = rpos_MultisetDifference(T1, T2);
if (list_Empty(l1))
/* If |M| = |N| and M-N = {} then N-M = {} */
return ord_Equal(); /* Terms are equal */
else {
LIST scan;
BOOL greater;
l2 = rpos_MultisetDifference(T2, T1);
for (greater = TRUE; !list_Empty(l2) && greater; l2 = list_Pop(l2)) {
for (scan = l1, greater = FALSE; !list_Empty(scan) && !greater; scan = list_Cdr(scan))
greater = rpos_Greater(list_Car(scan), list_Car(l2), VarIsConst);
}
list_Delete(l1); /* l2 was freed in the outer for loop */
if (greater)
return ord_GreaterThan();
else
return ord_Uncomparable();
}
}
ord_RESULT rpos_CompareAux(TERM T1, TERM T2, BOOL VarIsConst)
/**************************************************************
INPUT: Two terms, a boolean flag indicating if variables
of <T1> and <T2> are interpreted as skolem constants
RETURNS: The relation between the two terms with respect to the
RPOS ordering:
ord_GREATER_THAN if <T1> is greater than <T2>,
ord_EQUAL if both terms are equal,
ord_SMALLER_THAN if <T2> is greater than <T1> and
ord_UNCOMPARABLE otherwise.
CAUTION: The precedence from the order module is used to determine
the precedence of symbols!
If <VarIsConst> is set then variables are interpreted as constants
with lowest precedence. They are ranked to each other using
their variable index.
***************************************************************/
{
ord_RESULT result;
result = rpos_GreaterEqual(T1, T2, VarIsConst);
if (!ord_IsUncomparable(result))
return result;
else if (rpos_Greater(T2, T1, VarIsConst))
return ord_SmallerThan();
else
return ord_UNCOMPARABLE;
}
static ord_RESULT rpos_LexGreaterEqual(TERM T1, TERM T2, BOOL VarIsConst)
/**************************************************************
INPUT: Two terms with equal top symbols and lexicographic status.
RETURNS: ord_GREATER_THAN if <T1> is greater than <T2>,
ord_EQUAL if both terms are equal and
ord_UNCOMPARABLE otherwise.
CAUTION: If <VarIsConst> is set then variables are interpreted as constants
with lowest precedence. They are ranked to each other using
their variable index.
***************************************************************/
{
ord_RESULT result;
LIST l1, l2, scan1, scan2;
if (symbol_HasProperty(term_TopSymbol(T1), ORDRIGHT)) {
l1 = list_Reverse(term_ArgumentList(T1)); /* Create new lists */
l2 = list_Reverse(term_ArgumentList(T2));
} else {
l1 = term_ArgumentList(T1);
l2 = term_ArgumentList(T2);
}
/* First ignore equal arguments */
result = ord_Equal();
for (scan1 = l1, scan2 = l2; !list_Empty(scan1);
scan1 = list_Cdr(scan1), scan2 = list_Cdr(scan2)) {
result = rpos_GreaterEqual(list_Car(scan1), list_Car(scan2), VarIsConst);
if (!ord_IsEqual(result))
break;
}
if (ord_IsEqual(result)) /* All arguments are equal, so the terms */
/* empty */; /* are equal with respect to RPOS */
else if (ord_IsGreaterThan(result)) {
/* Check if T1 > each remaining argument of T2 */
for (scan2 = list_Cdr(scan2); !list_Empty(scan2) &&
rpos_Greater(T1, list_Car(scan2), VarIsConst);
scan2 = list_Cdr(scan2)); /* Empty body */
if (list_Empty(scan2))
result = ord_GreaterThan();
else
result = ord_Uncomparable();
}
else {
/* Argument of T1 was not >= argument of T2. */
/* Try to find an argument of T1 that is >= T2 */
for (scan1 = list_Cdr(scan1), result = ord_Uncomparable();
!list_Empty(scan1) && !ord_IsGreaterThan(result);
scan1 = list_Cdr(scan1)) {
if (!ord_IsUncomparable(rpos_GreaterEqual(list_Car(scan1), T2, VarIsConst)))
result = ord_GreaterThan();
}
}
if (symbol_HasProperty(term_TopSymbol(T1), ORDRIGHT)) {
list_Delete(l1); /* Delete the lists create above */
list_Delete(l2);
}
return result;
}
ord_RESULT rpos_GreaterEqual(TERM T1, TERM T2, BOOL VarIsConst)
/**************************************************************
INPUT: Two terms.
RETURNS: ord_GREATER_THAN if <T1> is greater than <T2>
ord_EQUAL if both terms are equal
ord_UNCOMPARABLE otherwise.
CAUTION: The precedence from the order module is used to determine
the precedence of symbols!
If <VarIsConst> is set then variables are interpreted as constants
with lowest precedence. They are ranked to each other using
their variable index.
***************************************************************/
{
LIST scan;
if (term_IsVariable(T1)) {
if (term_EqualTopSymbols(T1, T2))
return ord_Equal(); /* T2 is the same variable */
else if(VarIsConst && term_IsVariable(T2)) {
if(term_TopSymbol(T1) > term_TopSymbol(T2))
return ord_GreaterThan();
else
return ord_Uncomparable();
}
else
/* A variable can't be greater than another term */
return ord_Uncomparable();
} else if (!VarIsConst && term_IsVariable(T2)) { /* T1 isn't a variable */
if (term_ContainsSymbol(T1, term_TopSymbol(T2)))
return ord_GreaterThan();
else
return ord_Uncomparable();
} else if(VarIsConst && term_IsVariable(T2)){
return ord_GreaterThan();
} else if (term_EqualTopSymbols(T1, T2)) {
if (symbol_HasProperty(term_TopSymbol(T1), ORDMUL))
return rpos_MulGreaterEqual(T1, T2, VarIsConst);
else
return rpos_LexGreaterEqual(T1, T2, VarIsConst);
} else {
if (symbol_PrecedenceGreater(ord_PRECEDENCE, term_TopSymbol(T1),
term_TopSymbol(T2))) {
/* Different top symbols, symbol of T1 > symbol of T2. */
/* Try if T1 > each argument of T2. */
for (scan = term_ArgumentList(T2); !list_Empty(scan); scan = list_Cdr(scan))
if (!rpos_Greater(T1, list_Car(scan), VarIsConst))
return ord_Uncomparable();
return ord_GreaterThan();
} else {
/* Try to find an argument of T1 that is >= T2 */
for (scan = term_ArgumentList(T1); !list_Empty(scan); scan = list_Cdr(scan))
if (!ord_IsUncomparable(rpos_GreaterEqual(list_Car(scan), T2, VarIsConst)))
return ord_GreaterThan(); /* Argument of T1 >= T2 */
return ord_Uncomparable();
}
}
}
ord_RESULT rpos_Compare(TERM T1, TERM T2)
/**************************************************************
INPUT: Two terms.
RETURNS: The relation between the two terms with respect to the
RPOS ordering:
ord_GREATER_THAN if <T1> is greater than <T2>,
ord_EQUAL if both terms are equal,
ord_SMALLER_THAN if <T2> is greater than <T1> and
ord_UNCOMPARABLE otherwise.
CAUTION: The precedence from the order module is used to determine
the precedence of symbols!
***************************************************************/
{
ord_RESULT result;
result = rpos_GreaterEqual(T1, T2);
if (!ord_IsUncomparable(result))
return result;
else if (rpos_Greater(T2, T1))
return ord_SmallerThan();
else
return ord_UNCOMPARABLE;
}
