mirrors/postgres
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Remove unnecessary casts

Browse Source 
Some code carefully cast all data buffer arguments for data write and
read function calls to void *, even though the respective arguments
are already void *.  Remove this unnecessary clutter.

Discussion: https://www.postgresql.org/message-id/flat/11dda853-bb5b-59ba-a746-e168b1ce4bdb%40enterprisedb.com
This commit is contained in:
Peter Eisentraut 2022-12-30 10:02:59 +01:00
parent 388e80132c
commit 5f2f99c9c6
5 changed files with 23 additions and 23 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/backend/executor/nodeAgg.c
View File

@ -2961,10 +2961,10 @@ hashagg_spill_tuple(AggState *aggstate, HashAggSpill *spill,
tape = spill->partitions[partition]; tape = spill->partitions[partition];
LogicalTapeWrite(tape, (void *) &hash, sizeof(uint32)); LogicalTapeWrite(tape, &hash, sizeof(uint32));
total_written += sizeof(uint32); total_written += sizeof(uint32);
LogicalTapeWrite(tape, (void *) tuple, tuple->t_len); LogicalTapeWrite(tape, tuple, tuple->t_len);
total_written += tuple->t_len; total_written += tuple->t_len;
if (shouldFree) if (shouldFree)
@ -3029,7 +3029,7 @@ hashagg_batch_read(HashAggBatch *batch, uint32 *hashp)
tuple->t_len = t_len; tuple->t_len = t_len;
nread = LogicalTapeRead(tape, nread = LogicalTapeRead(tape,
(void *) ((char *) tuple + sizeof(uint32)), (char *) tuple + sizeof(uint32),
t_len - sizeof(uint32)); t_len - sizeof(uint32));
if (nread != t_len - sizeof(uint32)) if (nread != t_len - sizeof(uint32))
ereport(ERROR, ereport(ERROR,

4
src/backend/storage/file/buffile.c
View File

@ -607,7 +607,7 @@ BufFileRead(BufFile *file, void *ptr, size_t size)
memcpy(ptr, file->buffer.data + file->pos, nthistime); memcpy(ptr, file->buffer.data + file->pos, nthistime);
file->pos += nthistime; file->pos += nthistime;
ptr = (void *) ((char *) ptr + nthistime); ptr = (char *) ptr + nthistime;
size -= nthistime; size -= nthistime;
nread += nthistime; nread += nthistime;
} }
@ -655,7 +655,7 @@ BufFileWrite(BufFile *file, void *ptr, size_t size)
file->pos += nthistime; file->pos += nthistime;
if (file->nbytes < file->pos) if (file->nbytes < file->pos)
file->nbytes = file->pos; file->nbytes = file->pos;
ptr = (void *) ((char *) ptr + nthistime); ptr = (char *) ptr + nthistime;
size -= nthistime; size -= nthistime;
} }
} }

18
src/backend/utils/sort/logtape.c
View File

