index 5b246bcde4b3e70fe9cf3ad02afc4966b372b40e..6790f22b4b6702f47bc907eccdd999f0e78ccf0b 100644 (file)
while (sz < padded_sz)
((char *) out)[sz++] = 0;
SET_VARSIZE(out, padded_sz);
- memcpy((void *) VARDATA(out), (void *) VARBITS(leaf), VARBITBYTES(leaf));
+ memcpy(VARDATA(out), VARBITS(leaf), VARBITBYTES(leaf));
return out;
}
index 2c98b330cd7dfad016d486eda770b5a526398bd6..b0afdf02bb55456eb028828d0d934f6ef3bc672f 100644 (file)
{
Interval *key = DatumGetIntervalP(entry->key);
- memcpy((void *) r, (void *) key, INTERVALSIZE);
- memcpy((void *) (r + INTERVALSIZE), (void *) key, INTERVALSIZE);
+ memcpy(r, key, INTERVALSIZE);
+ memcpy(r + INTERVALSIZE, key, INTERVALSIZE);
}
else
{
index 05c154afa3406da9f7ae21089f5637b179b71fd0..346ee837d75f44e1b4aa00fffb408a53601935e1 100644 (file)
@@ -87,8 +87,8 @@ gbt_num_compress(GISTENTRY *entry, const gbtree_ninfo *tinfo)
Assert(tinfo->indexsize >= 2 * tinfo->size);
- memcpy((void *) &r[0], leaf, tinfo->size);
- memcpy((void *) &r[tinfo->size], leaf, tinfo->size);
+ memcpy(&r[0], leaf, tinfo->size);
+ memcpy(&r[tinfo->size], leaf, tinfo->size);
retval = palloc(sizeof(GISTENTRY));
gistentryinit(*retval, PointerGetDatum(r), entry->rel, entry->page,
entry->offset, false);
@@ -184,7 +184,7 @@ gbt_num_union(GBT_NUMKEY *out, const GistEntryVector *entryvec, const gbtree_nin
o.lower = &((GBT_NUMKEY *) out)[0];
o.upper = &((GBT_NUMKEY *) out)[tinfo->size];
- memcpy((void *) out, (void *) cur, 2 * tinfo->size);
+ memcpy(out, cur, 2 * tinfo->size);
for (i = 1; i < numranges; i++)
{
@@ -360,7 +360,7 @@ gbt_num_picksplit(const GistEntryVector *entryvec, GIST_SPLITVEC *v,
arr[i].t = (GBT_NUMKEY *) DatumGetPointer((entryvec->vector[i].key));
arr[i].i = i;
}
- qsort_arg((void *) &arr[FirstOffsetNumber], maxoff - FirstOffsetNumber + 1, sizeof(Nsrt), (qsort_arg_comparator) tinfo->f_cmp, (void *) flinfo);
+ qsort_arg(&arr[FirstOffsetNumber], maxoff - FirstOffsetNumber + 1, sizeof(Nsrt), (qsort_arg_comparator) tinfo->f_cmp, flinfo);
/* We do simply create two parts */
index 3ef82d0e208ed2613e2600405f935a91d5b802f5..0c0e952f736214d798bdb929942d948e4a21b449 100644 (file)
@@ -502,11 +502,11 @@ gbt_var_picksplit(const GistEntryVector *entryvec, GIST_SPLITVEC *v,
varg.tinfo = tinfo;
varg.collation = collation;
varg.flinfo = flinfo;
- qsort_arg((void *) &arr[FirstOffsetNumber],
+ qsort_arg(&arr[FirstOffsetNumber],
maxoff - FirstOffsetNumber + 1,
sizeof(Vsrt),
gbt_vsrt_cmp,
- (void *) &varg);
+ &varg);
/* We do simply create two parts */
index b81875979a3b905f09857e0c5f4f4b21a4c24ea6..fe8c679cbed636f509de26b3a5c4e1549845001a 100644 (file)
retval = palloc(sizeof(GISTENTRY));
- memcpy((void *) r, (void *) key, UUID_LEN);
- memcpy((void *) (r + UUID_LEN), (void *) key, UUID_LEN);
+ memcpy(r, key, UUID_LEN);
+ memcpy(r + UUID_LEN, key, UUID_LEN);
gistentryinit(*retval, PointerGetDatum(r),
entry->rel, entry->page,
entry->offset, false);
index 976c578e1ce5635252c7ccf98b07caea6e39e817..26af935a70f6f6ccaa5dfbf2fb6fbef478ee91c3 100644 (file)
@@ -80,7 +80,7 @@ internal_citext_pattern_cmp(text *left, text *right, Oid collid)
llen = strlen(lcstr);
rlen = strlen(rcstr);
- result = memcmp((void *) lcstr, (void *) rcstr, Min(llen, rlen));
+ result = memcmp(lcstr, rcstr, Min(llen, rlen));
if (result == 0)
{
if (llen < rlen)
index 5d8b806d30a09c553f207e88493466620db7759c..3df00493e8172ca16d2316a159830e027b6a1716 100644 (file)
size_beta = hemdist(datum_r, _j, siglen);
costvector[j - 1].cost = abs(size_alpha - size_beta);
}
- qsort((void *) costvector, maxoff, sizeof(SPLITCOST), comparecost);
+ qsort(costvector, maxoff, sizeof(SPLITCOST), comparecost);
union_l = GETSIGN(datum_l);
union_r = GETSIGN(datum_r);
if (ISALLTRUE(datum_l) || ISALLTRUE(_j))
{
if (!ISALLTRUE(datum_l))
- memset((void *) union_l, 0xff, siglen);
+ memset(union_l, 0xff, siglen);
}
else
{
if (ISALLTRUE(datum_r) || ISALLTRUE(_j))
{
if (!ISALLTRUE(datum_r))
- memset((void *) union_r, 0xff, siglen);
+ memset(union_r, 0xff, siglen);
}
else
{
index ae09cede8c0e66cfab7f0e0d2f9d76147bef9994..cec7df71a25ac0eef120ddc28c253f86e0223b17 100644 (file)
@@ -365,7 +365,7 @@ hstoreUniquePairs(Pairs *a, int32 l, int32 *buflen)
return l;
}
- qsort((void *) a, l, sizeof(Pairs), comparePairs);
+ qsort(a, l, sizeof(Pairs), comparePairs);
/*
* We can't use qunique here because we have some clean-up code to run on
index 331fa25fcf724313d7d37767cc869002fe57071e..7a48ce624def939e1b64606414a745ee3054fdc9 100644 (file)
/*
* shunt everything down to start at the right place
*/
- memmove((void *) &dr[0], (void *) &dr[2 * j], 2 * (len - j) * sizeof(int32));
+ memmove(&dr[0], &dr[2 * j], 2 * (len - j) * sizeof(int32));
}
/*
min = ((int64) dr[i] - (int64) dr[i - 1]);
cand = i;
}
- memmove((void *) &dr[cand - 1], (void *) &dr[cand + 1], (len - cand - 1) * sizeof(int32));
+ memmove(&dr[cand - 1], &dr[cand + 1], (len - cand - 1) * sizeof(int32));
len -= 2;
}
pfree(union_d);
costvector[i - 1].cost = fabsf((size_alpha - size_l) - (size_beta - size_r));
}
- qsort((void *) costvector, maxoff, sizeof(SPLITCOST), comparecost);
+ qsort(costvector, maxoff, sizeof(SPLITCOST), comparecost);
/*
* Now split up the regions between the two seeds. An important property
index 5ab6eb81e8df2c71fcd8eec2a29fe53b8fd369b4..68f624e085c6fa4d93418b8c8d896585b6e53ffa 100644 (file)
{
bool r = false;
- qsort_arg(a, len, sizeof(int32), isort_cmp, (void *) &r);
+ qsort_arg(a, len, sizeof(int32), isort_cmp, &r);
return r;
}
index dadc18646a8acc916a2ab5944f45dfc8b65177c9..bfba5eef1d1f4e522f5ae3d14e2e1a7b02391080 100644 (file)
size_beta = hemdist(datum_r, _j, siglen);
costvector[j - 1].cost = abs(size_alpha - size_beta);
}
- qsort((void *) costvector, maxoff, sizeof(SPLITCOST), comparecost);
+ qsort(costvector, maxoff, sizeof(SPLITCOST), comparecost);
union_l = GETSIGN(datum_l);
union_r = GETSIGN(datum_r);
if (ISALLTRUE(datum_l) || ISALLTRUE(_j))
{
if (!ISALLTRUE(datum_l))
- memset((void *) union_l, 0xff, siglen);
+ memset(union_l, 0xff, siglen);
}
else
{
if (ISALLTRUE(datum_r) || ISALLTRUE(_j))
{
if (!ISALLTRUE(datum_r))
- memset((void *) union_r, 0xff, siglen);
+ memset(union_r, 0xff, siglen);
}
else
{
index 385a10283b0448009574780ae45981c1690aec41..e89a39a5b5f25377e8b942204d53091adfefcc46 100644 (file)
size_beta = hemdist(datum_r, _j, siglen);
costvector[j - 1].cost = abs(size_alpha - size_beta);
}
- qsort((void *) costvector, maxoff, sizeof(SPLITCOST), comparecost);
+ qsort(costvector, maxoff, sizeof(SPLITCOST), comparecost);
union_l = LTG_SIGN(datum_l);
union_r = LTG_SIGN(datum_r);
if (LTG_ISALLTRUE(datum_l) || LTG_ISALLTRUE(_j))
{
if (!LTG_ISALLTRUE(datum_l))
- memset((void *) union_l, 0xff, siglen);
+ memset(union_l, 0xff, siglen);
}
else
{
if (LTG_ISALLTRUE(datum_r) || LTG_ISALLTRUE(_j))
{
if (!LTG_ISALLTRUE(datum_r))
- memset((void *) union_r, 0xff, siglen);
+ memset(union_r, 0xff, siglen);
}
else
{
index 5d2db6c62be845fd9ede6abfe18a867271dabea7..3cba2269d86d620317c623ac1768849fd7df7505 100644 (file)
array[j].r = LTG_GETLNODE(lu, siglen);
}
- qsort((void *) &array[FirstOffsetNumber], maxoff - FirstOffsetNumber + 1,
+ qsort(&array[FirstOffsetNumber], maxoff - FirstOffsetNumber + 1,
sizeof(RIX), treekey_cmp);
lu_l = lu_r = ru_l = ru_r = NULL;
index d9910e6c99268a082c47c81ecf132fde634d4834..0d29e156303be5e223c69bb6dfb5f9c26bf358cf 100644 (file)
@@ -195,10 +195,10 @@ pushval_asis(QPRS_STATE *state, int type, char *strval, int lenval, uint16 flag)
int32 tmp = state->curop - state->op;
state->lenop *= 2;
- state->op = (char *) repalloc((void *) state->op, state->lenop);
+ state->op = (char *) repalloc(state->op, state->lenop);
state->curop = state->op + tmp;
}
- memcpy((void *) state->curop, (void *) strval, lenval);
+ memcpy(state->curop, strval, lenval);
state->curop += lenval;
*(state->curop) = '0円';
state->curop++;
@@ -391,7 +391,7 @@ queryin(char *buf, struct Node *escontext)
}
/* set user-friendly operand view */
- memcpy((void *) GETOPERAND(query), (void *) state.op, state.sumlen);
+ memcpy(GETOPERAND(query), state.op, state.sumlen);
pfree(state.op);
/* set left operand's position for every operator */
index 61b184597af6dfbb8512519c623d9360dd8b5f29..88a40ab7d39b8043eead48b254231758a7f66cac 100644 (file)
@@ -131,7 +131,7 @@ heap_force_common(FunctionCallInfo fcinfo, HeapTupleForceOption heap_force_opt)
* array.
*/
if (ntids > 1)
- qsort((void *) tids, ntids, sizeof(ItemPointerData), tidcmp);
+ qsort(tids, ntids, sizeof(ItemPointerData), tidcmp);
curr_start_ptr = next_start_ptr = 0;
nblocks = RelationGetNumberOfBlocks(rel);
index ef5d8cca784bb6b822278f29088b6d7a2e24741e..9ef2e38560a2b1a339f101f299a5fa12fa791bb2 100644 (file)
@@ -102,7 +102,7 @@ makesign(BITVECP sign, TRGM *a, int siglen)
trgm *ptr = GETARR(a);
int32 tmp = 0;
- MemSet((void *) sign, 0, siglen);
+ MemSet(sign, 0, siglen);
SETBIT(sign, SIGLENBIT(siglen)); /* set last unused bit */
for (k = 0; k < len; k++)
{
@@ -755,7 +755,7 @@ fillcache(CACHESIGN *item, TRGM *key, BITVECP sign, int siglen)
else if (ISALLTRUE(key))
item->allistrue = true;
else
- memcpy((void *) item->sign, (void *) GETSIGN(key), siglen);
+ memcpy(item->sign, GETSIGN(key), siglen);
}
#define WISH_F(a,b,c) (double)( -(double)(((a)-(b))*((a)-(b))*((a)-(b)))*(c) )
size_beta = hemdistcache(&(cache[seed_2]), &(cache[j]), siglen);
costvector[j - 1].cost = abs(size_alpha - size_beta);
}
- qsort((void *) costvector, maxoff, sizeof(SPLITCOST), comparecost);
+ qsort(costvector, maxoff, sizeof(SPLITCOST), comparecost);
for (k = 0; k < maxoff; k++)
{
if (ISALLTRUE(datum_l) || cache[j].allistrue)
{
if (!ISALLTRUE(datum_l))
- memset((void *) GETSIGN(datum_l), 0xff, siglen);
+ memset(GETSIGN(datum_l), 0xff, siglen);
}
else
{
if (ISALLTRUE(datum_r) || cache[j].allistrue)
{
if (!ISALLTRUE(datum_r))
- memset((void *) GETSIGN(datum_r), 0xff, siglen);
+ memset(GETSIGN(datum_r), 0xff, siglen);
}
else
{
index 2c644bc1485be175f5ce52074a03260399a9b1c4..49d4497b4f3cffc62daac474a42db3cc11748782 100644 (file)
*/
if (len > 1)
{
- qsort((void *) GETARR(trg), len, sizeof(trgm), comp_trgm);
+ qsort(GETARR(trg), len, sizeof(trgm), comp_trgm);
len = qunique(GETARR(trg), len, sizeof(trgm), comp_trgm);
}
@@ -929,7 +929,7 @@ generate_wildcard_trgm(const char *str, int slen)
*/
if (len > 1)
{
- qsort((void *) GETARR(trg), len, sizeof(trgm), comp_trgm);
+ qsort(GETARR(trg), len, sizeof(trgm), comp_trgm);
len = qunique(GETARR(trg), len, sizeof(trgm), comp_trgm);
}
index 52e5aa17bf31f1bd6fdada2e0d9fbd09973003cd..e2a5496c34a98fe7ae8cbdbca8c3651b8fe4bc4a 100644 (file)
* VARDATA is a pointer to the data region of the new struct. The source
* could be a short datum, so retrieve its data through VARDATA_ANY.
*/
- memcpy((void *) VARDATA(new_t), /* destination */
- (void *) VARDATA_ANY(t), /* source */
+ memcpy(VARDATA(new_t), /* destination */
+ VARDATA_ANY(t), /* source */
VARSIZE_ANY_EXHDR(t)); /* how many bytes */
PG_RETURN_TEXT_P(new_t);
}
index ac670fd02d79b30b5a5431edb1a45a762fe51888..0ace6035beb880a7685c2d2ba1757b0c2c4abf0b 100644 (file)
*/
qsort_arg(&range->values[start],
range->nvalues, sizeof(Datum),
- compare_values, (void *) &cxt);
+ compare_values, &cxt);
n = 1;
for (i = 1; i < range->nvalues; i++)
@@ -1197,7 +1197,7 @@ sort_expanded_ranges(FmgrInfo *cmp, Oid colloid,
* some of the points) and do merge sort.
*/
qsort_arg(eranges, neranges, sizeof(ExpandedRange),
- compare_expanded_ranges, (void *) &cxt);
+ compare_expanded_ranges, &cxt);
/*
* Deduplicate the ranges - simply compare each range to the preceding
@@ -1535,7 +1535,7 @@ reduce_expanded_ranges(ExpandedRange *eranges, int neranges,
* sorted result.
*/
qsort_arg(values, nvalues, sizeof(Datum),
- compare_values, (void *) &cxt);
+ compare_values, &cxt);
/* We have nvalues boundary values, which means nvalues/2 ranges. */
for (i = 0; i < (nvalues / 2); i++)
index e7cc452a8aa2115a958151041ef17d33db290c97..f05128ecf5053489218f326e140ab4c99bc39a10 100644 (file)
@@ -560,7 +560,7 @@ ginExtractEntries(GinState *ginstate, OffsetNumber attnum,
arg.collation = ginstate->supportCollation[attnum - 1];
arg.haveDups = false;
qsort_arg(keydata, *nentries, sizeof(keyEntryData),
- cmpEntries, (void *) &arg);
+ cmpEntries, &arg);
if (arg.haveDups)
{
index eb9178d4560c95bca6032a9e3b2585b14cdeb8f6..4881034069baaece24f17e8559a0eff78b3606f2 100644 (file)
numranges = entryvec->n;
pageunion = (BOX *) palloc(sizeof(BOX));
cur = DatumGetBoxP(entryvec->vector[0].key);
- memcpy((void *) pageunion, (void *) cur, sizeof(BOX));
+ memcpy(pageunion, cur, sizeof(BOX));
for (i = 1; i < numranges; i++)
{
BOX *r;
r = (BOX *) palloc(sizeof(BOX));
- memcpy((void *) r, (void *) &(in->boundbox), sizeof(BOX));
+ memcpy(r, &(in->boundbox), sizeof(BOX));
retval = (GISTENTRY *) palloc(sizeof(GISTENTRY));
gistentryinit(*retval, PointerGetDatum(r),
index 56451fede10a726951ed756e5d0bc1c2bf198e9f..b4d843a0ff15c6beae1e8584db82b2dd6fc555cb 100644 (file)
@@ -113,7 +113,7 @@ gistextractpage(Page page, int *len /* out */ )
IndexTuple *
gistjoinvector(IndexTuple *itvec, int *len, IndexTuple *additvec, int addlen)
{
- itvec = (IndexTuple *) repalloc((void *) itvec, sizeof(IndexTuple) * ((*len) + addlen));
+ itvec = (IndexTuple *) repalloc(itvec, sizeof(IndexTuple) * ((*len) + addlen));
memmove(&itvec[*len], additvec, sizeof(IndexTuple) * addlen);
*len += addlen;
return itvec;
index 8003583c0aefb4ffcbc1efccc7d5e159ffe65b05..7da499c4dd55da75cbf5c681a30b01459ec57b21 100644 (file)
@@ -488,8 +488,8 @@ _bt_sort_array_elements(IndexScanDesc scan, ScanKey skey,
fmgr_info(cmp_proc, &cxt.flinfo);
cxt.collation = skey->sk_collation;
cxt.reverse = reverse;
- qsort_arg((void *) elems, nelems, sizeof(Datum),
- _bt_compare_array_elements, (void *) &cxt);
+ qsort_arg(elems, nelems, sizeof(Datum),
+ _bt_compare_array_elements, &cxt);
/* Now scan the sorted elements and remove duplicates */
return qunique_arg(elems, nelems, sizeof(Datum),
index 7acf654bf847fa12c6f93ee4b6b9c178260c5f11..f8a136ba0a102026a7614f34b4d5c22d9e1ed134 100644 (file)
@@ -967,7 +967,7 @@ findDependentObjects(const ObjectAddress *object,
* first within ObjectAddressAndFlags.
*/
if (numDependentObjects > 1)
- qsort((void *) dependentObjects, numDependentObjects,
+ qsort(dependentObjects, numDependentObjects,
sizeof(ObjectAddressAndFlags),
object_address_comparator);
@@ -2442,7 +2442,7 @@ eliminate_duplicate_dependencies(ObjectAddresses *addrs)
return; /* nothing to do */
/* Sort the refs so that duplicates are adjacent */
- qsort((void *) addrs->refs, addrs->numrefs, sizeof(ObjectAddress),
+ qsort(addrs->refs, addrs->numrefs, sizeof(ObjectAddress),
object_address_comparator);
/* Remove dups */
sort_object_addresses(ObjectAddresses *addrs)
{
if (addrs->numrefs > 1)
- qsort((void *) addrs->refs, addrs->numrefs,
+ qsort(addrs->refs, addrs->numrefs,
sizeof(ObjectAddress),
object_address_comparator);
}
index 1ce0ba94e33ebed1dd9b71a51ab5f968ae21a678..64d326f073c32801903f2a68fe40dedcaaafcd51 100644 (file)
@@ -762,7 +762,7 @@ checkSharedDependencies(Oid classId, Oid objectId,
* Sort and report local and shared objects.
*/
if (numobjects > 1)
- qsort((void *) objects, numobjects,
+ qsort(objects, numobjects,
sizeof(ShDependObjectInfo), shared_dependency_comparator);
for (int i = 0; i < numobjects; i++)
index c86e690980ea2af280d80ba0a104eeadef32fbcd..65750958bb2cb3fa5d148dd58236e2ce84af9463 100644 (file)
@@ -1304,7 +1304,7 @@ acquire_sample_rows(Relation onerel, int elevel,
* tuples are already sorted.
*/
if (numrows == targrows)
- qsort_interruptible((void *) rows, numrows, sizeof(HeapTuple),
+ qsort_interruptible(rows, numrows, sizeof(HeapTuple),
compare_rows, NULL);
/*
/* Sort the collected values */
cxt.ssup = &ssup;
cxt.tupnoLink = tupnoLink;
- qsort_interruptible((void *) values, values_cnt, sizeof(ScalarItem),
- compare_scalars, (void *) &cxt);
+ qsort_interruptible(values, values_cnt, sizeof(ScalarItem),
+ compare_scalars, &cxt);
/*
* Now scan the values in order, find the most common ones, and also
deltafrac;
/* Sort the MCV items into position order to speed next loop */
- qsort_interruptible((void *) track, num_mcv, sizeof(ScalarMCVItem),
+ qsort_interruptible(track, num_mcv, sizeof(ScalarMCVItem),
compare_mcvs, NULL);
/*
index 6a4311cc63111947f2feeffc3b7f02bf70a539b4..eb62d285ea70ad1807e64169fe18d4aff7163d2a 100644 (file)
@@ -878,7 +878,7 @@ pg_import_system_collations(PG_FUNCTION_ARGS)
* created such a pg_collation entry above, and that one will win.)
*/
if (naliases > 1)
- qsort((void *) aliases, naliases, sizeof(CollAliasData), cmpaliases);
+ qsort(aliases, naliases, sizeof(CollAliasData), cmpaliases);
/* Now add aliases, ignoring any that match pre-existing entries */
for (i = 0; i < naliases; i++)
index 7b1a4b127eb397f51f46b5e5f80557044875fac2..aa79d9de4d419eaed4b1cce6829659f21fa3c55f 100644 (file)
@@ -2384,8 +2384,8 @@ vac_tid_reaped(ItemPointer itemptr, void *state)
if (item < litem || item > ritem)
return false;
- res = (ItemPointer) bsearch((void *) itemptr,
- (void *) dead_items->items,
+ res = (ItemPointer) bsearch(itemptr,
+ dead_items->items,
dead_items->num_items,
sizeof(ItemPointerData),
vac_cmp_itemptr);
index fe6a964ee1e0f6bde19cbc73ad0a28a340ff9322..862bd0330bc7b8bb9cec48efe4aedfdfd1a5d10e 100644 (file)
/* CurrentOfExpr could never appear OR'd with something else */
Assert(!tidstate->tss_isCurrentOf);
- qsort((void *) tidList, numTids, sizeof(ItemPointerData),
+ qsort(tidList, numTids, sizeof(ItemPointerData),
itemptr_comparator);
numTids = qunique(tidList, numTids, sizeof(ItemPointerData),
itemptr_comparator);
index 8c640ce16ac7e483b125af052f236696517e4f57..29a18584410a50c2ec90a9f5ad41ef26d6637cae 100644 (file)
if (ptbase != NULL)
pg_atomic_init_u32(&ptbase->refcount, 0);
if (npages > 1)
- qsort_arg((void *) (ptpages->index), npages, sizeof(int),
- tbm_shared_comparator, (void *) ptbase->ptentry);
+ qsort_arg(ptpages->index, npages, sizeof(int),
+ tbm_shared_comparator, ptbase->ptentry);
if (nchunks > 1)
- qsort_arg((void *) (ptchunks->index), nchunks, sizeof(int),
- tbm_shared_comparator, (void *) ptbase->ptentry);
+ qsort_arg(ptchunks->index, nchunks, sizeof(int),
+ tbm_shared_comparator, ptbase->ptentry);
}
/*
index ed880c496aa320a8f8844ca1e972ab4f18ee97cf..a69c1d1e77d794316c39fd83172a0e4f1b039379 100644 (file)
@@ -531,7 +531,7 @@ create_list_bounds(PartitionBoundSpec **boundspecs, int nparts,
Assert(j == ndatums);
qsort_arg(all_values, ndatums, sizeof(PartitionListValue),
- qsort_partition_list_value_cmp, (void *) key);
+ qsort_partition_list_value_cmp, key);
boundinfo->ndatums = ndatums;
boundinfo->datums = (Datum **) palloc0(ndatums * sizeof(Datum *));
@@ -737,7 +737,7 @@ create_range_bounds(PartitionBoundSpec **boundspecs, int nparts,
qsort_arg(all_bounds, ndatums,
sizeof(PartitionRangeBound *),
qsort_partition_rbound_cmp,
- (void *) key);
+ key);
/* Save distinct bounds from all_bounds into rbounds. */
rbounds = (PartitionRangeBound **)
index bdc21bb4577a98724334bde89b19a80a081923f0..572d9b44643997d4220f0b7bc9d6bb914de49634 100644 (file)
@@ -1129,7 +1129,7 @@ build_sorted_items(StatsBuildData *data, int *nitems,
}
/* do the sort, using the multi-sort */
- qsort_interruptible((void *) items, nrows, sizeof(SortItem),
+ qsort_interruptible(items, nrows, sizeof(SortItem),
multi_sort_compare, mss);
return items;
index 2d2a87d3a6f1ff7ca14e071bdd0a98c601f3135c..e21e0e87e4133d32d4673fddaea5517e06219cc2 100644 (file)
@@ -457,7 +457,7 @@ build_distinct_groups(int numrows, SortItem *items, MultiSortSupport mss,
Assert(j + 1 == ngroups);
/* Sort the distinct groups by frequency (in descending order). */
- qsort_interruptible((void *) groups, ngroups, sizeof(SortItem),
+ qsort_interruptible(groups, ngroups, sizeof(SortItem),
compare_sort_item_count, NULL);
*ndistinct = ngroups;
@@ -528,7 +528,7 @@ build_column_frequencies(SortItem *groups, int ngroups,
}
/* sort the values, deduplicate */
- qsort_interruptible((void *) result[dim], ngroups, sizeof(SortItem),
+ qsort_interruptible(result[dim], ngroups, sizeof(SortItem),
sort_item_compare, ssup);
/*
index 13301a3157d3b03c56052a8f8ad182a392b00fa4..df5cc3e13a7d0341c53326df4114e1a570decb98 100644 (file)
@@ -489,7 +489,7 @@ ndistinct_for_combination(double totalrows, StatsBuildData *data,
}
/* We can sort the array now ... */
- qsort_interruptible((void *) items, numrows, sizeof(SortItem),
+ qsort_interruptible(items, numrows, sizeof(SortItem),
multi_sort_compare, mss);
/* ... and count the number of distinct combinations */
index 4340bf96416a938fc185bac55c56ae8a729fcf28..a7071b2fce5f9db86cd715477ac0ae6af0277b3b 100644 (file)
pg_read_barrier(); /* pairs with GetNewTransactionId */
memcpy(snapshot->subxip + subcount,
- (void *) proc->subxids.xids,
+ proc->subxids.xids,
nsubxids * sizeof(TransactionId));
subcount += nsubxids;
}
/* barrier not really required, as XidGenLock is held, but ... */
pg_read_barrier(); /* pairs with GetNewTransactionId */
- memcpy(&xids[count], (void *) proc->subxids.xids,
+ memcpy(&xids[count], proc->subxids.xids,
nsubxids * sizeof(TransactionId));
count += nsubxids;
subcount += nsubxids;
index 83838ab438568cbd650848e6e53230ac61112566..8d48cad251e3769b68bd083dd10576f049a1b83d 100644 (file)
@@ -695,7 +695,7 @@ NIAddAffix(IspellDict *Conf, const char *flag, char flagflags, const char *mask,
if (Conf->maffixes)
{
Conf->maffixes *= 2;
- Conf->Affix = (AFFIX *) repalloc((void *) Conf->Affix, Conf->maffixes * sizeof(AFFIX));
+ Conf->Affix = (AFFIX *) repalloc(Conf->Affix, Conf->maffixes * sizeof(AFFIX));
}
else
{
@@ -1116,7 +1116,7 @@ addCompoundAffixFlagValue(IspellDict *Conf, char *s, uint32 val)
{
Conf->mCompoundAffixFlag *= 2;
Conf->CompoundAffixFlags = (CompoundAffixFlag *)
- repalloc((void *) Conf->CompoundAffixFlags,
+ repalloc(Conf->CompoundAffixFlags,
Conf->mCompoundAffixFlag * sizeof(CompoundAffixFlag));
}
else
@@ -1158,7 +1158,7 @@ getCompoundAffixFlagValue(IspellDict *Conf, char *s)
setCompoundAffixFlagValue(Conf, &key, sflag, 0);
found = (CompoundAffixFlag *)
- bsearch(&key, (void *) Conf->CompoundAffixFlags,
+ bsearch(&key, Conf->CompoundAffixFlags,
Conf->nCompoundAffixFlag, sizeof(CompoundAffixFlag),
cmpcmdflag);
if (found != NULL)
@@ -1305,7 +1305,7 @@ NIImportOOAffixes(IspellDict *Conf, const char *filename)
tsearch_readline_end(&trst);
if (Conf->nCompoundAffixFlag > 1)
- qsort((void *) Conf->CompoundAffixFlags, Conf->nCompoundAffixFlag,
+ qsort(Conf->CompoundAffixFlags, Conf->nCompoundAffixFlag,
sizeof(CompoundAffixFlag), cmpcmdflag);
if (!tsearch_readline_begin(&trst, filename))
else
{
/* Count the number of different flags used in the dictionary */
- qsort((void *) Conf->Spell, Conf->nspell, sizeof(SPELL *),
+ qsort(Conf->Spell, Conf->nspell, sizeof(SPELL *),
cmpspellaffix);
naffix = 0;
}
/* Start build a prefix tree */
- qsort((void *) Conf->Spell, Conf->nspell, sizeof(SPELL *), cmpspell);
+ qsort(Conf->Spell, Conf->nspell, sizeof(SPELL *), cmpspell);
Conf->Dictionary = mkSPNode(Conf, 0, Conf->nspell, 0);
}
/* Store compound affixes in the Conf->CompoundAffix array */
if (Conf->naffixes > 1)
- qsort((void *) Conf->Affix, Conf->naffixes, sizeof(AFFIX), cmpaffix);
+ qsort(Conf->Affix, Conf->naffixes, sizeof(AFFIX), cmpaffix);
Conf->CompoundAffix = ptr = (CMPDAffix *) palloc(sizeof(CMPDAffix) * Conf->naffixes);
ptr->affix = NULL;
index f9a87e43ab6dc2ed7891394f282f91c34fcce631..3b6d41f9e8ed35c25a6becfdfd4d74949ed1208c 100644 (file)
@@ -97,7 +97,7 @@ uniqueWORD(ParsedWord *a, int32 l)
/*
* Sort words with its positions
*/
- qsort((void *) a, l, sizeof(ParsedWord), compareWORD);
+ qsort(a, l, sizeof(ParsedWord), compareWORD);
/*
* Initialize first word and its first position
index 9b6d934958aa8d3af0b37bffb5854d31c4bcbb77..25d98527786ab3f8989b908b2b3ba83f6846c64d 100644 (file)
@@ -410,7 +410,7 @@ parsetext(Oid cfgId, ParsedText *prs, char *buf, int buflen)
if (prs->curwords == prs->lenwords)
{
prs->lenwords *= 2;
- prs->words = (ParsedWord *) repalloc((void *) prs->words, prs->lenwords * sizeof(ParsedWord));
+ prs->words = (ParsedWord *) repalloc(prs->words, prs->lenwords * sizeof(ParsedWord));
}
if (ptr->flags & TSL_ADDPOS)
@@ -442,7 +442,7 @@ hladdword(HeadlineParsedText *prs, char *buf, int buflen, int type)
if (prs->curwords >= prs->lenwords)
{
prs->lenwords *= 2;
- prs->words = (HeadlineWordEntry *) repalloc((void *) prs->words, prs->lenwords * sizeof(HeadlineWordEntry));
+ prs->words = (HeadlineWordEntry *) repalloc(prs->words, prs->lenwords * sizeof(HeadlineWordEntry));
}
memset(&(prs->words[prs->curwords]), 0, sizeof(HeadlineWordEntry));
prs->words[prs->curwords].type = (uint8) type;
@@ -470,7 +470,7 @@ hlfinditem(HeadlineParsedText *prs, TSQuery query, int32 pos, char *buf, int buf
while (prs->curwords + query->size >= prs->lenwords)
{
prs->lenwords *= 2;
- prs->words = (HeadlineWordEntry *) repalloc((void *) prs->words, prs->lenwords * sizeof(HeadlineWordEntry));
+ prs->words = (HeadlineWordEntry *) repalloc(prs->words, prs->lenwords * sizeof(HeadlineWordEntry));
}
word = &(prs->words[prs->curwords - 1]);
index bb954184d3523313de76b7ad274e59b45a5b24d7..7c4c2a91123d529a092152c983c850a4c27f3733 100644 (file)
@@ -109,8 +109,7 @@ readstoplist(const char *fname, StopList *s, char *(*wordop) (const char *))
else
{
reallen *= 2;
- stop = (char **) repalloc((void *) stop,
- sizeof(char *) * reallen);
+ stop = (char **) repalloc(stop, sizeof(char *) * reallen);
}
}
index f0411bf48f6268a3ca414beb096ba1ea1e1b8c9c..f0cd2866ff5a84bc376561688cfa260c93389f27 100644 (file)
@@ -143,7 +143,7 @@ makesign(BITVECP sign, SignTSVector *a, int siglen)
len = ARRNELEM(a);
int32 *ptr = GETARR(a);
- MemSet((void *) sign, 0, siglen);
+ MemSet(sign, 0, siglen);
for (k = 0; k < len; k++)
HASH(sign, ptr[k], siglen);
}
* val->size
*/
len = CALCGTSIZE(ARRKEY, len);
- res = (SignTSVector *) repalloc((void *) res, len);
+ res = (SignTSVector *) repalloc(res, len);
SET_VARSIZE(res, len);
}
@@ -577,7 +577,7 @@ fillcache(CACHESIGN *item, SignTSVector *key, int siglen)
else if (ISALLTRUE(key))
item->allistrue = true;
else
- memcpy((void *) item->sign, (void *) GETSIGN(key), siglen);
+ memcpy(item->sign, GETSIGN(key), siglen);
}
#define WISH_F(a,b,c) (double)( -(double)(((a)-(b))*((a)-(b))*((a)-(b)))*(c) )
size_beta = hemdistcache(&(cache[seed_2]), &(cache[j]), siglen);
costvector[j - 1].cost = abs(size_alpha - size_beta);
}
- qsort((void *) costvector, maxoff, sizeof(SPLITCOST), comparecost);
+ qsort(costvector, maxoff, sizeof(SPLITCOST), comparecost);
for (k = 0; k < maxoff; k++)
{
if (ISALLTRUE(datum_l) || cache[j].allistrue)
{
if (!ISALLTRUE(datum_l))
- memset((void *) GETSIGN(datum_l), 0xff, siglen);
+ memset(GETSIGN(datum_l), 0xff, siglen);
}
else
{
if (ISALLTRUE(datum_r) || cache[j].allistrue)
{
if (!ISALLTRUE(datum_r))
- memset((void *) GETSIGN(datum_r), 0xff, siglen);
+ memset(GETSIGN(datum_r), 0xff, siglen);
}
else
{
index 25150c6d16616921639b31483b84e1b9ace28121..67ad876a27c6a89c86486ad951fb0a090a180d67 100644 (file)
@@ -602,10 +602,10 @@ pushValue(TSQueryParserState state, char *strval, int lenval, int16 weight, bool
int used = state->curop - state->op;
state->lenop *= 2;
- state->op = (char *) repalloc((void *) state->op, state->lenop);
+ state->op = (char *) repalloc(state->op, state->lenop);
state->curop = state->op + used;
}
- memcpy((void *) state->curop, (void *) strval, lenval);
+ memcpy(state->curop, strval, lenval);
state->curop += lenval;
*(state->curop) = '0円';
state->curop++;
}
/* Copy all the operand strings to TSQuery */
- memcpy((void *) GETOPERAND(query), (void *) state.op, state.sumlen);
+ memcpy(GETOPERAND(query), state.op, state.sumlen);
pfree(state.op);
/*
index 59b3e859c32f317b12ea420e9348bef71b58f201..dc31665770618c629482f8b2e3b3d9491d55d92b 100644 (file)
@@ -67,9 +67,9 @@ plainnode(PLAINTREE *state, NODE *node)
if (state->cur == state->len)
{
state->len *= 2;
- state->ptr = (QueryItem *) repalloc((void *) state->ptr, state->len * sizeof(QueryItem));
+ state->ptr = (QueryItem *) repalloc(state->ptr, state->len * sizeof(QueryItem));
}
- memcpy((void *) &(state->ptr[state->cur]), (void *) node->valnode, sizeof(QueryItem));
+ memcpy(&(state->ptr[state->cur]), node->valnode, sizeof(QueryItem));
if (node->valnode->type == QI_VAL)
state->cur++;
else if (node->valnode->qoperator.oper == OP_NOT)
index b7941ffaca865173ac2062f371e0cd4b6a6bcaa1..7c99348d44c8097b52413c14c314fa74df9cabb3 100644 (file)
size_beta = hemdist(GETENTRY(entryvec, seed_2), GETENTRY(entryvec, j));
costvector[j - 1].cost = abs(size_alpha - size_beta);
}
- qsort((void *) costvector, maxoff, sizeof(SPLITCOST), comparecost);
+ qsort(costvector, maxoff, sizeof(SPLITCOST), comparecost);
for (k = 0; k < maxoff; k++)
{
index f266b9f0676bf7a51f07fecce9a69269999ba39e..7b6970a6f82aecf5f109c94e00c9a28b181d7f3d 100644 (file)
for (i = 0; i < in->nchild; i++)
QTNSort(in->child[i]);
if (in->nchild > 1 && in->valnode->qoperator.oper != OP_PHRASE)
- qsort((void *) in->child, in->nchild, sizeof(QTNode *), cmpQTN);
+ qsort(in->child, in->nchild, sizeof(QTNode *), cmpQTN);
}
/*
index 1ae555f7f708fd6cbc7100dbb825b1f41855d090..e5b850ea8ef42af816130f5519eb2b8963f85d23 100644 (file)
if (*size < 2)
return res;
- qsort_arg(res, *size, sizeof(QueryOperand *), compareQueryOperand, (void *) operand);
+ qsort_arg(res, *size, sizeof(QueryOperand *), compareQueryOperand, operand);
ptr = res + 1;
prevptr = res;
@@ -804,7 +804,7 @@ get_docrep(TSVector txt, QueryRepresentation *qr, int *doclen)
/*
* Sort representation in ascending order by pos and entry
*/
- qsort((void *) doc, cur, sizeof(DocRepresentation), compareDocR);
+ qsort(doc, cur, sizeof(DocRepresentation), compareDocR);
/*
* Join QueryItem per WordEntry and it's position
index c7e20ce4ecc18793f2470d0d14c951b7cddddb46..0e66f362c306c223ed35bdd9c43d267a417d2a32 100644 (file)
@@ -58,7 +58,7 @@ uniquePos(WordEntryPos *a, int l)
if (l <= 1)
return l;
- qsort((void *) a, l, sizeof(WordEntryPos), compareWordEntryPos);
+ qsort(a, l, sizeof(WordEntryPos), compareWordEntryPos);
res = a;
ptr = a + 1;
@@ -107,8 +107,7 @@ uniqueentry(WordEntryIN *a, int l, char *buf, int *outbuflen)
Assert(l >= 1);
if (l > 1)
- qsort_arg((void *) a, l, sizeof(WordEntryIN), compareentry,
- (void *) buf);
+ qsort_arg(a, l, sizeof(WordEntryIN), compareentry, buf);
buflen = 0;
res = a;
{
arrlen *= 2;
arr = (WordEntryIN *)
- repalloc((void *) arr, sizeof(WordEntryIN) * arrlen);
+ repalloc(arr, sizeof(WordEntryIN) * arrlen);
}
while ((cur - tmpbuf) + toklen >= buflen)
{
int dist = cur - tmpbuf;
buflen *= 2;
- tmpbuf = (char *) repalloc((void *) tmpbuf, buflen);
+ tmpbuf = (char *) repalloc(tmpbuf, buflen);
cur = tmpbuf + dist;
}
arr[len].entry.len = toklen;
arr[len].entry.pos = cur - tmpbuf;
- memcpy((void *) cur, (void *) token, toklen);
+ memcpy(cur, token, toklen);
cur += toklen;
if (poslen != 0)
SET_VARSIZE(vec, hdrlen + datalen);
if (needSort)
- qsort_arg((void *) ARRPTR(vec), vec->size, sizeof(WordEntry),
- compareentry, (void *) STRPTR(vec));
+ qsort_arg(ARRPTR(vec), vec->size, sizeof(WordEntry),
+ compareentry, STRPTR(vec));
PG_RETURN_TSVECTOR(vec);
}
index 9bfb95557a9294725f5f4d719a88515cb373d8e4..da0723ad38587c36f53a6878349b433d3e735b4e 100644 (file)
return -1;
}
- memset((void *) &serv_addr, 0, sizeof(serv_addr));
+ memset(&serv_addr, 0, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_port = pg_hton16(0);
serv_addr.sin_addr.s_addr = pg_hton32(INADDR_LOOPBACK);
index cb4386f8710f7b29e3c2c28194ec57073d5d683e..269bfce019b5b9354c0a21b3a3412dffe7297eab 100644 (file)
@@ -2363,8 +2363,7 @@ WriteDataChunks(ArchiveHandle *AH, ParallelState *pstate)
}
if (ntes > 1)
- qsort((void *) tes, ntes, sizeof(TocEntry *),
- TocEntrySizeCompare);
+ qsort(tes, ntes, sizeof(TocEntry *), TocEntrySizeCompare);
for (int i = 0; i < ntes; i++)
DispatchJobForTocEntry(AH, pstate, tes[i], ACT_DUMP,
index f963b9a4498913b22331af40e8b0a995091d95e5..8266c117a3ef963376f90fc0aa2c3d25a1ffb37a 100644 (file)
sortDumpableObjectsByTypeName(DumpableObject **objs, int numObjs)
{
if (numObjs > 1)
- qsort((void *) objs, numObjs, sizeof(DumpableObject *),
+ qsort(objs, numObjs, sizeof(DumpableObject *),
DOTypeNameCompare);
}
index 9ad75446eecd1a40c5d425fe7909672767040be3..dc8800c7cdeeb1c7549dc95a88b3469f9a8b1d16 100644 (file)
* consistent order, which is important for reproducible behavior if one
* library depends on another.
*/
- qsort((void *) os_info.libraries, os_info.num_libraries,
+ qsort(os_info.libraries, os_info.num_libraries,
sizeof(LibraryInfo), library_name_compare);
for (libnum = 0; libnum < os_info.num_libraries; libnum++)
index 9c12ffaea9338fe0284b0c8363686e407ff1a490..508ed218e83923008ce1aba972c6ebf968ef1b0b 100644 (file)
/* Sort if we have to */
if (!variables->vars_sorted)
{
- qsort((void *) variables->vars, variables->nvars, sizeof(Variable),
+ qsort(variables->vars, variables->nvars, sizeof(Variable),
compareVariableNames);
variables->vars_sorted = true;
}
/* Now we can search */
key.name = name;
- return (Variable *) bsearch((void *) &key,
- (void *) variables->vars,
+ return (Variable *) bsearch(&key,
+ variables->vars,
variables->nvars,
sizeof(Variable),
compareVariableNames);
index cdd155ebbdd80957e1db04f1b5e92fee6ce73acd..ceffb56835b81734ba25b86ecb8c1bfa51e9e623 100644 (file)
* VARDATA is a pointer to the data region of the new struct. The source
* could be a short datum, so retrieve its data through VARDATA_ANY.
*/
- memcpy((void *) VARDATA(new_t), /* destination */
- (void *) VARDATA_ANY(t), /* source */
+ memcpy(VARDATA(new_t), /* destination */
+ VARDATA_ANY(t), /* source */
VARSIZE_ANY_EXHDR(t)); /* how many bytes */
PG_RETURN_TEXT_P(new_t);
}