mirror
/
sane-project-backends
kopia lustrzana https://gitlab.com/sane-project/backends
1
0
Forkuj 0
Kod Zgłoszenia Projekty Wydania Wiki Aktywność

Cast pointer arguments if needed when using "%p" format specifier 

Pointer arguments must have type (void *) when printed with the format
specifier "%p".
merge-requests/701/head
David Ward 2022-03-08 19:00:00 -05:00
rodzic f3162bafa8
commit 1a933bba7e
28 zmienionych plików z 126 dodań i 110 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

4
backend/artec.c
Wyświetl plik

@ -3474,7 +3474,7 @@ artec_sane_read (SANE_Handle handle, SANE_Byte * buf, SANE_Int max_len, SANE_Int
SANE_Byte line_buf[ARTEC_MAX_READ_SIZE];
DBG (7, "artec_sane_read( %p, %p, %d, %d )\n", handle, buf, max_len, *len);
DBG (7, "artec_sane_read( %p, %p, %d, %d )\n", handle, (void *) buf, max_len, *len);
*len = 0;
@ -3674,7 +3674,7 @@ sane_read (SANE_Handle handle, SANE_Byte * buf, SANE_Int max_len, SANE_Int * len
static SANE_Byte temp_buf[ARTEC_MAX_READ_SIZE];
static int bytes_in_buf = 0;
DBG (7, "sane_read( %p, %p, %d, %d )\n", handle, buf, max_len, *len);
DBG (7, "sane_read( %p, %p, %d, %d )\n", handle, (void *) buf, max_len, *len);
DBG (9, "sane_read: bib = %d, ml = %d\n", bytes_in_buf, max_len);
if (bytes_in_buf != 0)

2
backend/artec_eplus48u.c
Wyświetl plik

@ -1628,7 +1628,7 @@ artec48u_device_memory_read (Artec48U_Device * dev,
SANE_Status status;
XDBG ((8, "%s: dev=%p, addr=0x%x, size=0x%x, data=%p\n",
function_name, (void *) dev, addr, size, data));
function_name, (void *) dev, addr, size, (void *) data));
CHECK_DEV_ACTIVE (dev, function_name);
status = sanei_usb_control_msg (dev->fd, 0xc0, 0x01,

8
backend/dell1600n_net.c
Wyświetl plik

@ -946,7 +946,7 @@ HexDump (int debugLevel, const unsigned char *buf, size_t bufSize)
{
if (!(i % 16))
sprintf (lineBuf, "%p: ", (buf + i));
sprintf (lineBuf, "%p: ", (void *) &buf[i]);
sprintf (itemBuf, "%02x ", (const unsigned int) buf[i]);
@ -1199,7 +1199,7 @@ ProcessFindResponse (unsigned char *pData, size_t size)
DBG (10, "ProcessFindResponse: processing %lu bytes, pData=%p\n",
(unsigned long)size, pData);
(unsigned long) size, (void *) pData);
/* check we have a complete packet */
if (!MessageIsComplete (pData, size))
@ -1355,7 +1355,7 @@ ProcessUdpResponse (unsigned char *pData, size_t size,
HexDump (15, pData, size);
DBG (10, "ProcessUdpResponse: processing %lu bytes, pData=%p\n",
(unsigned long)size, pData);
(unsigned long) size, (void *) pData);
/* check we have a complete packet */
if (!MessageIsComplete (pData, size))
@ -1486,7 +1486,7 @@ ProcessTcpResponse (struct ScannerState *pState, struct ComBuf *pTcpBuf)
int bProcessImage = 0;
DBG (10, "ProcessTcpResponse: processing %lu bytes, pData=%p\n",
(unsigned long)pTcpBuf->m_used, pData);
(unsigned long) pTcpBuf->m_used, (void *) pData);
HexDump (15, pData, pTcpBuf->m_used);
/* if message not complete then wait for more to arrive */

2
backend/dll.c
Wyświetl plik

@ -1365,7 +1365,7 @@ sane_read (SANE_Handle handle, SANE_Byte * data, SANE_Int max_length,
struct meta_scanner *s = handle;
DBG (3, "sane_read(handle=%p,data=%p,maxlen=%d,lenp=%p)\n",
handle, data, max_length, (void *) length);
handle, (void *) data, max_length, (void *) length);
return (*(op_read_t)s->be->op[OP_READ]) (s->handle, data, max_length, length);
}

2
backend/epson2.c
Wyświetl plik