@ -319,7 +319,7 @@ ltsReadFillBuffer(LogicalTape *lt)
datablocknum += lt->offsetBlockNumber; datablocknum += lt->offsetBlockNumber;
/* Read the block */ /* Read the block */
ltsReadBlock(lt->tapeSet, datablocknum, (void *) thisbuf); ltsReadBlock(lt->tapeSet, datablocknum, thisbuf);
if (!lt->frozen) if (!lt->frozen)
ltsReleaseBlock(lt->tapeSet, datablocknum); ltsReleaseBlock(lt->tapeSet, datablocknum);
lt->curBlockNumber = lt->nextBlockNumber; lt->curBlockNumber = lt->nextBlockNumber;
@ -806,7 +806,7 @@ LogicalTapeWrite(LogicalTape *lt, void *ptr, size_t size)
/* set the next-pointer and dump the current block. */ /* set the next-pointer and dump the current block. */
TapeBlockGetTrailer(lt->buffer)->next = nextBlockNumber; TapeBlockGetTrailer(lt->buffer)->next = nextBlockNumber;
ltsWriteBlock(lt->tapeSet, lt->curBlockNumber, (void *) lt->buffer); ltsWriteBlock(lt->tapeSet, lt->curBlockNumber, lt->buffer);
/* initialize the prev-pointer of the next block */ /* initialize the prev-pointer of the next block */
TapeBlockGetTrailer(lt->buffer)->prev = lt->curBlockNumber; TapeBlockGetTrailer(lt->buffer)->prev = lt->curBlockNumber;
@ -826,7 +826,7 @@ LogicalTapeWrite(LogicalTape *lt, void *ptr, size_t size)
lt->pos += nthistime; lt->pos += nthistime;
if (lt->nbytes < lt->pos) if (lt->nbytes < lt->pos)
lt->nbytes = lt->pos; lt->nbytes = lt->pos;
ptr = (void *) ((char *) ptr + nthistime); ptr = (char *) ptr + nthistime;
size -= nthistime; size -= nthistime;
} }
} }
@ -888,7 +888,7 @@ LogicalTapeRewindForRead(LogicalTape *lt, size_t buffer_size)
lt->buffer_size - lt->nbytes); lt->buffer_size - lt->nbytes);
TapeBlockSetNBytes(lt->buffer, lt->nbytes); TapeBlockSetNBytes(lt->buffer, lt->nbytes);
ltsWriteBlock(lt->tapeSet, lt->curBlockNumber, (void *) lt->buffer); ltsWriteBlock(lt->tapeSet, lt->curBlockNumber, lt->buffer);
} }
lt->writing = false; lt->writing = false;
} }
@ -953,7 +953,7 @@ LogicalTapeRead(LogicalTape *lt, void *ptr, size_t size)
memcpy(ptr, lt->buffer + lt->pos, nthistime); memcpy(ptr, lt->buffer + lt->pos, nthistime);
lt->pos += nthistime; lt->pos += nthistime;
ptr = (void *) ((char *) ptr + nthistime); ptr = (char *) ptr + nthistime;
size -= nthistime; size -= nthistime;
nread += nthistime; nread += nthistime;
} }
@ -1004,7 +1004,7 @@ LogicalTapeFreeze(LogicalTape *lt, TapeShare *share)
lt->buffer_size - lt->nbytes); lt->buffer_size - lt->nbytes);
TapeBlockSetNBytes(lt->buffer, lt->nbytes); TapeBlockSetNBytes(lt->buffer, lt->nbytes);
ltsWriteBlock(lt->tapeSet, lt->curBlockNumber, (void *) lt->buffer); ltsWriteBlock(lt->tapeSet, lt->curBlockNumber, lt->buffer);
} }
lt->writing = false; lt->writing = false;
lt->frozen = true; lt->frozen = true;
@ -1031,7 +1031,7 @@ LogicalTapeFreeze(LogicalTape *lt, TapeShare *share)
if (lt->firstBlockNumber == -1L) if (lt->firstBlockNumber == -1L)
lt->nextBlockNumber = -1L; lt->nextBlockNumber = -1L;
ltsReadBlock(lt->tapeSet, lt->curBlockNumber, (void *) lt->buffer); ltsReadBlock(lt->tapeSet, lt->curBlockNumber, lt->buffer);
if (TapeBlockIsLast(lt->buffer)) if (TapeBlockIsLast(lt->buffer))
lt->nextBlockNumber = -1L; lt->nextBlockNumber = -1L;
else else
@ -1098,7 +1098,7 @@ LogicalTapeBackspace(LogicalTape *lt, size_t size)
return seekpos; return seekpos;
} }
ltsReadBlock(lt->tapeSet, prev, (void *) lt->buffer); ltsReadBlock(lt->tapeSet, prev, lt->buffer);
if (TapeBlockGetTrailer(lt->buffer)->next != lt->curBlockNumber) if (TapeBlockGetTrailer(lt->buffer)->next != lt->curBlockNumber)
elog(ERROR, "broken tape, next of block %ld is %ld, expected %ld", elog(ERROR, "broken tape, next of block %ld is %ld, expected %ld",
@ -1142,7 +1142,7 @@ LogicalTapeSeek(LogicalTape *lt, long blocknum, int offset)
if (blocknum != lt->curBlockNumber) if (blocknum != lt->curBlockNumber)
{ {
ltsReadBlock(lt->tapeSet, blocknum, (void *) lt->buffer); ltsReadBlock(lt->tapeSet, blocknum, lt->buffer);
lt->curBlockNumber = blocknum; lt->curBlockNumber = blocknum;
lt->nbytes = TapeBlockPayloadSize; lt->nbytes = TapeBlockPayloadSize;
lt->nextBlockNumber = TapeBlockGetTrailer(lt->buffer)->next; lt->nextBlockNumber = TapeBlockGetTrailer(lt->buffer)->next;

2
src/backend/utils/sort/tuplesort.c
View File

@ -2908,7 +2908,7 @@ markrunend(LogicalTape *tape)
{ {
unsigned int len = 0; unsigned int len = 0;
LogicalTapeWrite(tape, (void *) &len, sizeof(len)); LogicalTapeWrite(tape, &len, sizeof(len));
} }
/* /*

16
src/backend/utils/sort/tuplesortvariants.c
View File

@ -1002,10 +1002,10 @@ writetup_heap(Tuplesortstate *state, LogicalTape *tape, SortTuple *stup)
/* total on-disk footprint: */ /* total on-disk footprint: */
unsigned int tuplen = tupbodylen + sizeof(int); unsigned int tuplen = tupbodylen + sizeof(int);
LogicalTapeWrite(tape, (void *) &tuplen, sizeof(tuplen)); LogicalTapeWrite(tape, &tuplen, sizeof(tuplen));
LogicalTapeWrite(tape, (void *) tupbody, tupbodylen); LogicalTapeWrite(tape, tupbody, tupbodylen);
if (base->sortopt & TUPLESORT_RANDOMACCESS) /* need trailing length word? */ if (base->sortopt & TUPLESORT_RANDOMACCESS) /* need trailing length word? */
LogicalTapeWrite(tape, (void *) &tuplen, sizeof(tuplen)); LogicalTapeWrite(tape, &tuplen, sizeof(tuplen));
} }
static void static void
@ -1475,10 +1475,10 @@ writetup_index(Tuplesortstate *state, LogicalTape *tape, SortTuple *stup)
unsigned int tuplen; unsigned int tuplen;
tuplen = IndexTupleSize(tuple) + sizeof(tuplen); tuplen = IndexTupleSize(tuple) + sizeof(tuplen);
LogicalTapeWrite(tape, (void *) &tuplen, sizeof(tuplen)); LogicalTapeWrite(tape, &tuplen, sizeof(tuplen));
LogicalTapeWrite(tape, (void *) tuple, IndexTupleSize(tuple)); LogicalTapeWrite(tape, tuple, IndexTupleSize(tuple));
if (base->sortopt & TUPLESORT_RANDOMACCESS) /* need trailing length word? */ if (base->sortopt & TUPLESORT_RANDOMACCESS) /* need trailing length word? */
LogicalTapeWrite(tape, (void *) &tuplen, sizeof(tuplen)); LogicalTapeWrite(tape, &tuplen, sizeof(tuplen));
} }
static void static void
@ -1564,10 +1564,10 @@ writetup_datum(Tuplesortstate *state, LogicalTape *tape, SortTuple *stup)
writtenlen = tuplen + sizeof(unsigned int); writtenlen = tuplen + sizeof(unsigned int);
LogicalTapeWrite(tape, (void *) &writtenlen, sizeof(writtenlen)); LogicalTapeWrite(tape, &writtenlen, sizeof(writtenlen));
LogicalTapeWrite(tape, waddr, tuplen); LogicalTapeWrite(tape, waddr, tuplen);
if (base->sortopt & TUPLESORT_RANDOMACCESS) /* need trailing length word? */ if (base->sortopt & TUPLESORT_RANDOMACCESS) /* need trailing length word? */
LogicalTapeWrite(tape, (void *) &writtenlen, sizeof(writtenlen)); LogicalTapeWrite(tape, &writtenlen, sizeof(writtenlen));
} }
static void static void