Annotation of embedaddon/curl/lib/warnless.c, revision 1.1.1.1
1.1 misho 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__ */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to warnless.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / curl / lib