@ -2348,7 +2348,7 @@ sane_read(SANE_Handle handle, SANE_Byte *data, SANE_Int max_length,
/* XXX if FS G and STATUS_IOERR, use e2_check_extended_status */
DBG(18, "moving data %p %p, %d (%d lines)\n",
s->ptr, s->end,
(void *) s->ptr, (void *) s->end,
max_length, max_length / s->params.bytes_per_line);
e2_copy_image_data(s, data, max_length, length);

10
backend/epson2_net.c
Wyświetl plik

@ -70,7 +70,7 @@ sanei_epson_net_read_buf(Epson_Scanner *s, unsigned char *buf, ssize_t wanted,
ssize_t read = 0;
DBG(23, "%s: reading up to %lu from buffer at %p, %lu available\n",
__func__, (u_long) wanted, s->netptr, (u_long) s->netlen);
__func__, (u_long) wanted, (void *) s->netptr, (u_long) s->netlen);
if ((size_t) wanted > s->netlen) {
*status = SANE_STATUS_IO_ERROR;
@ -84,7 +84,7 @@ sanei_epson_net_read_buf(Epson_Scanner *s, unsigned char *buf, ssize_t wanted,
s->netlen -= read;
if (s->netlen == 0) {
DBG(23, "%s: freeing %p\n", __func__, s->netbuf);
DBG(23, "%s: freeing %p\n", __func__, (void *) s->netbuf);
free(s->netbuf);
s->netbuf = s->netptr = NULL;
s->netlen = 0;
@ -179,7 +179,7 @@ sanei_epson_net_write(Epson_Scanner *s, unsigned int cmd, const unsigned char *b
if (reply_len) {
if (s->netbuf) {
DBG(23, "%s, freeing %p, %ld bytes unprocessed\n",
__func__, s->netbuf, (u_long) s->netlen);
__func__, (void *) s->netbuf, (u_long) s->netlen);
free(s->netbuf);
s->netbuf = s->netptr = NULL;
s->netlen = 0;
@ -192,11 +192,11 @@ sanei_epson_net_write(Epson_Scanner *s, unsigned int cmd, const unsigned char *b
}
s->netlen = reply_len;
DBG(24, "%s: allocated %lu bytes at %p\n", __func__,
(u_long) s->netlen, s->netbuf);
(u_long) s->netlen, (void *) s->netbuf);
}
DBG(24, "%s: cmd = %04x, buf = %p, buf_size = %lu, reply_len = %lu\n",
__func__, cmd, buf, (u_long) buf_size, (u_long) reply_len);
__func__, cmd, (void *) buf, (u_long) buf_size, (u_long) reply_len);
memset(h1, 0x00, 12);
memset(h2, 0x00, 8);

10
backend/epsonds-net.c
Wyświetl plik

@ -79,7 +79,7 @@ epsonds_net_read_buf(epsonds_scanner *s, unsigned char *buf, ssize_t wanted,
ssize_t read = 0;
DBG(23, "%s: reading up to %lu from buffer at %p, %lu available\n",
__func__, (u_long) wanted, s->netptr, (u_long) s->netlen);
__func__, (u_long) wanted, (void *) s->netptr, (u_long) s->netlen);
if ((size_t) wanted > s->netlen) {
*status = SANE_STATUS_IO_ERROR;
@ -93,7 +93,7 @@ epsonds_net_read_buf(epsonds_scanner *s, unsigned char *buf, ssize_t wanted,
s->netlen -= read;
if (s->netlen == 0) {
DBG(23, "%s: freeing %p\n", __func__, s->netbuf);
DBG(23, "%s: freeing %p\n", __func__, (void *) s->netbuf);
free(s->netbuf);
s->netbuf = s->netptr = NULL;
s->netlen = 0;
@ -195,7 +195,7 @@ epsonds_net_write(epsonds_scanner *s, unsigned int cmd, const unsigned char *buf
if (reply_len) {
if (s->netbuf) {
DBG(23, "%s, freeing %p, %ld bytes unprocessed\n",
__func__, s->netbuf, (u_long) s->netlen);
__func__, (void *) s->netbuf, (u_long) s->netlen);
free(s->netbuf);
s->netbuf = s->netptr = NULL;
s->netlen = 0;
@ -208,11 +208,11 @@ epsonds_net_write(epsonds_scanner *s, unsigned int cmd, const unsigned char *buf
}
s->netlen = reply_len;
DBG(24, "%s: allocated %lu bytes at %p\n", __func__,
(u_long) s->netlen, s->netbuf);
(u_long) s->netlen, (void *) s->netbuf);
}
DBG(24, "%s: cmd = %04x, buf = %p, buf_size = %lu, reply_len = %lu\n",
__func__, cmd, buf, (u_long) buf_size, (u_long) reply_len);
__func__, cmd, (void *) buf, (u_long) buf_size, (u_long) reply_len);
memset(h1, 0x00, 12);
memset(h2, 0x00, 8);

4
backend/gt68xx_low.c
Wyświetl plik

@ -425,7 +425,7 @@ gt68xx_device_memory_write (GT68xx_Device * dev,
SANE_Status status;
DBG (8,
"gt68xx_device_memory_write: dev=%p, addr=0x%x, size=0x%x, data=%p\n",
(void *) dev, addr, size, data);
(void *) dev, addr, size, (void *) data);
CHECK_DEV_ACTIVE (dev, "gt68xx_device_memory_write");
status =
sanei_usb_control_msg (dev->fd, 0x40,
@ -448,7 +448,7 @@ gt68xx_device_memory_read (GT68xx_Device * dev,
SANE_Status status;
DBG (8,
"gt68xx_device_memory_read: dev=%p, addr=0x%x, size=0x%x, data=%p\n",
(void *) dev, addr, size, data);
(void *) dev, addr, size, (void *) data);
CHECK_DEV_ACTIVE (dev, "gt68xx_device_memory_read");
status =
sanei_usb_control_msg (dev->fd, 0xc0,

5
backend/hp5590_low.c
Wyświetl plik

@ -796,8 +796,9 @@ hp5590_bulk_read (SANE_Int dn,
DBG (DBG_err,
"%s: USB-in-USB: attempted to access over the end of buffer "
"(in_ptr: %p, end_ptr: %p, ptr: %p, buffer size: %u\n",
__func__, bulk_read_state->buffer_in_ptr,
bulk_read_state->buffer_end_ptr, bulk_read_state->buffer,
__func__, (void *) bulk_read_state->buffer_in_ptr,
(void *) bulk_read_state->buffer_end_ptr,
(void *) bulk_read_state->buffer,
bulk_read_state->buffer_size);
return SANE_STATUS_NO_MEM;
}

16
backend/lexmark_low.c
Wyświetl plik

@ -4994,14 +4994,14 @@ sanei_lexmark_low_read_scan_data (SANE_Byte * data, SANE_Int size,
DBG (2, " Filled a buffer from the scanner\n");
DBG (2, " bytes_remaining: %lu\n", (u_long) dev->bytes_remaining);
DBG (2, " bytes_in_buffer: %lu\n", (u_long) dev->bytes_in_buffer);
DBG (2, " read_pointer: %p\n", dev->read_pointer);
DBG (2, " read_pointer: %p\n", (void *) dev->read_pointer);
}
}
DBG (5, "READ BUFFER INFO: \n");
DBG (5, " write ptr: %p\n", dev->read_buffer->writeptr);
DBG (5, " read ptr: %p\n", dev->read_buffer->readptr);
DBG (5, " max write ptr: %p\n", dev->read_buffer->max_writeptr);
DBG (5, " write ptr: %p\n", (void *) dev->read_buffer->writeptr);
DBG (5, " read ptr: %p\n", (void *) dev->read_buffer->readptr);
DBG (5, " max write ptr: %p\n", (void *) dev->read_buffer->max_writeptr);
DBG (5, " buffer size: %lu\n", (u_long) dev->read_buffer->size);
DBG (5, " line size: %lu\n", (u_long) dev->read_buffer->linesize);
DBG (5, " empty: %d\n", dev->read_buffer->empty);
@ -5059,9 +5059,9 @@ sanei_lexmark_low_read_scan_data (SANE_Byte * data, SANE_Int size,
}
DBG (5, "READ BUFFER INFO: \n");
DBG (5, " write ptr: %p\n", dev->read_buffer->writeptr);
DBG (5, " read ptr: %p\n", dev->read_buffer->readptr);
DBG (5, " max write ptr: %p\n", dev->read_buffer->max_writeptr);
DBG (5, " write ptr: %p\n", (void *) dev->read_buffer->writeptr);
DBG (5, " read ptr: %p\n", (void *) dev->read_buffer->readptr);
DBG (5, " max write ptr: %p\n", (void *) dev->read_buffer->max_writeptr);
DBG (5, " buffer size: %lu\n", (u_long) dev->read_buffer->size);
DBG (5, " line size: %lu\n", (u_long) dev->read_buffer->linesize);
DBG (5, " empty: %d\n", dev->read_buffer->empty);
@ -5074,7 +5074,7 @@ sanei_lexmark_low_read_scan_data (SANE_Byte * data, SANE_Int size,
DBG (2, " Copying lines from buffer to data\n");
DBG (2, " bytes_remaining: %lu\n", (u_long) dev->bytes_remaining);
DBG (2, " bytes_in_buffer: %lu\n", (u_long) dev->bytes_in_buffer);
DBG (2, " read_pointer: %p\n", dev->read_buffer->readptr);
DBG (2, " read_pointer: %p\n", (void *) dev->read_buffer->readptr);
DBG (2, " bytes_read %lu\n", (u_long) bytes_read);
/* if no more bytes to xfer and read buffer empty we're at the end */

2
backend/ma1509.c
Wyświetl plik

@ -161,7 +161,7 @@ ma1509_cmd (Ma1509_Scanner * s, const SANE_Byte * cmd, SANE_Byte * data,
#define MA1509_READ_LIMIT (1024 * 256)
DBG (5, "ma1509_cmd: fd=%d, cmd=%p, data=%p, data_size=%ld\n",
s->fd, cmd, data, (long int) (data_size ? *data_size : 0));
s->fd, (void *) cmd, (void *) data, (long int) (data_size ? *data_size : 0));
DBG (5, "ma1509_cmd: cmd = %02x %02x %02x %02x %02x %02x %02x %02x \n",
cmd[0], cmd[1], cmd[2], cmd[3], cmd[4], cmd[5], cmd[6], cmd[7]);

2
backend/magicolor.c
Wyświetl plik

@ -3001,7 +3001,7 @@ sane_read(SANE_Handle handle, SANE_Byte *data, SANE_Int max_length,
}
DBG(18, "moving data %p %p, %d (%d lines)\n",
s->ptr, s->end,
(void *) s->ptr, (void *) s->end,
max_length, max_length / s->params.bytes_per_line);
mc_copy_image_data(s, data, max_length, length);

5
backend/microtek.c
Wyświetl plik

@ -2356,7 +2356,8 @@ static SANE_Status do_real_calibrate(Microtek_Scanner *s)
input = calloc(STRIPS * 3 * linewidth, sizeof(input[0]));
combuff = calloc(linewidth + 6, sizeof(combuff[0]));
if ((input == NULL) || (combuff == NULL)) {
DBG(23, "do_real_cal: bad calloc %p %p\n", input, combuff);
DBG(23, "do_real_cal: bad calloc %p %p\n",
(void *) input, (void *) combuff);
free(input);
free(combuff);
return SANE_STATUS_NO_MEM;
@ -2370,7 +2371,7 @@ static SANE_Status do_real_calibrate(Microtek_Scanner *s)
ntoget = (nleft > nmax) ? nmax : nleft;
buffsize = ntoget * 3 * linewidth;
DBG(23, "...nleft %d toget %d size %lu spot %d input+spot %p\n",
nleft, ntoget, (u_long) buffsize, spot, input+spot);
nleft, ntoget, (u_long) buffsize, spot, (void *) (input+spot));
if ((statusA = read_scan_data(s, ntoget, input+spot, &buffsize))
!= SANE_STATUS_GOOD) {
DBG(23, "...read scan failed\n");

118
backend/microtek2.c
Wyświetl plik

@ -195,7 +195,7 @@ sane_exit (void)
if ( md_first_dev->shading_table_w )
{
DBG(100, "free md_first_dev->shading_table_w at %p\n",
md_first_dev->shading_table_w);
(void *) md_first_dev->shading_table_w);
free((void *) md_first_dev->shading_table_w);
md_first_dev->shading_table_w = NULL;
}
@ -203,7 +203,7 @@ sane_exit (void)
if ( md_first_dev->shading_table_d )
{
DBG(100, "free md_first_dev->shading_table_d at %p\n",
md_first_dev->shading_table_d);
(void *) md_first_dev->shading_table_d);
free((void *) md_first_dev->shading_table_d);
md_first_dev->shading_table_d = NULL;
}
@ -599,7 +599,8 @@ sane_read(SANE_Handle handle, SANE_Byte *buf, SANE_Int maxlen, SANE_Int *len )
ssize_t nread;
DBG(30, "sane_read: handle=%p, buf=%p, maxlen=%d\n", handle, buf, maxlen);
DBG(30, "sane_read: handle=%p, buf=%p, maxlen=%d\n",
handle, (void *) buf, maxlen);
*len = 0;
@ -742,7 +743,7 @@ add_device_list(SANE_String_Const dev_name, Microtek2_Device **mdev)
md->opts = md_options;
++md_num_devices;
*mdev = md;
DBG(100, "free hdev at %p\n", hdev);
DBG(100, "free hdev at %p\n", (void *) hdev);
free(hdev);
return SANE_STATUS_GOOD;
@ -1360,53 +1361,56 @@ cleanup_scanner(Microtek2_Scanner *ms)
/* free buffers */
if ( ms->buf.src_buffer[0] )
{
DBG(100, "free ms->buf.src_buffer[0] at %p\n", ms->buf.src_buffer[0]);
DBG(100, "free ms->buf.src_buffer[0] at %p\n",
(void *) ms->buf.src_buffer[0]);
free((void *) ms->buf.src_buffer[0]);
ms->buf.src_buffer[0] = NULL;
ms->buf.src_buf = NULL;
}
if ( ms->buf.src_buffer[1] )
{
DBG(100, "free ms->buf.src_buffer[1] at %p\n", ms->buf.src_buffer[1]);
DBG(100, "free ms->buf.src_buffer[1] at %p\n",
(void *) ms->buf.src_buffer[1]);
free((void *) ms->buf.src_buffer[1]);
ms->buf.src_buffer[1] = NULL;
ms->buf.src_buf = NULL;
}
if ( ms->buf.src_buf )
{
DBG(100, "free ms->buf.src_buf at %p\n", ms->buf.src_buf);
DBG(100, "free ms->buf.src_buf at %p\n", (void *) ms->buf.src_buf);
free((void *) ms->buf.src_buf);
ms->buf.src_buf = NULL;
}
if ( ms->temporary_buffer )
{
DBG(100, "free ms->temporary_buffer at %p\n", ms->temporary_buffer);
DBG(100, "free ms->temporary_buffer at %p\n",
(void *) ms->temporary_buffer);
free((void *) ms->temporary_buffer);
ms->temporary_buffer = NULL;
}
if ( ms->gamma_table )
{
DBG(100, "free ms->gamma_table at %p\n", ms->gamma_table);
DBG(100, "free ms->gamma_table at %p\n", (void *) ms->gamma_table);
free((void *) ms->gamma_table);
ms->gamma_table = NULL;
}
if ( ms->control_bytes )
{
DBG(100, "free ms->control_bytes at %p\n", ms->control_bytes);
DBG(100, "free ms->control_bytes at %p\n", (void *) ms->control_bytes);
free((void *) ms->control_bytes);
ms->control_bytes = NULL;
}
if ( ms->condensed_shading_w )
{
DBG(100, "free ms->condensed_shading_w at %p\n",
ms->condensed_shading_w);
(void *) ms->condensed_shading_w);
free((void *) ms->condensed_shading_w);
ms->condensed_shading_w = NULL;
}
if ( ms->condensed_shading_d )
{
DBG(100, "free ms->condensed_shading_d at %p\n",
ms->condensed_shading_d);
(void *) ms->condensed_shading_d);
free((void *) ms->condensed_shading_d);
ms->condensed_shading_d = NULL;
}
@ -4201,7 +4205,8 @@ scsi_send_gamma(Microtek2_Scanner *ms)
DBG(30, "scsi_send_gamma: pos=%p, size=%d, word=%d, color=%d\n",
ms->gamma_table, ms->lut_size_bytes, ms->word, ms->current_color);
(void *) ms->gamma_table, ms->lut_size_bytes, ms->word,
ms->current_color);
if ( ( 3 * ms->lut_size_bytes ) <= 0xffff ) /*send Gamma with one command*/
{
@ -4465,7 +4470,7 @@ scsi_read_control_bits(Microtek2_Scanner *ms)
int count_1s;
DBG(30, "scsi_read_control_bits: ms=%p, fd=%d\n", (void *) ms, ms->sfd);
DBG(30, "ms->control_bytes = %p\n", ms->control_bytes);
DBG(30, "ms->control_bytes = %p\n", (void *) ms->control_bytes);
RCB_SET_CMD(cmd);
RCB_SET_LENGTH(cmd, ms->n_control_bytes);
@ -4520,7 +4525,7 @@ scsi_set_window(Microtek2_Scanner *ms, int n) { /* n windows, not yet */
size = SW_CMD_L + SW_HEADER_L + n * SW_BODY_L;
setwindow = (uint8_t *) malloc(size);
DBG(100, "scsi_set_window: setwindow= %p, malloc'd %d Bytes\n",
setwindow, size);
(void *) setwindow, size);
if ( setwindow == NULL )
{
DBG(1, "scsi_set_window: malloc for setwindow failed\n");
@ -4592,7 +4597,7 @@ scsi_set_window(Microtek2_Scanner *ms, int n) { /* n windows, not yet */
if ( status != SANE_STATUS_GOOD )
DBG(1, "scsi_set_window: '%s'\n", sane_strstatus(status));
DBG(100, "scsi_set_window: free setwindow at %p\n", setwindow);
DBG(100, "scsi_set_window: free setwindow at %p\n", (void *) setwindow);
free((void *) setwindow);
return status;
}
@ -4665,7 +4670,8 @@ scsi_read_image(Microtek2_Scanner *ms, uint8_t *buffer, int bytes_per_pixel)
uint8_t tmp;
DBG(30, "scsi_read_image: ms=%p, buffer=%p\n", (void *) ms, buffer);
DBG(30, "scsi_read_image: ms=%p, buffer=%p\n",
(void *) ms, (void *) buffer);
ENDIAN_TYPE(endiantype)
RI_SET_CMD(cmd);
@ -4790,7 +4796,7 @@ scsi_read_shading(Microtek2_Scanner *ms, uint8_t *buffer, uint32_t length)
size_t size;
DBG(30, "scsi_read_shading: pos=%p, size=%d, word=%d, color=%d, dark=%d\n",
buffer, length, ms->word, ms->current_color, ms->dark);
(void *) buffer, length, ms->word, ms->current_color, ms->dark);
size = length;
@ -4807,7 +4813,8 @@ scsi_read_shading(Microtek2_Scanner *ms, uint8_t *buffer, uint32_t length)
DBG(100, "scsi_read_shading: sfd=%d, cmd=%p, sizeofcmd=%lu,"
"dest=%p, destsize=%lu\n",
ms->sfd, cmd, (u_long) sizeof(cmd), buffer, (u_long) size);
ms->sfd, (void *) cmd, (u_long) sizeof(cmd), (void *) buffer,
(u_long) size);
status = sanei_scsi_cmd(ms->sfd, cmd, sizeof(cmd), buffer, &size);
if ( status != SANE_STATUS_GOOD )
@ -4837,12 +4844,11 @@ scsi_send_shading(Microtek2_Scanner *ms,
DBG(30, "scsi_send_shading: pos=%p, size=%d, word=%d, color=%d, dark=%d\n",
shading_data, length, ms->word, ms->current_color,
dark);
(void *) shading_data, length, ms->word, ms->current_color, dark);
cmd = (uint8_t *) malloc(SSI_CMD_L + length);
DBG(100, "scsi_send_shading: cmd=%p, malloc'd %d bytes\n",
cmd, SSI_CMD_L + length);
(void *) cmd, SSI_CMD_L + length);
if ( cmd == NULL )
{
DBG(1, "scsi_send_shading: Couldn't get buffer for shading table\n");
@ -4868,7 +4874,7 @@ scsi_send_shading(Microtek2_Scanner *ms,
if ( status != SANE_STATUS_GOOD )
DBG(1, "scsi_send_shading: '%s'\n", sane_strstatus(status));
DBG(100, "free cmd at %p\n", cmd);
DBG(100, "free cmd at %p\n", (void *) cmd);
free((void *) cmd);
return status;
@ -5070,7 +5076,8 @@ scsi_sense_handler (int fd, u_char *sense, void *arg)
uint8_t ascq;
DBG(30, "scsi_sense_handler: fd=%d, sense=%p arg=%p\n",fd, sense, arg);
DBG(30, "scsi_sense_handler: fd=%d, sense=%p arg=%p\n",
fd, (void *) sense, arg);
dump_area(sense, RQS_LENGTH(sense), "SenseBuffer");
@ -5264,7 +5271,7 @@ sane_start(SANE_Handle handle)
if (ms->control_bytes) free((void *)ms->control_bytes);
ms->control_bytes = (uint8_t *) malloc(ms->n_control_bytes);
DBG(100, "sane_start: ms->control_bytes=%p, malloc'd %lu bytes\n",
ms->control_bytes, (u_long) ms->n_control_bytes);
(void *) ms->control_bytes, (u_long) ms->n_control_bytes);
if ( ms->control_bytes == NULL )
{
DBG(1, "sane_start: malloc() for control bits failed\n");
@ -5373,7 +5380,7 @@ sane_start(SANE_Handle handle)
ms->gamma_table = (uint8_t *) malloc(3 * ms->lut_size_bytes );
DBG(100, "sane_start: ms->gamma_table=%p, malloc'd %d bytes\n",
ms->gamma_table, 3 * ms->lut_size_bytes);
(void *) ms->gamma_table, 3 * ms->lut_size_bytes);
if ( ms->gamma_table == NULL )
{
DBG(1, "sane_start: malloc for gammatable failed\n");
@ -5559,7 +5566,7 @@ prepare_buffers(Microtek2_Scanner *ms)
ms->buf.src_buffer[i] = (uint8_t *) malloc(ms->src_buffer_size
+ extra_buf_size);
DBG(100, "prepare_buffers: ms->buf.src_buffer[%d]=%p,"
"malloc'd %d bytes\n", i, ms->buf.src_buffer[i],
"malloc'd %d bytes\n", i, (void *) ms->buf.src_buffer[i],
ms->src_buffer_size + extra_buf_size);
if ( ms->buf.src_buffer[i] == NULL )
{
@ -5579,7 +5586,7 @@ prepare_buffers(Microtek2_Scanner *ms)
free((void *) ms->buf.src_buf);
ms->buf.src_buf = malloc(ms->src_buffer_size);
DBG(100, "sane_start: ms->buf.src_buf=%p, malloc'd %d bytes\n",
ms->buf.src_buf, ms->src_buffer_size);
(void *) ms->buf.src_buf, ms->src_buffer_size);
if ( ms->buf.src_buf == NULL )
{
DBG(1, "sane_start: malloc for scan buffer failed\n");
@ -5602,7 +5609,7 @@ prepare_buffers(Microtek2_Scanner *ms)
{
ms->temporary_buffer = (uint8_t *) malloc(ms->remaining_bytes);
DBG(100, "sane_start: ms->temporary_buffer=%p, malloc'd %d bytes\n",
ms->temporary_buffer, ms->remaining_bytes);
(void *) ms->temporary_buffer, ms->remaining_bytes);
if ( ms->temporary_buffer == NULL )
{
DBG(1, "sane_start: malloc() for temporary buffer failed\n");
@ -5918,7 +5925,8 @@ condense_shading(Microtek2_Scanner *ms)
}
ms->condensed_shading_w = (uint8_t *)malloc(cond_length);
DBG(100, "condense_shading: ms->condensed_shading_w=%p,"
"malloc'd %d bytes\n", ms->condensed_shading_w, cond_length);
"malloc'd %d bytes\n",
(void *) ms->condensed_shading_w, cond_length);
if ( ms->condensed_shading_w == NULL )
{
DBG(1, "condense_shading: malloc for white table failed\n");
@ -5938,7 +5946,8 @@ condense_shading(Microtek2_Scanner *ms)
}
ms->condensed_shading_d = (uint8_t *)malloc(cond_length);
DBG(100, "condense_shading: ms->condensed_shading_d=%p,"
" malloc'd %d bytes\n", ms->condensed_shading_d, cond_length);
" malloc'd %d bytes\n",
(void *) ms->condensed_shading_d, cond_length);
if ( ms->condensed_shading_d == NULL )
{
DBG(1, "condense_shading: malloc for dark table failed\n");
@ -6100,7 +6109,8 @@ read_shading_image(Microtek2_Scanner *ms)
ms->shading_image = malloc(ms->bpl * ms->src_remaining_lines);
DBG(100, "read shading image: ms->shading_image=%p,"
" malloc'd %d bytes\n",
ms->shading_image, ms->bpl * ms->src_remaining_lines);
(void *) ms->shading_image,
ms->bpl * ms->src_remaining_lines);
if ( ms->shading_image == NULL )
{
DBG(1, "read_shading_image: malloc for buffer failed\n");
@ -6166,7 +6176,7 @@ read_shading_image(Microtek2_Scanner *ms)
}
DBG(100, "free memory for ms->shading_image at %p\n",
ms->shading_image);
(void *) ms->shading_image);
free((void *) ms->shading_image);
ms->shading_image = NULL;
}
@ -6241,7 +6251,7 @@ read_shading_image(Microtek2_Scanner *ms)
ms->shading_image = malloc(ms->bpl * ms->src_remaining_lines);
DBG(100, "read shading image: ms->shading_image=%p, malloc'd %d bytes\n",
ms->shading_image, ms->bpl * ms->src_remaining_lines);
(void *) ms->shading_image, ms->bpl * ms->src_remaining_lines);
if ( ms->shading_image == NULL )
{
DBG(1, "read_shading_image: malloc for buffer failed\n");
@ -6328,7 +6338,7 @@ read_shading_image(Microtek2_Scanner *ms)
return status;
DBG(100, "free memory for ms->shading_image at %p\n",
ms->shading_image);
(void *) ms->shading_image);
free((void *) ms->shading_image);
ms->shading_image = NULL;
@ -6360,7 +6370,7 @@ prepare_shading_data(Microtek2_Scanner *ms, uint32_t lines, uint8_t **data)
#endif
DBG(30, "prepare_shading_data: ms=%p, lines=%d, *data=%p\n",
(void *) ms, lines, *data);
(void *) ms, lines, (void *) *data);
md = ms->dev;
mi = &md->info[md->scan_source];
@ -6373,7 +6383,7 @@ prepare_shading_data(Microtek2_Scanner *ms, uint32_t lines, uint8_t **data)
{
*data = (uint8_t *) malloc(length);
DBG(100, "prepare_shading_data: malloc'd %d bytes at %p\n",
length, *data);
length, (void *) *data);
if ( *data == NULL )
{
DBG(1, "prepare_shading_data: malloc for shading table failed\n");
@ -6597,7 +6607,7 @@ read_cx_shading_image(Microtek2_Scanner *ms)
}
ms->shading_image = malloc(shading_bytes);
DBG(100, "read_cx_shading: ms->shading_image=%p, malloc'd %d bytes\n",
ms->shading_image, shading_bytes);
(void *) ms->shading_image, shading_bytes);
if ( ms->shading_image == NULL )
{
DBG(1, "read_cx_shading: malloc for cx_shading buffer failed\n");
@ -6642,7 +6652,7 @@ read_cx_shading_image(Microtek2_Scanner *ms)
if ( ms->shading_image )
{
DBG(100, "free memory for ms->shading_image at %p\n",
ms->shading_image);
(void *) ms->shading_image);
free((void *) ms->shading_image);
ms->shading_image = NULL;
}
@ -6694,7 +6704,7 @@ calc_cx_shading_line(Microtek2_Scanner *ms)
free( (void *)md->shading_table_w );
md->shading_table_w = (uint8_t *) malloc(shading_line_bytes);
DBG(100, "calc_cx_shading: md->shading_table_w=%p, malloc'd %d bytes\n",
md->shading_table_w, shading_line_bytes);
(void *) md->shading_table_w, shading_line_bytes);
if ( md->shading_table_w == NULL )
{
DBG(100, "calc_cx_shading: malloc for white shadingtable failed\n");
@ -6711,7 +6721,7 @@ calc_cx_shading_line(Microtek2_Scanner *ms)
free( (void *)md->shading_table_d);
md->shading_table_d = (uint8_t *) malloc(shading_line_bytes);
DBG(100, "calc_cx_shading: md->shading_table_d=%p, malloc'd %d bytes\n",
md->shading_table_d, shading_line_bytes);
(void *) md->shading_table_d, shading_line_bytes);
if ( md->shading_table_d == NULL )
{
@ -6729,8 +6739,9 @@ calc_cx_shading_line(Microtek2_Scanner *ms)
"shading_line_bytes=%d\n"
"shading_line_pixels=%d\n"
"shading_table_pointer=%p\n",
(void *) ms, md->shading_table_w, md->shading_table_d,
shading_line_bytes, shading_line_pixels, shading_table_pointer);
(void *) ms, (void *) md->shading_table_w,
(void *) md->shading_table_d, shading_line_bytes,
shading_line_pixels, (void *) shading_table_pointer);
/* calculating the median pixel values over the shading lines */
/* and write them to the shading table */
@ -6862,7 +6873,7 @@ calculate_gamma(Microtek2_Scanner *ms, uint8_t *pos, int color, char *mode)
DBG(30, "calculate_gamma: ms=%p, pos=%p, color=%d, mode=%s\n",
(void *) ms, pos, color, mode);
(void *) ms, (void *) pos, color, mode);
md = ms->dev;
mi = &md->info[md->scan_source];
@ -6980,7 +6991,7 @@ shading_function(Microtek2_Scanner *ms, uint8_t *data)
int i;
DBG(40, "shading_function: ms=%p, data=%p\n", (void *) ms, data);
DBG(40, "shading_function: ms=%p, data=%p\n", (void *) ms, (void *) data);
md = ms->dev;
mi = &md->info[md->scan_source];
@ -7174,8 +7185,9 @@ reader_process(void *data)
ms->transfer_length = ms->src_lines_to_read * ms->bpl;
DBG(30, "reader_process: transferlength=%d, lines=%d, linelength=%d, "
"real_bpl=%d, srcbuf=%p\n", ms->transfer_length,
ms->src_lines_to_read, ms->bpl, ms->real_bpl, ms->buf.src_buf);
"real_bpl=%d, srcbuf=%p\n",
ms->transfer_length, ms->src_lines_to_read, ms->bpl,
ms->real_bpl, (void *) ms->buf.src_buf);
sigprocmask (SIG_BLOCK, &sigterm_set, 0);
status = scsi_read_image(ms, ms->buf.src_buf, (ms->depth > 8) ? 2 : 1);
@ -7333,7 +7345,7 @@ chunky_copy_pixels(Microtek2_Scanner *ms, uint8_t *from)
int color;
DBG(30, "chunky_copy_pixels: from=%p, pixels=%d, fp=%p, depth=%d\n",
from, ms->ppl, (void *) ms->fp, ms->depth);
(void *) from, ms->ppl, (void *) ms->fp, ms->depth);
md = ms->dev;
if ( ms->depth > 8 )
@ -7512,7 +7524,7 @@ segreg_proc_data(Microtek2_Scanner *ms)
}
DBG(30, "segreg_proc_data: src_buf=%p, free_lines=%d\n",
ms->buf.src_buf, ms->buf.free_lines);
(void *) ms->buf.src_buf, ms->buf.free_lines);
return SANE_STATUS_GOOD;
}
@ -7881,7 +7893,7 @@ wordchunky_copy_pixels(uint8_t *from, uint32_t pixels, int depth, FILE *fp)
int color;
DBG(30, "wordchunky_copy_pixels: from=%p, pixels=%d, depth=%d\n",
from, pixels, depth);
(void *) from, pixels, depth);
if ( depth > 8 )
{
@ -7993,7 +8005,7 @@ gray_copy_pixels(Microtek2_Scanner *ms,
float s_w, s_d, shading_factor = 0;
DBG(30, "gray_copy_pixels: pixels=%d, from=%p, fp=%p, depth=%d\n",
ms->ppl, from, (void *) ms->fp, ms->depth);
ms->ppl, (void *) from, (void *) ms->fp, ms->depth);
md = ms->dev;
step = right_to_left == 1 ? -1 : 1;
@ -8228,7 +8240,7 @@ lineartfake_copy_pixels(Microtek2_Scanner *ms,
DBG(30, "lineartfake_copy_pixels: from=%p,pixels=%d,threshold=%d,file=%p\n",
from, pixels, threshold, (void *) fp);
(void *) from, pixels, threshold, (void *) fp);
md = ms->dev;
bit = 0;
dest = 0;
@ -8302,7 +8314,7 @@ auto_adjust_proc_data(Microtek2_Scanner *ms, uint8_t **temp_current)
DBG(30, "auto_adjust_proc_data: ms=%p, temp_current=%p\n",
(void *) ms, *temp_current);
(void *) ms, (void *) *temp_current);
md = ms->dev;
mi = &md->info[md->scan_source];

