Mercurial > hgrepos > Python2 > PyMuPDF

comparison mupdf-source/thirdparty/curl/lib/warnless.c @ 2:b50eed0cc0ef upstream

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
ADD: MuPDF v1.26.7: the MuPDF source as downloaded by a default build of PyMuPDF 1.26.4. The directory name has changed: no version number in the expanded directory now.
author Franz Glasner <fzglas.hg@dom66.de>
date Mon, 15 Sep 2025 11:43:07 +0200
parents
children
comparison
equal deleted inserted replaced
1:1d09e1dec1d9 2:b50eed0cc0ef
1 /***************************************************************************
2 * _ _ ____ _
3 * Project ___| | | | _ \| |
4 * / __| | | | |_) | |
5 * | (__| |_| | _ <| |___
6 * \___|\___/|_| \_\_____|
7 *
8 * Copyright (C) 1998 - 2019, 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 ** signed int to unsigned size_t
405 */
406
407 size_t curlx_sitouz(int sinum)
408 {
409 #ifdef __INTEL_COMPILER
410 # pragma warning(push)
411 # pragma warning(disable:810) /* conversion may lose significant bits */
412 #endif
413
414 DEBUGASSERT(sinum >= 0);
415 return (size_t) sinum;
416
417 #ifdef __INTEL_COMPILER
418 # pragma warning(pop)
419 #endif
420 }
421
422 #ifdef USE_WINSOCK
423
424 /*
425 ** curl_socket_t to signed int
426 */
427
428 int curlx_sktosi(curl_socket_t s)
429 {
430 return (int)((ssize_t) s);
431 }
432
433 /*
434 ** signed int to curl_socket_t
435 */
436
437 curl_socket_t curlx_sitosk(int i)
438 {
439 return (curl_socket_t)((ssize_t) i);
440 }
441
442 #endif /* USE_WINSOCK */
443
444 #if defined(WIN32) || defined(_WIN32)
445
446 ssize_t curlx_read(int fd, void *buf, size_t count)
447 {
448 return (ssize_t)read(fd, buf, curlx_uztoui(count));
449 }
450
451 ssize_t curlx_write(int fd, const void *buf, size_t count)
452 {
453 return (ssize_t)write(fd, buf, curlx_uztoui(count));
454 }
455
456 #endif /* WIN32 || _WIN32 */
457
458 #if defined(__INTEL_COMPILER) && defined(__unix__)
459
460 int curlx_FD_ISSET(int fd, fd_set *fdset)
461 {
462 #pragma warning(push)
463 #pragma warning(disable:1469) /* clobber ignored */
464 return FD_ISSET(fd, fdset);
465 #pragma warning(pop)
466 }
467
468 void curlx_FD_SET(int fd, fd_set *fdset)
469 {
470 #pragma warning(push)
471 #pragma warning(disable:1469) /* clobber ignored */
472 FD_SET(fd, fdset);
473 #pragma warning(pop)
474 }
475
476 void curlx_FD_ZERO(fd_set *fdset)
477 {
478 #pragma warning(push)
479 #pragma warning(disable:593) /* variable was set but never used */
480 FD_ZERO(fdset);
481 #pragma warning(pop)
482 }
483
484 unsigned short curlx_htons(unsigned short usnum)
485 {
486 #if (__INTEL_COMPILER == 910) && defined(__i386__)
487 return (unsigned short)(((usnum << 8) & 0xFF00) | ((usnum >> 8) & 0x00FF));
488 #else
489 #pragma warning(push)
490 #pragma warning(disable:810) /* conversion may lose significant bits */
491 return htons(usnum);
492 #pragma warning(pop)
493 #endif
494 }
495
496 unsigned short curlx_ntohs(unsigned short usnum)
497 {
498 #if (__INTEL_COMPILER == 910) && defined(__i386__)
499 return (unsigned short)(((usnum << 8) & 0xFF00) | ((usnum >> 8) & 0x00FF));
500 #else
501 #pragma warning(push)
502 #pragma warning(disable:810) /* conversion may lose significant bits */
503 return ntohs(usnum);
504 #pragma warning(pop)
505 #endif
506 }
507
508 #endif /* __INTEL_COMPILER && __unix__ */