open-dsi
/
postgres
mirror of https://github.com/postgres/postgres
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

LispUnion routine didn't generate a proper union: anytime

Browse Source 
l2 contained more than one entry, there would be duplicates in the output
list.  Miscellaneous code beautification in other routines, too.
REL7_0_PATCHES
Tom Lane 26 years ago
parent 448d1ab0ad
commit 51e29a2be3
1 changed files with 133 additions and 212 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 333
      src/backend/nodes/list.c

333
src/backend/nodes/list.c
Unescape View File

@ -7,7 +7,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/nodes/list.c,v 1.25 1999/07/17 20:17:06 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/nodes/list.c,v 1.26 1999/08/14 19:29:35 tgl Exp $
*
* NOTES
* XXX a few of the following functions are duplicated to handle
@ -57,6 +57,45 @@ makeList(void *elem,...)
return retval;
}
/*
* makeInteger
*/
Value *
makeInteger(long i)
{
Value *v = makeNode(Value);
v->type = T_Integer;
v->val.ival = i;
return v;
}
/*
* makeFloat
*/
Value *
makeFloat(double d)
{
Value *v = makeNode(Value);
v->type = T_Float;
v->val.dval = d;
return v;
}
/*
* makeString
*/
Value *
makeString(char *str)
{
Value *v = makeNode(Value);
v->type = T_String;
v->val.str = str;
return v;
}
/*
* lcons
*
@ -115,6 +154,9 @@ lappendi(List *list, int datum)
* nconc
*
* Concat l2 on to the end of l1
*
* NB: l1 is destructively changed! Use nconc(listCopy(l1), l2)
* if you need to make a merged list without touching the original lists.
*/
List *
nconc(List *l1, List *l2)
@ -128,76 +170,13 @@ nconc(List *l1, List *l2)
if (l1 == l2)
elog(ERROR, "tryout to nconc a list to itself");
for (temp = l1; lnext(temp) != NULL; temp = lnext(temp))
for (temp = l1; lnext(temp) != NIL; temp = lnext(temp))
;
lnext(temp) = l2;
return l1; /* list1 is now list1+list2 */
}
#ifdef NOT_USED
List *
nreverse(List *list)
{
List *rlist = NIL;
List *p = NIL;
if (list == NULL)
return NIL;
if (length(list) == 1)
return list;
for (p = list; p != NULL; p = lnext(p))
rlist = lcons(lfirst(p), rlist);
lfirst(list) = lfirst(rlist);
lnext(list) = lnext(rlist);
return list;
}
#endif
/*
* makeInteger
*/
Value *
makeInteger(long i)
{
Value *v = makeNode(Value);
v->type = T_Integer;
v->val.ival = i;
return v;
}
/*
* makeFloat
*/
Value *
makeFloat(double d)
{
Value *v = makeNode(Value);
v->type = T_Float;
v->val.dval = d;
return v;
}
/*
* makeString
*/
Value *
makeString(char *str)
{
Value *v = makeNode(Value);
v->type = T_String;
v->val.str = str;
return v;
}
/*
* nth
*
@ -243,7 +222,6 @@ set_nth(List *l, int n, void *elem)
n--;
}
lfirst(l) = elem;
return;
}
/*
@ -268,6 +246,9 @@ length(List *l)
* freeList
*
* Free the List nodes of a list
* The pointed-to nodes, if any, are NOT freed.
* This works for integer lists too.
*
*/
void
freeList(List *list)
@ -281,73 +262,24 @@ freeList(List *list)
}
}
#ifdef NOT_USED
/*
* below are for backwards compatibility
*/
List *
append(List *l1, List *l2)
{
List *newlist,
*newlist2,
*p;
if (l1 == NIL)
return copyObject(l2);
newlist = copyObject(l1);
newlist2 = copyObject(l2);
for (p = newlist; lnext(p) != NIL; p = lnext(p))
;
lnext(p) = newlist2;
return newlist;
}
#endif
#ifdef NOT_USED
/*
* below are for backwards compatibility
*/
List *
intAppend(List *l1, List *l2)
{
List *newlist,
*newlist2,
*p;
if (l1 == NIL)
return listCopy(l2);
newlist = listCopy(l1);
newlist2 = listCopy(l2);
for (p = newlist; lnext(p) != NIL; p = lnext(p))
;
lnext(p) = newlist2;
return newlist;
}
#endif
/*
* same
*
* Returns t if two lists contain the same elements.
* now defined in lispdep.c
* Returns t if two lists contain the same elements
* (but unlike equal(), they need not be in the same order)
*
*
* XXX only good for IntList -ay
* XXX should be called samei() --- only good for IntList -ay
*/
bool
same(List *l1, List *l2)
{
List *temp = NIL;
List *temp;
if (l1 == NULL)
return l2 == NULL;
if (l2 == NULL)
return l1 == NULL;
if (l1 == NIL)
return l2 == NIL;
if (l2 == NIL)
return l1 == NIL;
if (length(l1) == length(l2))
{
foreach(temp, l1)
@ -361,70 +293,47 @@ same(List *l1, List *l2)
}
/*
* Generate the union of two lists,
* ie, l1 plus all members of l2 that are not already in l1.
*
* NOTE: if there are duplicates in l1 they will still be duplicate in the
* result; but duplicates in l2 are discarded.
*
* The result is a fresh List, but it points to the same member nodes
* as were in the inputs.
*/
List *
LispUnion(List *l1, List *l2)
{
List *retval = NIL;
List *i = NIL;
List *j = NIL;
if (l1 == NIL)
return l2; /* XXX - should be copy of l2 */
if (l2 == NIL)
return l1; /* XXX - should be copy of l1 */
List *retval = listCopy(l1);
List *i;
foreach(i, l1)
{
foreach(j, l2)
{
if (!equal(lfirst(i), lfirst(j)))
foreach(i, l2)
{
if (! member(lfirst(i), retval))
retval = lappend(retval, lfirst(i));
break;
}
}
}
foreach(i, l2)
retval = lappend(retval, lfirst(i));
return retval;
}
List *
LispUnioni(List *l1, List *l2)
{
List *retval = NIL;
List *i = NIL;
List *j = NIL;
if (l1 == NIL)
return l2; /* XXX - should be copy of l2 */
if (l2 == NIL)
return l1; /* XXX - should be copy of l1 */
List *retval = listCopy(l1);
List *i;
foreach(i, l1)
{
foreach(j, l2)
{
if (lfirsti(i) != lfirsti(j))
foreach(i, l2)
{
if (! intMember(lfirsti(i), retval))
retval = lappendi(retval, lfirsti(i));
break;
}
}
}
foreach(i, l2)
retval = lappendi(retval, lfirsti(i));
return retval;
}
/*
* member()
* - nondestructive, returns t iff l1 is a member of the list
* l2
* nondestructive, returns t iff l1 is a member of the list l2
*/
bool
member(void *l1, List *l2)
@ -432,8 +341,10 @@ member(void *l1, List *l2)
List *i;
foreach(i, l2)
{
if (equal((Node *) l1, (Node *) lfirst(i)))
return true;
}
return false;
}
@ -443,14 +354,18 @@ intMember(int l1, List *l2)
List *i;
foreach(i, l2)
{
if (l1 == lfirsti(i))
return true;
}
return false;
}
/*
* lremove -
* only does pointer comparisons. Removes 'elem' from the the linked list.
* lremove
* Removes 'elem' from the the linked list.
* This version matches 'elem' using simple pointer comparison.
* See also LispRemove.
*/
List *
lremove(void *elem, List *list)
@ -465,10 +380,10 @@ lremove(void *elem, List *list)
break;
prev = l;
}
if (l != NULL)
if (l != NIL)
{
if (prev == NIL)
result = lnext(list);
result = lnext(l);
else
lnext(prev) = lnext(l);
}
@ -477,54 +392,57 @@ lremove(void *elem, List *list)
/*
* LispRemove
* Removes 'elem' from the the linked list.
* This version matches 'elem' using equal().
* (If there is more than one equal list member, the first is removed.)
* See also lremove.
*/
List *
LispRemove(void *elem, List *list)
{
List *temp = NIL;
List *l;
List *prev = NIL;
List *result = list;
if (equal(elem, lfirst(list)))
return lnext(list);
temp = lnext(list);
prev = list;
while (temp != NIL)
{
if (equal(elem, lfirst(temp)))
foreach(l, list)
{
lnext(prev) = lnext(temp);
if (equal(elem, lfirst(l)))
break;
prev = l;
}
temp = lnext(temp);
prev = lnext(prev);
if (l != NIL)
{
if (prev == NIL)
result = lnext(l);
else
lnext(prev) = lnext(l);
}
return list;
return result;
}
#ifdef NOT_USED
List *
intLispRemove(int elem, List *list)
{
List *temp = NIL;
List *l;
List *prev = NIL;
List *result = list;
if (elem == lfirsti(list))
return lnext(list);
temp = lnext(list);
prev = list;
while (temp != NIL)
{
if (elem == lfirsti(temp))
foreach(l, list)
{
lnext(prev) = lnext(temp);
if (elem == lfirsti(l))
break;
prev = l;
}
temp = lnext(temp);
prev = lnext(prev);
if (l != NIL)
{
if (prev == NIL)
result = lnext(l);
else
lnext(prev) = lnext(l);
}
return list;
return result;
}
#endif
@ -533,20 +451,23 @@ intLispRemove(int elem, List *list)
* set_difference
*
* Return l1 without the elements in l2.
*
* The result is a fresh List, but it points to the same member nodes
* as were in l1.
*/
List *
set_difference(List *l1, List *l2)
{
List *temp1 = NIL;
List *result = NIL;
List *i;
if (l2 == NIL)
return l1;
return listCopy(l1); /* slightly faster path for empty l2 */
foreach(temp1, l1)
foreach(i, l1)
{
if (!member(lfirst(temp1), l2))
result = lappend(result, lfirst(temp1));
if (! member(lfirst(i), l2))
result = lappend(result, lfirst(i));
}
return result;
}
@ -559,16 +480,16 @@ set_difference(List *l1, List *l2)
List *
set_differencei(List *l1, List *l2)
{
List *temp1 = NIL;
List *result = NIL;
List *i;
if (l2 == NIL)
return l1;
return listCopy(l1); /* slightly faster path for empty l2 */
foreach(temp1, l1)
foreach(i, l1)
{
if (!intMember(lfirsti(temp1), l2))
result = lappendi(result, lfirsti(temp1));
if (! intMember(lfirsti(i), l2))
result = lappendi(result, lfirsti(i));
}
return result;
}

Write Preview
Loading…
Cancel
Save