2
backend/mustek.c
Wyświetl plik

@ -4656,7 +4656,7 @@ output_data (Mustek_Scanner * s, FILE * fp,
SANE_Int y, num_lines;
DBG (5, "output_data: data=%p, lpb=%d, bpl=%d, extra=%p\n",
data, lines_per_buffer, bpl, extra);
(void *) data, lines_per_buffer, bpl, (void *) extra);
/* convert to pixel-interleaved format: */
if ((s->mode & MUSTEK_MODE_COLOR)

4
backend/mustek_usb_high.c
Wyświetl plik

@ -2672,7 +2672,7 @@ usb_high_scan_get_rgb_24_bit_line (Mustek_Usb_Device * dev, SANE_Byte * line,
SANE_Word lines_left;
DBG (5, "usb_high_scan_get_rgb_24_bit_line: start, dev=%p, line=%p, "
"is_order_invert=%d\n", (void *) dev, line, is_order_invert);
"is_order_invert=%d\n", (void *) dev, (void *) line, is_order_invert);
RIE (usb_low_get_row (dev->chip, dev->green, &lines_left));
@ -2701,7 +2701,7 @@ usb_high_scan_get_mono_8_bit_line (Mustek_Usb_Device * dev, SANE_Byte * line,
SANE_Word lines_left;
DBG (5, "usb_high_scan_get_mono_8_bit_line: start, dev=%p, line=%p, "
"is_order_invert=%d\n", (void *) dev, line, is_order_invert);
"is_order_invert=%d\n", (void *) dev, (void *) line, is_order_invert);
RIE (usb_low_get_row (dev->chip, dev->green, &lines_left));
RIE (usb_high_cal_calibrate (dev->mono_calibrator, dev->green +

2
backend/net.c
Wyświetl plik

@ -2132,7 +2132,7 @@ sane_read (SANE_Handle handle, SANE_Byte * data, SANE_Int max_length,
int is_even;
DBG (3, "sane_read: handle=%p, data=%p, max_length=%d, length=%p\n",
handle, data, max_length, (void *) length);
handle, (void *) data, max_length, (void *) length);
if (!length)
{
DBG (1, "sane_read: length == NULL\n");

2
backend/niash.c
Wyświetl plik

@ -1368,7 +1368,7 @@ sane_read (SANE_Handle h, SANE_Byte * buf, SANE_Int maxlen, SANE_Int * len)
TDataPipe *p;
TModeParam const *pMode;
DBG (DBG_MSG, "sane_read: buf=%p, maxlen=%d, ", buf, maxlen);
DBG (DBG_MSG, "sane_read: buf=%p, maxlen=%d, ", (void *) buf, maxlen);
s = (TScanner *) h;

2
backend/pixma/pixma.c
Wyświetl plik

@ -899,7 +899,7 @@ print_scan_param (int level, const pixma_scan_param_t * sp)
pixma_dbg (level, " dpi=%ux%u offset=(%u,%u) dimension=%ux%u\n",
sp->xdpi, sp->ydpi, sp->x, sp->y, sp->w, sp->h);
pixma_dbg (level, " gamma=%f gamma_table=%p source=%d\n", sp->gamma,
sp->gamma_table, sp->source);
(void *) sp->gamma_table, sp->source);
pixma_dbg (level, " adf-wait=%d\n", sp->adf_wait);
}
#endif

2
backend/pixma/pixma_common.c
Wyświetl plik

@ -877,7 +877,7 @@ pixma_scan (pixma_t * s, pixma_scan_param_t * sp)
sp->line_size, sp->image_size, sp->channels, sp->depth);
pixma_dbg (3, " dpi=%ux%u offset=(%u,%u) dimension=%ux%u\n",
sp->xdpi, sp->ydpi, sp->x, sp->y, sp->w, sp->h);
pixma_dbg (3, " gamma=%f gamma_table=%p source=%d\n", sp->gamma, sp->gamma_table, sp->source);
pixma_dbg (3, " gamma=%f gamma_table=%p source=%d\n", sp->gamma, (void *) sp->gamma_table, sp->source);
pixma_dbg (3, " threshold=%d threshold_curve=%d\n", sp->threshold, sp->threshold_curve);
pixma_dbg (3, " adf-wait=%d\n", sp->adf_wait);
pixma_dbg (3, " ADF page count: %d\n", sp->adf_pageid);

2
backend/qcam.c
Wyświetl plik

@ -2119,7 +2119,7 @@ sane_read (SANE_Handle handle, SANE_Byte * buf, SANE_Int max_len,
len = s->bytes_per_frame - s->num_bytes;
DBG (8, "read(buf=%p,num_bytes=%ld,max_len=%d,len=%ld)\n",
buf, (long) s->num_bytes, max_len, (long) len);
(void *) buf, (long) s->num_bytes, max_len, (long) len);
nread = read (s->read_fd, buf, len);
if (nread <= 0)

9
backend/sm3840.c
Wyświetl plik

@ -145,11 +145,12 @@ sane_read (SANE_Handle handle, SANE_Byte * buf, SANE_Int max_len,
unsigned char c, d;
int i;
DBG (2, "+sane-read:%p %p %d %p\n", (unsigned char *) s, buf, max_len,
(unsigned char *) len);
DBG (2, "+sane-read:%p %p %d %p\n", (void *) s, (void *) buf, max_len,
(void *) len);
DBG (2,
"+sane-read:remain:%lu offset:%lu linesleft:%d linebuff:%p linesread:%d\n",
(u_long)s->remaining, (u_long)s->offset, s->linesleft, s->line_buffer, s->linesread);
(u_long) s->remaining, (u_long) s->offset, s->linesleft,
(void *) s->line_buffer, s->linesread);
if (!s->scanning)
return SANE_STATUS_INVAL;
@ -798,7 +799,7 @@ sane_open (SANE_String_Const devicename, SANE_Handle * handle)
/* empty devicename -> use first device */
dev = first_dev;
}
DBG (2, "using device: %s %p\n", dev->sane.name, (unsigned char *) dev);
DBG (2, "using device: %s %p\n", dev->sane.name, (void *) dev);
if (!dev)
return SANE_STATUS_INVAL;
s = calloc (sizeof (*s), 1);

