2008-05-17 03:28:26 +02:00
|
|
|
/*
|
2010-09-20 22:08:53 +02:00
|
|
|
* contrib/intarray/_int_tool.c
|
2008-05-17 03:28:26 +02:00
|
|
|
*/
|
2008-05-12 02:00:54 +02:00
|
|
|
#include "postgres.h"
|
|
|
|
|
2018-11-24 00:56:39 +01:00
|
|
|
#include <limits.h>
|
|
|
|
|
2003-06-11 21:31:05 +02:00
|
|
|
#include "_int.h"
|
2019-10-23 05:56:22 +02:00
|
|
|
#include "catalog/pg_type.h"
|
2003-06-11 21:31:05 +02:00
|
|
|
|
2011-01-09 06:39:21 +01:00
|
|
|
/* arguments are assumed sorted & unique-ified */
|
2003-06-11 21:31:05 +02:00
|
|
|
bool
|
|
|
|
inner_int_contains(ArrayType *a, ArrayType *b)
|
|
|
|
{
|
|
|
|
int na,
|
|
|
|
nb;
|
|
|
|
int i,
|
|
|
|
j,
|
|
|
|
n;
|
|
|
|
int *da,
|
|
|
|
*db;
|
|
|
|
|
|
|
|
na = ARRNELEMS(a);
|
|
|
|
nb = ARRNELEMS(b);
|
|
|
|
da = ARRPTR(a);
|
|
|
|
db = ARRPTR(b);
|
|
|
|
|
|
|
|
i = j = n = 0;
|
|
|
|
while (i < na && j < nb)
|
2011-01-09 06:39:21 +01:00
|
|
|
{
|
2003-06-11 21:31:05 +02:00
|
|
|
if (da[i] < db[j])
|
|
|
|
i++;
|
|
|
|
else if (da[i] == db[j])
|
|
|
|
{
|
|
|
|
n++;
|
|
|
|
i++;
|
|
|
|
j++;
|
|
|
|
}
|
|
|
|
else
|
2011-01-09 06:39:21 +01:00
|
|
|
break; /* db[j] is not in da */
|
|
|
|
}
|
2003-06-11 21:31:05 +02:00
|
|
|
|
2017-08-16 06:22:32 +02:00
|
|
|
return (n == nb) ? true : false;
|
2003-06-11 21:31:05 +02:00
|
|
|
}
|
|
|
|
|
2011-01-09 06:39:21 +01:00
|
|
|
/* arguments are assumed sorted */
|
2003-06-11 21:31:05 +02:00
|
|
|
bool
|
|
|
|
inner_int_overlap(ArrayType *a, ArrayType *b)
|
|
|
|
{
|
|
|
|
int na,
|
|
|
|
nb;
|
|
|
|
int i,
|
|
|
|
j;
|
|
|
|
int *da,
|
|
|
|
*db;
|
|
|
|
|
|
|
|
na = ARRNELEMS(a);
|
|
|
|
nb = ARRNELEMS(b);
|
|
|
|
da = ARRPTR(a);
|
|
|
|
db = ARRPTR(b);
|
|
|
|
|
|
|
|
i = j = 0;
|
|
|
|
while (i < na && j < nb)
|
2011-01-09 06:39:21 +01:00
|
|
|
{
|
2003-06-11 21:31:05 +02:00
|
|
|
if (da[i] < db[j])
|
|
|
|
i++;
|
|
|
|
else if (da[i] == db[j])
|
2017-08-16 06:22:32 +02:00
|
|
|
return true;
|
2003-06-11 21:31:05 +02:00
|
|
|
else
|
|
|
|
j++;
|
2011-01-09 06:39:21 +01:00
|
|
|
}
|
2003-06-11 21:31:05 +02:00
|
|
|
|
2017-08-16 06:22:32 +02:00
|
|
|
return false;
|
2003-06-11 21:31:05 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
ArrayType *
|
|
|
|
inner_int_union(ArrayType *a, ArrayType *b)
|
|
|
|
{
|
|
|
|
ArrayType *r = NULL;
|
|
|
|
|
2005-11-19 04:00:09 +01:00
|
|
|
CHECKARRVALID(a);
|
|
|
|
CHECKARRVALID(b);
|
|
|
|
|
2011-01-09 06:39:21 +01:00
|
|
|
if (ARRISEMPTY(a) && ARRISEMPTY(b))
|
2003-06-11 21:31:05 +02:00
|
|
|
return new_intArrayType(0);
|
2011-01-09 06:39:21 +01:00
|
|
|
if (ARRISEMPTY(a))
|
2003-06-11 21:31:05 +02:00
|
|
|
r = copy_intArrayType(b);
|
2011-01-09 06:39:21 +01:00
|
|
|
if (ARRISEMPTY(b))
|
2003-06-11 21:31:05 +02:00
|
|
|
r = copy_intArrayType(a);
|
|
|
|
|
2006-05-10 13:39:12 +02:00
|
|
|
if (!r)
|
2003-06-11 21:31:05 +02:00
|
|
|
{
|
2006-10-04 02:30:14 +02:00
|
|
|
int na = ARRNELEMS(a),
|
|
|
|
nb = ARRNELEMS(b);
|
|
|
|
int *da = ARRPTR(a),
|
|
|
|
*db = ARRPTR(b);
|
|
|
|
int i,
|
|
|
|
j,
|
|
|
|
*dr;
|
2003-06-11 21:31:05 +02:00
|
|
|
|
|
|
|
r = new_intArrayType(na + nb);
|
|
|
|
dr = ARRPTR(r);
|
|
|
|
|
|
|
|
/* union */
|
|
|
|
i = j = 0;
|
2006-10-04 02:30:14 +02:00
|
|
|
while (i < na && j < nb)
|
|
|
|
{
|
|
|
|
if (da[i] == db[j])
|
|
|
|
{
|
2006-05-10 13:39:12 +02:00
|
|
|
*dr++ = da[i++];
|
|
|
|
j++;
|
2006-10-04 02:30:14 +02:00
|
|
|
}
|
|
|
|
else if (da[i] < db[j])
|
2003-06-11 21:31:05 +02:00
|
|
|
*dr++ = da[i++];
|
|
|
|
else
|
|
|
|
*dr++ = db[j++];
|
2006-05-10 13:39:12 +02:00
|
|
|
}
|
2003-06-11 21:31:05 +02:00
|
|
|
|
|
|
|
while (i < na)
|
|
|
|
*dr++ = da[i++];
|
|
|
|
while (j < nb)
|
|
|
|
*dr++ = db[j++];
|
|
|
|
|
2006-10-04 02:30:14 +02:00
|
|
|
r = resize_intArrayType(r, dr - ARRPTR(r));
|
2003-06-11 21:31:05 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (ARRNELEMS(r) > 1)
|
|
|
|
r = _int_unique(r);
|
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
ArrayType *
|
|
|
|
inner_int_inter(ArrayType *a, ArrayType *b)
|
|
|
|
{
|
|
|
|
ArrayType *r;
|
|
|
|
int na,
|
|
|
|
nb;
|
|
|
|
int *da,
|
|
|
|
*db,
|
|
|
|
*dr;
|
|
|
|
int i,
|
2012-02-17 02:00:11 +01:00
|
|
|
j,
|
|
|
|
k;
|
2003-06-11 21:31:05 +02:00
|
|
|
|
2011-01-09 06:39:21 +01:00
|
|
|
if (ARRISEMPTY(a) || ARRISEMPTY(b))
|
2003-06-11 21:31:05 +02:00
|
|
|
return new_intArrayType(0);
|
|
|
|
|
|
|
|
na = ARRNELEMS(a);
|
|
|
|
nb = ARRNELEMS(b);
|
|
|
|
da = ARRPTR(a);
|
|
|
|
db = ARRPTR(b);
|
2004-10-21 21:28:36 +02:00
|
|
|
r = new_intArrayType(Min(na, nb));
|
2003-06-11 21:31:05 +02:00
|
|
|
dr = ARRPTR(r);
|
|
|
|
|
2012-02-17 02:00:11 +01:00
|
|
|
i = j = k = 0;
|
2003-06-11 21:31:05 +02:00
|
|
|
while (i < na && j < nb)
|
2011-01-09 06:39:21 +01:00
|
|
|
{
|
2003-06-11 21:31:05 +02:00
|
|
|
if (da[i] < db[j])
|
|
|
|
i++;
|
|
|
|
else if (da[i] == db[j])
|
|
|
|
{
|
2012-02-17 02:00:11 +01:00
|
|
|
if (k == 0 || dr[k - 1] != db[j])
|
|
|
|
dr[k++] = db[j];
|
2003-06-11 21:31:05 +02:00
|
|
|
i++;
|
|
|
|
j++;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
j++;
|
2011-01-09 06:39:21 +01:00
|
|
|
}
|
2003-06-11 21:31:05 +02:00
|
|
|
|
2012-02-17 02:00:11 +01:00
|
|
|
if (k == 0)
|
2003-06-11 21:31:05 +02:00
|
|
|
{
|
|
|
|
pfree(r);
|
|
|
|
return new_intArrayType(0);
|
|
|
|
}
|
|
|
|
else
|
2012-02-17 02:00:11 +01:00
|
|
|
return resize_intArrayType(r, k);
|
2003-06-11 21:31:05 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
rt__int_size(ArrayType *a, float *size)
|
|
|
|
{
|
|
|
|
*size = (float) ARRNELEMS(a);
|
|
|
|
}
|
|
|
|
|
2015-03-16 04:22:03 +01:00
|
|
|
/* qsort_arg comparison function for isort() */
|
|
|
|
static int
|
|
|
|
isort_cmp(const void *a, const void *b, void *arg)
|
|
|
|
{
|
|
|
|
int32 aval = *((const int32 *) a);
|
|
|
|
int32 bval = *((const int32 *) b);
|
|
|
|
|
|
|
|
if (aval < bval)
|
|
|
|
return -1;
|
|
|
|
if (aval > bval)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Report if we have any duplicates. If there are equal keys, qsort must
|
|
|
|
* compare them at some point, else it wouldn't know whether one should go
|
|
|
|
* before or after the other.
|
|
|
|
*/
|
|
|
|
*((bool *) arg) = true;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-05-06 18:12:18 +02:00
|
|
|
/* Sort the given data (len >= 2). Return true if any duplicates found */
|
2003-06-11 21:31:05 +02:00
|
|
|
bool
|
2012-06-25 00:51:46 +02:00
|
|
|
isort(int32 *a, int len)
|
2003-06-11 21:31:05 +02:00
|
|
|
{
|
2015-03-16 04:22:03 +01:00
|
|
|
bool r = false;
|
2003-06-11 21:31:05 +02:00
|
|
|
|
2015-03-16 04:22:03 +01:00
|
|
|
qsort_arg(a, len, sizeof(int32), isort_cmp, (void *) &r);
|
2003-06-11 21:31:05 +02:00
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2011-01-09 06:39:21 +01:00
|
|
|
/* Create a new int array with room for "num" elements */
|
2003-06-11 21:31:05 +02:00
|
|
|
ArrayType *
|
|
|
|
new_intArrayType(int num)
|
|
|
|
{
|
|
|
|
ArrayType *r;
|
2018-07-09 20:28:04 +02:00
|
|
|
int nbytes;
|
|
|
|
|
|
|
|
/* if no elements, return a zero-dimensional array */
|
|
|
|
if (num <= 0)
|
|
|
|
{
|
2018-11-24 00:56:39 +01:00
|
|
|
Assert(num == 0);
|
2018-07-09 20:28:04 +02:00
|
|
|
r = construct_empty_array(INT4OID);
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
nbytes = ARR_OVERHEAD_NONULLS(1) + sizeof(int) * num;
|
2003-06-11 21:31:05 +02:00
|
|
|
|
|
|
|
r = (ArrayType *) palloc0(nbytes);
|
|
|
|
|
2007-02-28 00:48:10 +01:00
|
|
|
SET_VARSIZE(r, nbytes);
|
2011-01-09 06:39:21 +01:00
|
|
|
ARR_NDIM(r) = 1;
|
2005-11-17 23:14:56 +01:00
|
|
|
r->dataoffset = 0; /* marker for no null bitmap */
|
2003-06-11 21:31:05 +02:00
|
|
|
ARR_ELEMTYPE(r) = INT4OID;
|
2011-01-09 06:39:21 +01:00
|
|
|
ARR_DIMS(r)[0] = num;
|
|
|
|
ARR_LBOUND(r)[0] = 1;
|
2003-06-11 21:31:05 +02:00
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
ArrayType *
|
|
|
|
resize_intArrayType(ArrayType *a, int num)
|
|
|
|
{
|
2018-07-09 20:28:04 +02:00
|
|
|
int nbytes;
|
2011-01-09 06:39:21 +01:00
|
|
|
int i;
|
2003-06-11 21:31:05 +02:00
|
|
|
|
2013-09-07 17:44:33 +02:00
|
|
|
/* if no elements, return a zero-dimensional array */
|
2018-07-09 20:28:04 +02:00
|
|
|
if (num <= 0)
|
2013-09-07 17:44:33 +02:00
|
|
|
{
|
2018-11-24 00:56:39 +01:00
|
|
|
Assert(num == 0);
|
Fix intarray's GiST opclasses to not fail for empty arrays with <@.
contrib/intarray considers "arraycol <@ constant-array" to be indexable,
but its GiST opclass code fails to reliably find index entries for empty
array values (which of course should trivially match such queries).
This is because the test condition to see whether we should descend
through a non-leaf node is wrong.
Unfortunately, empty array entries could be anywhere in the index,
as these index opclasses are currently designed. So there's no way
to fix this except by lobotomizing <@ indexscans to scan the whole
index ... which is what this patch does. That's pretty unfortunate:
the performance is now actually worse than a seqscan, in most cases.
We'd be better off to remove <@ from the GiST opclasses entirely,
and perhaps a future non-back-patchable patch will do so.
In the meantime, applications whose performance is adversely impacted
have a couple of options. They could switch to a GIN index, which
doesn't have this bug, or they could replace "arraycol <@ constant-array"
with "arraycol <@ constant-array AND arraycol && constant-array".
That will provide about the same performance as before, and it will find
all non-empty subsets of the given constant-array, which is all that
could reliably be expected of the query before.
While at it, add some more regression test cases to improve code
coverage of contrib/intarray.
In passing, adjust resize_intArrayType so that when it's returning an
empty array, it uses construct_empty_array for that rather than
cowboy hacking on the input array. While the hack produces an array
that looks valid for most purposes, it isn't bitwise equal to empty
arrays produced by other code paths, which could have subtle odd
effects. I don't think this code path is performance-critical
enough to justify such shortcuts. (Back-patch this part only as far
as v11; before commit 01783ac36 we were not careful about this in
other intarray code paths either.)
Back-patch the <@ fixes to all supported versions, since this was
broken from day one.
Patch by me; thanks to Alexander Korotkov for review.
Discussion: https://postgr.es/m/458.1565114141@sss.pgh.pa.us
2019-08-07 00:04:51 +02:00
|
|
|
a = construct_empty_array(INT4OID);
|
2013-09-07 17:44:33 +02:00
|
|
|
return a;
|
|
|
|
}
|
|
|
|
|
2003-06-11 21:31:05 +02:00
|
|
|
if (num == ARRNELEMS(a))
|
|
|
|
return a;
|
|
|
|
|
2018-07-09 20:28:04 +02:00
|
|
|
nbytes = ARR_DATA_OFFSET(a) + sizeof(int) * num;
|
|
|
|
|
2003-06-11 21:31:05 +02:00
|
|
|
a = (ArrayType *) repalloc(a, nbytes);
|
|
|
|
|
2007-02-28 00:48:10 +01:00
|
|
|
SET_VARSIZE(a, nbytes);
|
2011-01-09 06:39:21 +01:00
|
|
|
/* usually the array should be 1-D already, but just in case ... */
|
|
|
|
for (i = 0; i < ARR_NDIM(a); i++)
|
|
|
|
{
|
|
|
|
ARR_DIMS(a)[i] = num;
|
|
|
|
num = 1;
|
|
|
|
}
|
2003-06-11 21:31:05 +02:00
|
|
|
return a;
|
|
|
|
}
|
|
|
|
|
|
|
|
ArrayType *
|
|
|
|
copy_intArrayType(ArrayType *a)
|
|
|
|
{
|
|
|
|
ArrayType *r;
|
2011-01-09 06:39:21 +01:00
|
|
|
int n = ARRNELEMS(a);
|
2003-06-11 21:31:05 +02:00
|
|
|
|
2011-01-09 06:39:21 +01:00
|
|
|
r = new_intArrayType(n);
|
2012-06-25 00:51:46 +02:00
|
|
|
memcpy(ARRPTR(r), ARRPTR(a), n * sizeof(int32));
|
2003-06-11 21:31:05 +02:00
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* num for compressed key */
|
|
|
|
int
|
|
|
|
internal_size(int *a, int len)
|
|
|
|
{
|
2018-11-24 00:56:39 +01:00
|
|
|
int i;
|
|
|
|
int64 size = 0;
|
2003-06-11 21:31:05 +02:00
|
|
|
|
|
|
|
for (i = 0; i < len; i += 2)
|
2011-01-09 06:39:21 +01:00
|
|
|
{
|
Phase 2 of pgindent updates.
Change pg_bsd_indent to follow upstream rules for placement of comments
to the right of code, and remove pgindent hack that caused comments
following #endif to not obey the general rule.
Commit e3860ffa4dd0dad0dd9eea4be9cc1412373a8c89 wasn't actually using
the published version of pg_bsd_indent, but a hacked-up version that
tried to minimize the amount of movement of comments to the right of
code. The situation of interest is where such a comment has to be
moved to the right of its default placement at column 33 because there's
code there. BSD indent has always moved right in units of tab stops
in such cases --- but in the previous incarnation, indent was working
in 8-space tab stops, while now it knows we use 4-space tabs. So the
net result is that in about half the cases, such comments are placed
one tab stop left of before. This is better all around: it leaves
more room on the line for comment text, and it means that in such
cases the comment uniformly starts at the next 4-space tab stop after
the code, rather than sometimes one and sometimes two tabs after.
Also, ensure that comments following #endif are indented the same
as comments following other preprocessor commands such as #else.
That inconsistency turns out to have been self-inflicted damage
from a poorly-thought-through post-indent "fixup" in pgindent.
This patch is much less interesting than the first round of indent
changes, but also bulkier, so I thought it best to separate the effects.
Discussion: https://postgr.es/m/E1dAmxK-0006EE-1r@gemulon.postgresql.org
Discussion: https://postgr.es/m/30527.1495162840@sss.pgh.pa.us
2017-06-21 21:18:54 +02:00
|
|
|
if (!i || a[i] != a[i - 1]) /* do not count repeated range */
|
2019-05-22 18:55:34 +02:00
|
|
|
size += (int64) (a[i + 1]) - (int64) (a[i]) + 1;
|
2011-01-09 06:39:21 +01:00
|
|
|
}
|
2003-06-11 21:31:05 +02:00
|
|
|
|
2019-05-22 18:55:34 +02:00
|
|
|
if (size > (int64) INT_MAX || size < (int64) INT_MIN)
|
2018-11-24 00:56:39 +01:00
|
|
|
return -1; /* overflow */
|
|
|
|
return (int) size;
|
2003-06-11 21:31:05 +02:00
|
|
|
}
|
|
|
|
|
2011-01-09 06:39:21 +01:00
|
|
|
/* unique-ify elements of r in-place ... r must be sorted already */
|
2003-06-11 21:31:05 +02:00
|
|
|
ArrayType *
|
|
|
|
_int_unique(ArrayType *r)
|
|
|
|
{
|
|
|
|
int *tmp,
|
|
|
|
*dr,
|
|
|
|
*data;
|
|
|
|
int num = ARRNELEMS(r);
|
|
|
|
|
2003-08-04 02:43:34 +02:00
|
|
|
if (num < 2)
|
2003-06-11 21:31:05 +02:00
|
|
|
return r;
|
|
|
|
|
|
|
|
data = tmp = dr = ARRPTR(r);
|
|
|
|
while (tmp - data < num)
|
2011-01-09 06:39:21 +01:00
|
|
|
{
|
2003-06-11 21:31:05 +02:00
|
|
|
if (*tmp != *dr)
|
|
|
|
*(++dr) = *tmp++;
|
|
|
|
else
|
|
|
|
tmp++;
|
2011-01-09 06:39:21 +01:00
|
|
|
}
|
2003-06-11 21:31:05 +02:00
|
|
|
return resize_intArrayType(r, dr + 1 - ARRPTR(r));
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
gensign(BITVEC sign, int *a, int len)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/* we assume that the sign vector is previously zeroed */
|
|
|
|
for (i = 0; i < len; i++)
|
|
|
|
{
|
|
|
|
HASH(sign, *a);
|
|
|
|
a++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
int32
|
|
|
|
intarray_match_first(ArrayType *a, int32 elem)
|
|
|
|
{
|
|
|
|
int32 *aa,
|
|
|
|
c,
|
|
|
|
i;
|
|
|
|
|
2005-11-19 04:00:09 +01:00
|
|
|
CHECKARRVALID(a);
|
|
|
|
c = ARRNELEMS(a);
|
2003-06-11 21:31:05 +02:00
|
|
|
aa = ARRPTR(a);
|
|
|
|
for (i = 0; i < c; i++)
|
|
|
|
if (aa[i] == elem)
|
|
|
|
return (i + 1);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
ArrayType *
|
|
|
|
intarray_add_elem(ArrayType *a, int32 elem)
|
|
|
|
{
|
|
|
|
ArrayType *result;
|
|
|
|
int32 *r;
|
2005-11-19 04:00:09 +01:00
|
|
|
int32 c;
|
2003-06-11 21:31:05 +02:00
|
|
|
|
2005-11-19 04:00:09 +01:00
|
|
|
CHECKARRVALID(a);
|
2011-01-09 06:39:21 +01:00
|
|
|
c = ARRNELEMS(a);
|
2003-06-11 21:31:05 +02:00
|
|
|
result = new_intArrayType(c + 1);
|
|
|
|
r = ARRPTR(result);
|
|
|
|
if (c > 0)
|
|
|
|
memcpy(r, ARRPTR(a), c * sizeof(int32));
|
|
|
|
r[c] = elem;
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
ArrayType *
|
|
|
|
intarray_concat_arrays(ArrayType *a, ArrayType *b)
|
|
|
|
{
|
|
|
|
ArrayType *result;
|
2011-01-09 06:39:21 +01:00
|
|
|
int32 ac = ARRNELEMS(a);
|
|
|
|
int32 bc = ARRNELEMS(b);
|
2003-06-11 21:31:05 +02:00
|
|
|
|
2005-11-19 04:00:09 +01:00
|
|
|
CHECKARRVALID(a);
|
|
|
|
CHECKARRVALID(b);
|
2003-06-11 21:31:05 +02:00
|
|
|
result = new_intArrayType(ac + bc);
|
|
|
|
if (ac)
|
|
|
|
memcpy(ARRPTR(result), ARRPTR(a), ac * sizeof(int32));
|
|
|
|
if (bc)
|
|
|
|
memcpy(ARRPTR(result) + ac, ARRPTR(b), bc * sizeof(int32));
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
ArrayType *
|
|
|
|
int_to_intset(int32 n)
|
|
|
|
{
|
|
|
|
ArrayType *result;
|
|
|
|
int32 *aa;
|
|
|
|
|
|
|
|
result = new_intArrayType(1);
|
|
|
|
aa = ARRPTR(result);
|
|
|
|
aa[0] = n;
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
compASC(const void *a, const void *b)
|
|
|
|
{
|
2012-06-25 00:51:46 +02:00
|
|
|
if (*(const int32 *) a == *(const int32 *) b)
|
2003-06-11 21:31:05 +02:00
|
|
|
return 0;
|
2012-06-25 00:51:46 +02:00
|
|
|
return (*(const int32 *) a > *(const int32 *) b) ? 1 : -1;
|
2003-06-11 21:31:05 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
compDESC(const void *a, const void *b)
|
|
|
|
{
|
2012-06-25 00:51:46 +02:00
|
|
|
if (*(const int32 *) a == *(const int32 *) b)
|
2003-06-11 21:31:05 +02:00
|
|
|
return 0;
|
2012-06-25 00:51:46 +02:00
|
|
|
return (*(const int32 *) a < *(const int32 *) b) ? 1 : -1;
|
2003-06-11 21:31:05 +02:00
|
|
|
}
|