warnless.c
Go to the documentation of this file.
1 /***************************************************************************
2  * _ _ ____ _
3  * Project ___| | | | _ \| |
4  * / __| | | | |_) | |
5  * | (__| |_| | _ <| |___
6  * \___|\___/|_| \_\_____|
7  *
8  * Copyright (C) 1998 - 2017, Daniel Stenberg, <daniel@haxx.se>, et al.
9  *
10  * This software is licensed as described in the file COPYING, which
11  * you should have received as part of this distribution. The terms
12  * are also available at https://curl.haxx.se/docs/copyright.html.
13  *
14  * You may opt to use, copy, modify, merge, publish, distribute and/or sell
15  * copies of the Software, and permit persons to whom the Software is
16  * furnished to do so, under the terms of the COPYING file.
17  *
18  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
19  * KIND, either express or implied.
20  *
21  ***************************************************************************/
22 
23 #include "curl_setup.h"
24 
25 #if defined(__INTEL_COMPILER) && defined(__unix__)
26 
27 #ifdef HAVE_NETINET_IN_H
28 # include <netinet/in.h>
29 #endif
30 #ifdef HAVE_ARPA_INET_H
31 # include <arpa/inet.h>
32 #endif
33 
34 #endif /* __INTEL_COMPILER && __unix__ */
35 
36 #define BUILDING_WARNLESS_C 1
37 
38 #include "warnless.h"
39 
40 #define CURL_MASK_SCHAR 0x7F
41 #define CURL_MASK_UCHAR 0xFF
42 
43 #if (SIZEOF_SHORT == 2)
44 # define CURL_MASK_SSHORT 0x7FFF
45 # define CURL_MASK_USHORT 0xFFFF
46 #elif (SIZEOF_SHORT == 4)
47 # define CURL_MASK_SSHORT 0x7FFFFFFF
48 # define CURL_MASK_USHORT 0xFFFFFFFF
49 #elif (SIZEOF_SHORT == 8)
50 # define CURL_MASK_SSHORT 0x7FFFFFFFFFFFFFFF
51 # define CURL_MASK_USHORT 0xFFFFFFFFFFFFFFFF
52 #else
53 # error "SIZEOF_SHORT not defined"
54 #endif
55 
56 #if (SIZEOF_INT == 2)
57 # define CURL_MASK_SINT 0x7FFF
58 # define CURL_MASK_UINT 0xFFFF
59 #elif (SIZEOF_INT == 4)
60 # define CURL_MASK_SINT 0x7FFFFFFF
61 # define CURL_MASK_UINT 0xFFFFFFFF
62 #elif (SIZEOF_INT == 8)
63 # define CURL_MASK_SINT 0x7FFFFFFFFFFFFFFF
64 # define CURL_MASK_UINT 0xFFFFFFFFFFFFFFFF
65 #elif (SIZEOF_INT == 16)
66 # define CURL_MASK_SINT 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
67 # define CURL_MASK_UINT 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
68 #else
69 # error "SIZEOF_INT not defined"
70 #endif
71 
72 #if (SIZEOF_LONG == 2)
73 # define CURL_MASK_SLONG 0x7FFFL
74 # define CURL_MASK_ULONG 0xFFFFUL
75 #elif (SIZEOF_LONG == 4)
76 # define CURL_MASK_SLONG 0x7FFFFFFFL
77 # define CURL_MASK_ULONG 0xFFFFFFFFUL
78 #elif (SIZEOF_LONG == 8)
79 # define CURL_MASK_SLONG 0x7FFFFFFFFFFFFFFFL
80 # define CURL_MASK_ULONG 0xFFFFFFFFFFFFFFFFUL
81 #elif (SIZEOF_LONG == 16)
82 # define CURL_MASK_SLONG 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFL
83 # define CURL_MASK_ULONG 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFUL
84 #else
85 # error "SIZEOF_LONG not defined"
86 #endif
87 
88 #if (SIZEOF_CURL_OFF_T == 2)
89 # define CURL_MASK_SCOFFT CURL_OFF_T_C(0x7FFF)
90 # define CURL_MASK_UCOFFT CURL_OFF_TU_C(0xFFFF)
91 #elif (SIZEOF_CURL_OFF_T == 4)
92 # define CURL_MASK_SCOFFT CURL_OFF_T_C(0x7FFFFFFF)
93 # define CURL_MASK_UCOFFT CURL_OFF_TU_C(0xFFFFFFFF)
94 #elif (SIZEOF_CURL_OFF_T == 8)
95 # define CURL_MASK_SCOFFT CURL_OFF_T_C(0x7FFFFFFFFFFFFFFF)
96 # define CURL_MASK_UCOFFT CURL_OFF_TU_C(0xFFFFFFFFFFFFFFFF)
97 #elif (SIZEOF_CURL_OFF_T == 16)
98 # define CURL_MASK_SCOFFT CURL_OFF_T_C(0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)
99 # define CURL_MASK_UCOFFT CURL_OFF_TU_C(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)
100 #else
101 # error "SIZEOF_CURL_OFF_T not defined"
102 #endif
103 
104 #if (SIZEOF_SIZE_T == SIZEOF_SHORT)
105 # define CURL_MASK_SSIZE_T CURL_MASK_SSHORT
106 # define CURL_MASK_USIZE_T CURL_MASK_USHORT
107 #elif (SIZEOF_SIZE_T == SIZEOF_INT)
108 # define CURL_MASK_SSIZE_T CURL_MASK_SINT
109 # define CURL_MASK_USIZE_T CURL_MASK_UINT
110 #elif (SIZEOF_SIZE_T == SIZEOF_LONG)
111 # define CURL_MASK_SSIZE_T CURL_MASK_SLONG
112 # define CURL_MASK_USIZE_T CURL_MASK_ULONG
113 #elif (SIZEOF_SIZE_T == SIZEOF_CURL_OFF_T)
114 # define CURL_MASK_SSIZE_T CURL_MASK_SCOFFT
115 # define CURL_MASK_USIZE_T CURL_MASK_UCOFFT
116 #else
117 # error "SIZEOF_SIZE_T not defined"
118 #endif
119 
120 /*
121 ** unsigned long to unsigned short
122 */
123 
124 unsigned short curlx_ultous(unsigned long ulnum)
125 {
126 #ifdef __INTEL_COMPILER
127 # pragma warning(push)
128 # pragma warning(disable:810) /* conversion may lose significant bits */
129 #endif
130 
131  DEBUGASSERT(ulnum <= (unsigned long) CURL_MASK_USHORT);
132  return (unsigned short)(ulnum & (unsigned long) CURL_MASK_USHORT);
133 
134 #ifdef __INTEL_COMPILER
135 # pragma warning(pop)
136 #endif
137 }
138 
139 /*
140 ** unsigned long to unsigned char
141 */
142 
143 unsigned char curlx_ultouc(unsigned long ulnum)
144 {
145 #ifdef __INTEL_COMPILER
146 # pragma warning(push)
147 # pragma warning(disable:810) /* conversion may lose significant bits */
148 #endif
149 
150  DEBUGASSERT(ulnum <= (unsigned long) CURL_MASK_UCHAR);
151  return (unsigned char)(ulnum & (unsigned long) CURL_MASK_UCHAR);
152 
153 #ifdef __INTEL_COMPILER
154 # pragma warning(pop)
155 #endif
156 }
157 
158 /*
159 ** unsigned long to signed int
160 */
161 
162 int curlx_ultosi(unsigned long ulnum)
163 {
164 #ifdef __INTEL_COMPILER
165 # pragma warning(push)
166 # pragma warning(disable:810) /* conversion may lose significant bits */
167 #endif
168 
169  DEBUGASSERT(ulnum <= (unsigned long) CURL_MASK_SINT);
170  return (int)(ulnum & (unsigned long) CURL_MASK_SINT);
171 
172 #ifdef __INTEL_COMPILER
173 # pragma warning(pop)
174 #endif
175 }
176 
177 /*
178 ** unsigned size_t to signed curl_off_t
179 */
180 
181 curl_off_t curlx_uztoso(size_t uznum)
182 {
183 #ifdef __INTEL_COMPILER
184 # pragma warning(push)
185 # pragma warning(disable:810) /* conversion may lose significant bits */
186 #elif defined(_MSC_VER)
187 # pragma warning(push)
188 # pragma warning(disable:4310) /* cast truncates constant value */
189 #endif
190 
191  DEBUGASSERT(uznum <= (size_t) CURL_MASK_SCOFFT);
192  return (curl_off_t)(uznum & (size_t) CURL_MASK_SCOFFT);
193 
194 #if defined(__INTEL_COMPILER) || defined(_MSC_VER)
195 # pragma warning(pop)
196 #endif
197 }
198 
199 /*
200 ** unsigned size_t to signed int
201 */
202 
203 int curlx_uztosi(size_t uznum)
204 {
205 #ifdef __INTEL_COMPILER
206 # pragma warning(push)
207 # pragma warning(disable:810) /* conversion may lose significant bits */
208 #endif
209 
210  DEBUGASSERT(uznum <= (size_t) CURL_MASK_SINT);
211  return (int)(uznum & (size_t) CURL_MASK_SINT);
212 
213 #ifdef __INTEL_COMPILER
214 # pragma warning(pop)
215 #endif
216 }
217 
218 /*
219 ** unsigned size_t to unsigned long
220 */
221 
222 unsigned long curlx_uztoul(size_t uznum)
223 {
224 #ifdef __INTEL_COMPILER
225 # pragma warning(push)
226 # pragma warning(disable:810) /* conversion may lose significant bits */
227 #endif
228 
229 #if (SIZEOF_LONG < SIZEOF_SIZE_T)
230  DEBUGASSERT(uznum <= (size_t) CURL_MASK_ULONG);
231 #endif
232  return (unsigned long)(uznum & (size_t) CURL_MASK_ULONG);
233 
234 #ifdef __INTEL_COMPILER
235 # pragma warning(pop)
236 #endif
237 }
238 
239 /*
240 ** unsigned size_t to unsigned int
241 */
242 
243 unsigned int curlx_uztoui(size_t uznum)
244 {
245 #ifdef __INTEL_COMPILER
246 # pragma warning(push)
247 # pragma warning(disable:810) /* conversion may lose significant bits */
248 #endif
249 
250 #if (SIZEOF_INT < SIZEOF_SIZE_T)
251  DEBUGASSERT(uznum <= (size_t) CURL_MASK_UINT);
252 #endif
253  return (unsigned int)(uznum & (size_t) CURL_MASK_UINT);
254 
255 #ifdef __INTEL_COMPILER
256 # pragma warning(pop)
257 #endif
258 }
259 
260 /*
261 ** signed long to signed int
262 */
263 
264 int curlx_sltosi(long slnum)
265 {
266 #ifdef __INTEL_COMPILER
267 # pragma warning(push)
268 # pragma warning(disable:810) /* conversion may lose significant bits */
269 #endif
270 
271  DEBUGASSERT(slnum >= 0);
272 #if (SIZEOF_INT < SIZEOF_LONG)
273  DEBUGASSERT((unsigned long) slnum <= (unsigned long) CURL_MASK_SINT);
274 #endif
275  return (int)(slnum & (long) CURL_MASK_SINT);
276 
277 #ifdef __INTEL_COMPILER
278 # pragma warning(pop)
279 #endif
280 }
281 
282 /*
283 ** signed long to unsigned int
284 */
285 
286 unsigned int curlx_sltoui(long slnum)
287 {
288 #ifdef __INTEL_COMPILER
289 # pragma warning(push)
290 # pragma warning(disable:810) /* conversion may lose significant bits */
291 #endif
292 
293  DEBUGASSERT(slnum >= 0);
294 #if (SIZEOF_INT < SIZEOF_LONG)
295  DEBUGASSERT((unsigned long) slnum <= (unsigned long) CURL_MASK_UINT);
296 #endif
297  return (unsigned int)(slnum & (long) CURL_MASK_UINT);
298 
299 #ifdef __INTEL_COMPILER
300 # pragma warning(pop)
301 #endif
302 }
303 
304 /*
305 ** signed long to unsigned short
306 */
307 
308 unsigned short curlx_sltous(long slnum)
309 {
310 #ifdef __INTEL_COMPILER
311 # pragma warning(push)
312 # pragma warning(disable:810) /* conversion may lose significant bits */
313 #endif
314 
315  DEBUGASSERT(slnum >= 0);
316  DEBUGASSERT((unsigned long) slnum <= (unsigned long) CURL_MASK_USHORT);
317  return (unsigned short)(slnum & (long) CURL_MASK_USHORT);
318 
319 #ifdef __INTEL_COMPILER
320 # pragma warning(pop)
321 #endif
322 }
323 
324 /*
325 ** unsigned size_t to signed ssize_t
326 */
327 
328 ssize_t curlx_uztosz(size_t uznum)
329 {
330 #ifdef __INTEL_COMPILER
331 # pragma warning(push)
332 # pragma warning(disable:810) /* conversion may lose significant bits */
333 #endif
334 
335  DEBUGASSERT(uznum <= (size_t) CURL_MASK_SSIZE_T);
336  return (ssize_t)(uznum & (size_t) CURL_MASK_SSIZE_T);
337 
338 #ifdef __INTEL_COMPILER
339 # pragma warning(pop)
340 #endif
341 }
342 
343 /*
344 ** signed curl_off_t to unsigned size_t
345 */
346 
347 size_t curlx_sotouz(curl_off_t sonum)
348 {
349 #ifdef __INTEL_COMPILER
350 # pragma warning(push)
351 # pragma warning(disable:810) /* conversion may lose significant bits */
352 #endif
353 
354  DEBUGASSERT(sonum >= 0);
355  return (size_t)(sonum & (curl_off_t) CURL_MASK_USIZE_T);
356 
357 #ifdef __INTEL_COMPILER
358 # pragma warning(pop)
359 #endif
360 }
361 
362 /*
363 ** signed ssize_t to signed int
364 */
365 
366 int curlx_sztosi(ssize_t sznum)
367 {
368 #ifdef __INTEL_COMPILER
369 # pragma warning(push)
370 # pragma warning(disable:810) /* conversion may lose significant bits */
371 #endif
372 
373  DEBUGASSERT(sznum >= 0);
374 #if (SIZEOF_INT < SIZEOF_SIZE_T)
375  DEBUGASSERT((size_t) sznum <= (size_t) CURL_MASK_SINT);
376 #endif
377  return (int)(sznum & (ssize_t) CURL_MASK_SINT);
378 
379 #ifdef __INTEL_COMPILER
380 # pragma warning(pop)
381 #endif
382 }
383 
384 /*
385 ** unsigned int to unsigned short
386 */
387 
388 unsigned short curlx_uitous(unsigned int uinum)
389 {
390 #ifdef __INTEL_COMPILER
391 # pragma warning(push)
392 # pragma warning(disable:810) /* conversion may lose significant bits */
393 #endif
394 
395  DEBUGASSERT(uinum <= (unsigned int) CURL_MASK_USHORT);
396  return (unsigned short) (uinum & (unsigned int) CURL_MASK_USHORT);
397 
398 #ifdef __INTEL_COMPILER
399 # pragma warning(pop)
400 #endif
401 }
402 
403 /*
404 ** unsigned int to unsigned char
405 */
406 
407 unsigned char curlx_uitouc(unsigned int uinum)
408 {
409 #ifdef __INTEL_COMPILER
410 # pragma warning(push)
411 # pragma warning(disable:810) /* conversion may lose significant bits */
412 #endif
413 
414  DEBUGASSERT(uinum <= (unsigned int) CURL_MASK_UCHAR);
415  return (unsigned char) (uinum & (unsigned int) CURL_MASK_UCHAR);
416 
417 #ifdef __INTEL_COMPILER
418 # pragma warning(pop)
419 #endif
420 }
421 
422 /*
423 ** unsigned int to signed int
424 */
425 
426 int curlx_uitosi(unsigned int uinum)
427 {
428 #ifdef __INTEL_COMPILER
429 # pragma warning(push)
430 # pragma warning(disable:810) /* conversion may lose significant bits */
431 #endif
432 
433  DEBUGASSERT(uinum <= (unsigned int) CURL_MASK_SINT);
434  return (int) (uinum & (unsigned int) CURL_MASK_SINT);
435 
436 #ifdef __INTEL_COMPILER
437 # pragma warning(pop)
438 #endif
439 }
440 
441 /*
442 ** signed int to unsigned size_t
443 */
444 
445 size_t curlx_sitouz(int sinum)
446 {
447 #ifdef __INTEL_COMPILER
448 # pragma warning(push)
449 # pragma warning(disable:810) /* conversion may lose significant bits */
450 #endif
451 
452  DEBUGASSERT(sinum >= 0);
453  return (size_t) sinum;
454 
455 #ifdef __INTEL_COMPILER
456 # pragma warning(pop)
457 #endif
458 }
459 
460 #ifdef USE_WINSOCK
461 
462 /*
463 ** curl_socket_t to signed int
464 */
465 
466 int curlx_sktosi(curl_socket_t s)
467 {
468  return (int)((ssize_t) s);
469 }
470 
471 /*
472 ** signed int to curl_socket_t
473 */
474 
475 curl_socket_t curlx_sitosk(int i)
476 {
477  return (curl_socket_t)((ssize_t) i);
478 }
479 
480 #endif /* USE_WINSOCK */
481 
482 #if defined(WIN32) || defined(_WIN32)
483 
484 ssize_t curlx_read(int fd, void *buf, size_t count)
485 {
486  return (ssize_t)read(fd, buf, curlx_uztoui(count));
487 }
488 
489 ssize_t curlx_write(int fd, const void *buf, size_t count)
490 {
491  return (ssize_t)write(fd, buf, curlx_uztoui(count));
492 }
493 
494 #endif /* WIN32 || _WIN32 */
495 
496 #if defined(__INTEL_COMPILER) && defined(__unix__)
497 
498 int curlx_FD_ISSET(int fd, fd_set *fdset)
499 {
500  #pragma warning(push)
501  #pragma warning(disable:1469) /* clobber ignored */
502  return FD_ISSET(fd, fdset);
503  #pragma warning(pop)
504 }
505 
506 void curlx_FD_SET(int fd, fd_set *fdset)
507 {
508  #pragma warning(push)
509  #pragma warning(disable:1469) /* clobber ignored */
510  FD_SET(fd, fdset);
511  #pragma warning(pop)
512 }
513 
514 void curlx_FD_ZERO(fd_set *fdset)
515 {
516  #pragma warning(push)
517  #pragma warning(disable:593) /* variable was set but never used */
518  FD_ZERO(fdset);
519  #pragma warning(pop)
520 }
521 
522 unsigned short curlx_htons(unsigned short usnum)
523 {
524 #if (__INTEL_COMPILER == 910) && defined(__i386__)
525  return (unsigned short)(((usnum << 8) & 0xFF00) | ((usnum >> 8) & 0x00FF));
526 #else
527  #pragma warning(push)
528  #pragma warning(disable:810) /* conversion may lose significant bits */
529  return htons(usnum);
530  #pragma warning(pop)
531 #endif
532 }
533 
534 unsigned short curlx_ntohs(unsigned short usnum)
535 {
536 #if (__INTEL_COMPILER == 910) && defined(__i386__)
537  return (unsigned short)(((usnum << 8) & 0xFF00) | ((usnum >> 8) & 0x00FF));
538 #else
539  #pragma warning(push)
540  #pragma warning(disable:810) /* conversion may lose significant bits */
541  return ntohs(usnum);
542  #pragma warning(pop)
543 #endif
544 }
545 
546 #endif /* __INTEL_COMPILER && __unix__ */
CURL_MASK_SSIZE_T
#define CURL_MASK_SSIZE_T
Definition: warnless.c:105
curlx_sltosi
int curlx_sltosi(long slnum)
Definition: warnless.c:264
curlx_sitouz
size_t curlx_sitouz(int sinum)
Definition: warnless.c:445
curlx_ultouc
unsigned char curlx_ultouc(unsigned long ulnum)
Definition: warnless.c:143
s
XmlRpcServer s
DEBUGASSERT
#define DEBUGASSERT(x)
Definition: curl_setup_once.h:420
curlx_uitosi
int curlx_uitosi(unsigned int uinum)
Definition: warnless.c:426
curlx_uztosi
int curlx_uztosi(size_t uznum)
Definition: warnless.c:203
curlx_uztosz
ssize_t curlx_uztosz(size_t uznum)
Definition: warnless.c:328
i
unsigned int i
Definition: unit1303.c:79
curlx_ultous
unsigned short curlx_ultous(unsigned long ulnum)
Definition: warnless.c:124
curlx_ultosi
int curlx_ultosi(unsigned long ulnum)
Definition: warnless.c:162
curlx_sltous
unsigned short curlx_sltous(long slnum)
Definition: warnless.c:308
curlx_uitouc
unsigned char curlx_uitouc(unsigned int uinum)
Definition: warnless.c:407
curlx_uztoso
curl_off_t curlx_uztoso(size_t uznum)
Definition: warnless.c:181
curlx_uztoul
unsigned long curlx_uztoul(size_t uznum)
Definition: warnless.c:222
CURL_MASK_UCHAR
#define CURL_MASK_UCHAR
Definition: warnless.c:41
size_t
curl_easy_setopt expects a curl_off_t argument for this option curl_easy_setopt expects a curl_write_callback argument for this option curl_easy_setopt expects a curl_ioctl_callback argument for this option curl_easy_setopt expects a curl_opensocket_callback argument for this option curl_easy_setopt expects a curl_debug_callback argument for this option curl_easy_setopt expects a curl_conv_callback argument for this option curl_easy_setopt expects a private data pointer as argument for this option curl_easy_setopt expects a FILE *argument for this option curl_easy_setopt expects a struct curl_httppost *argument for this option curl_easy_setopt expects a struct curl_slist *argument for this option curl_easy_getinfo expects a pointer to char *for this info curl_easy_getinfo expects a pointer to double for this info curl_easy_getinfo expects a pointer to struct curl_tlssessioninfo *for this info curl_easy_getinfo expects a pointer to curl_socket_t for this info size_t
Definition: typecheck-gcc.h:518
curl_off_t
CURL_TYPEOF_CURL_OFF_T curl_off_t
Definition: system.h:420
curlx_uztoui
unsigned int curlx_uztoui(size_t uznum)
Definition: warnless.c:243
curl_setup.h
curlx_uitous
unsigned short curlx_uitous(unsigned int uinum)
Definition: warnless.c:388
ssize_t
#define ssize_t
Definition: config-win32.h:382
curlx_sztosi
int curlx_sztosi(ssize_t sznum)
Definition: warnless.c:366
buf
char buf[3]
Definition: unit1398.c:32
curlx_sltoui
unsigned int curlx_sltoui(long slnum)
Definition: warnless.c:286
curlx_sotouz
size_t curlx_sotouz(curl_off_t sonum)
Definition: warnless.c:347
curl_socket_t
int curl_socket_t
Definition: curl.h:130
CURL_MASK_USIZE_T
#define CURL_MASK_USIZE_T
Definition: warnless.c:106

rc_tagdetect_client
Author(s): Monika Florek-Jasinska , Raphael Schaller
autogenerated on Sat Feb 13 2021 03:42:17