8
backend/snapscan-options.c
Wyświetl plik

@ -1107,7 +1107,7 @@ SANE_Status sane_control_option (SANE_Handle h,
"%s: writing \"%s\" to location %p\n",
me,
pss->mode_s,
(SANE_String) v);
(void *) v);
strcpy ((SANE_String) v, pss->mode_s);
break;
case OPT_PREVIEW_MODE:
@ -1115,7 +1115,7 @@ SANE_Status sane_control_option (SANE_Handle h,
"%s: writing \"%s\" to location %p\n",
me,
pss->preview_mode_s,
(SANE_String) v);
(void *) v);
strcpy ((SANE_String) v, pss->preview_mode_s);
break;
case OPT_SOURCE:
@ -1144,7 +1144,7 @@ SANE_Status sane_control_option (SANE_Handle h,
"%s: writing \"%s\" to location %p\n",
me,
pss->predef_window,
(SANE_String) v);
(void *) v);
strcpy ((SANE_String) v, pss->predef_window);
break;
case OPT_GAMMA_GS:
@ -1179,7 +1179,7 @@ SANE_Status sane_control_option (SANE_Handle h,
"%s: writing \"%s\" to location %p\n",
me,
pss->dither_matrix,
(SANE_String) v);
(void *) v);
strcpy ((SANE_String) v, pss->dither_matrix);
break;
case OPT_NEGATIVE:

2
backend/st400.c
Wyświetl plik

@ -1221,7 +1221,7 @@ sane_read( SANE_Handle handle, SANE_Byte *buf, SANE_Int maxlen, SANE_Int *lenP )
size_t r, i;
SANE_Byte val;
DBG(DCODE, "sane_read(%p, %p, %d, %p)\n", handle, buf, (int)maxlen, (void *) lenP);
DBG(DCODE, "sane_read(%p, %p, %d, %p)\n", handle, (void *) buf, (int) maxlen, (void *) lenP);
*lenP = 0;
if( !dev->status.scanning )

4
backend/test.c
Wyświetl plik

@ -1450,7 +1450,7 @@ reader_process (Test_Device * test_device, SANE_Int fd)
return status;
DBG (2, "(child) reader_process: buffer=%p, buffersize=%lu\n",
buffer, (u_long) buffer_size);
(void *) buffer, (u_long) buffer_size);
while (byte_count < bytes_total)
{
@ -2877,7 +2877,7 @@ sane_read (SANE_Handle handle, SANE_Byte * data,
DBG (4, "sane_read: handle=%p, data=%p, max_length = %d, length=%p\n",
handle, data, max_length, (void *) length);
handle, (void *) data, max_length, (void *) length);
if (!inited)
{
DBG (1, "sane_read: not inited, call sane_init() first\n");

2
backend/v4l.c
Wyświetl plik

@ -1007,7 +1007,7 @@ sane_start (SANE_Handle handle)
buffer = NULL;
return SANE_STATUS_IO_ERROR;
}
DBG (3, "sane_start: mmapped frame, capture 1 pict into %p\n", buffer);
DBG (3, "sane_start: mmapped frame, capture 1 pict into %p\n", (void *) buffer);
s->mmap.frame = 0;
s->mmap.width = s->window.width;
/* s->mmap.width = parms.pixels_per_line; ??? huh? */

2
backend/xerox_mfp.c
Wyświetl plik

@ -1304,7 +1304,7 @@ sane_read(SANE_Handle h, SANE_Byte *buf, SANE_Int maxlen, SANE_Int *lenp)
SANE_Status status;
struct device *dev = h;
DBG(3, "%s: %p, %p, %d, %p\n", __func__, h, buf, maxlen, (void *)lenp);
DBG(3, "%s: %p, %p, %d, %p\n", __func__, h, (void *) buf, maxlen, (void *) lenp);
if (lenp)
*lenp = 0;

3
sanei/sanei_pv8630.c
Wyświetl plik

@ -87,7 +87,8 @@ sanei_pv8630_read_byte (int fd, SANEI_PV_Index index, SANE_Byte * byte)
{
SANE_Status status;
DBG(DBG_info, "sanei_pv8630_read_byte - index=%d, byte=%p\n", index, byte);
DBG(DBG_info, "sanei_pv8630_read_byte - index=%d, byte=%p\n",
index, (void *) byte);
status =
sanei_usb_control_msg (fd, 0xc0, PV8630_REQ_READBYTE, 0, index, 1, byte);