lib/warnless.c

   1 /***************************************************************************
   2  *                                  _   _ ____  _
   3  *  Project                     ___| | | |  _ \| |
   4  *                             / __| | | | |_) | |
   5  *                            | (__| |_| |  _ <| |___
   6  *                             \___|\___/|_| \_\_____|
   7  *
   8  * Copyright (C) 1998 - 2013, 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 http://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 (CURL_SIZEOF_LONG == 2)
  73 #  define CURL_MASK_SLONG  0x7FFFL
  74 #  define CURL_MASK_ULONG  0xFFFFUL
  75 #elif (CURL_SIZEOF_LONG == 4)
  76 #  define CURL_MASK_SLONG  0x7FFFFFFFL
  77 #  define CURL_MASK_ULONG  0xFFFFFFFFUL
  78 #elif (CURL_SIZEOF_LONG == 8)
  79 #  define CURL_MASK_SLONG  0x7FFFFFFFFFFFFFFFL
  80 #  define CURL_MASK_ULONG  0xFFFFFFFFFFFFFFFFUL
  81 #elif (CURL_SIZEOF_LONG == 16)
  82 #  define CURL_MASK_SLONG  0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFL
  83 #  define CURL_MASK_ULONG  0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFUL
  84 #else
  85 #  error "CURL_SIZEOF_LONG not defined"
  86 #endif
  87
  88 #if (CURL_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 (CURL_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 (CURL_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 (CURL_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 "CURL_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 == CURL_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 == CURL_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 int
 179 */
 180
 181 int curlx_uztosi(size_t uznum)
 182 {
 183 #ifdef __INTEL_COMPILER
 184 #  pragma warning(push)
 185 #  pragma warning(disable:810) /* conversion may lose significant bits */
 186 #endif
 187
 188   DEBUGASSERT(uznum <= (size_t) CURL_MASK_SINT);
 189   return (int)(uznum & (size_t) CURL_MASK_SINT);
 190
 191 #ifdef __INTEL_COMPILER
 192 #  pragma warning(pop)
 193 #endif
 194 }
 195
 196 /*
 197 ** unsigned size_t to unsigned long
 198 */
 199
 200 unsigned long curlx_uztoul(size_t uznum)
 201 {
 202 #ifdef __INTEL_COMPILER
 203 # pragma warning(push)
 204 # pragma warning(disable:810) /* conversion may lose significant bits */
 205 #endif
 206
 207 #if (CURL_SIZEOF_LONG < SIZEOF_SIZE_T)
 208   DEBUGASSERT(uznum <= (size_t) CURL_MASK_ULONG);
 209 #endif
 210   return (unsigned long)(uznum & (size_t) CURL_MASK_ULONG);
 211
 212 #ifdef __INTEL_COMPILER
 213 # pragma warning(pop)
 214 #endif
 215 }
 216
 217 /*
 218 ** unsigned size_t to unsigned int
 219 */
 220
 221 unsigned int curlx_uztoui(size_t uznum)
 222 {
 223 #ifdef __INTEL_COMPILER
 224 # pragma warning(push)
 225 # pragma warning(disable:810) /* conversion may lose significant bits */
 226 #endif
 227
 228 #if (SIZEOF_INT < SIZEOF_SIZE_T)
 229   DEBUGASSERT(uznum <= (size_t) CURL_MASK_UINT);
 230 #endif
 231   return (unsigned int)(uznum & (size_t) CURL_MASK_UINT);
 232
 233 #ifdef __INTEL_COMPILER
 234 # pragma warning(pop)
 235 #endif
 236 }
 237
 238 /*
 239 ** signed long to signed int
 240 */
 241
 242 int curlx_sltosi(long slnum)
 243 {
 244 #ifdef __INTEL_COMPILER
 245 #  pragma warning(push)
 246 #  pragma warning(disable:810) /* conversion may lose significant bits */
 247 #endif
 248
 249   DEBUGASSERT(slnum >= 0);
 250 #if (SIZEOF_INT < CURL_SIZEOF_LONG)
 251   DEBUGASSERT((unsigned long) slnum <= (unsigned long) CURL_MASK_SINT);
 252 #endif
 253   return (int)(slnum & (long) CURL_MASK_SINT);
 254
 255 #ifdef __INTEL_COMPILER
 256 #  pragma warning(pop)
 257 #endif
 258 }
 259
 260 /*
 261 ** signed long to unsigned int
 262 */
 263
 264 unsigned int curlx_sltoui(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 < CURL_SIZEOF_LONG)
 273   DEBUGASSERT((unsigned long) slnum <= (unsigned long) CURL_MASK_UINT);
 274 #endif
 275   return (unsigned int)(slnum & (long) CURL_MASK_UINT);
 276
 277 #ifdef __INTEL_COMPILER
 278 #  pragma warning(pop)
 279 #endif
 280 }
 281
 282 /*
 283 ** signed long to unsigned short
 284 */
 285
 286 unsigned short curlx_sltous(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   DEBUGASSERT((unsigned long) slnum <= (unsigned long) CURL_MASK_USHORT);
 295   return (unsigned short)(slnum & (long) CURL_MASK_USHORT);
 296
 297 #ifdef __INTEL_COMPILER
 298 #  pragma warning(pop)
 299 #endif
 300 }
 301
 302 /*
 303 ** unsigned size_t to signed ssize_t
 304 */
 305
 306 ssize_t curlx_uztosz(size_t uznum)
 307 {
 308 #ifdef __INTEL_COMPILER
 309 #  pragma warning(push)
 310 #  pragma warning(disable:810) /* conversion may lose significant bits */
 311 #endif
 312
 313   DEBUGASSERT(uznum <= (size_t) CURL_MASK_SSIZE_T);
 314   return (ssize_t)(uznum & (size_t) CURL_MASK_SSIZE_T);
 315
 316 #ifdef __INTEL_COMPILER
 317 #  pragma warning(pop)
 318 #endif
 319 }
 320
 321 /*
 322 ** signed curl_off_t to unsigned size_t
 323 */
 324
 325 size_t curlx_sotouz(curl_off_t sonum)
 326 {
 327 #ifdef __INTEL_COMPILER
 328 #  pragma warning(push)
 329 #  pragma warning(disable:810) /* conversion may lose significant bits */
 330 #endif
 331
 332   DEBUGASSERT(sonum >= 0);
 333   return (size_t)(sonum & (curl_off_t) CURL_MASK_USIZE_T);
 334
 335 #ifdef __INTEL_COMPILER
 336 #  pragma warning(pop)
 337 #endif
 338 }
 339
 340 /*
 341 ** signed ssize_t to signed int
 342 */
 343
 344 int curlx_sztosi(ssize_t sznum)
 345 {
 346 #ifdef __INTEL_COMPILER
 347 #  pragma warning(push)
 348 #  pragma warning(disable:810) /* conversion may lose significant bits */
 349 #endif
 350
 351   DEBUGASSERT(sznum >= 0);
 352 #if (SIZEOF_INT < SIZEOF_SIZE_T)
 353   DEBUGASSERT((size_t) sznum <= (size_t) CURL_MASK_SINT);
 354 #endif
 355   return (int)(sznum & (ssize_t) CURL_MASK_SINT);
 356
 357 #ifdef __INTEL_COMPILER
 358 #  pragma warning(pop)
 359 #endif
 360 }
 361
 362 /*
 363 ** signed int to unsigned size_t
 364 */
 365
 366 size_t curlx_sitouz(int sinum)
 367 {
 368 #ifdef __INTEL_COMPILER
 369 #  pragma warning(push)
 370 #  pragma warning(disable:810) /* conversion may lose significant bits */
 371 #endif
 372
 373   DEBUGASSERT(sinum >= 0);
 374   return (size_t) sinum;
 375
 376 #ifdef __INTEL_COMPILER
 377 #  pragma warning(pop)
 378 #endif
 379 }
 380
 381 #ifdef USE_WINSOCK
 382
 383 /*
 384 ** curl_socket_t to signed int
 385 */
 386
 387 int curlx_sktosi(curl_socket_t s)
 388 {
 389   return (int)((ssize_t) s);
 390 }
 391
 392 /*
 393 ** signed int to curl_socket_t
 394 */
 395
 396 curl_socket_t curlx_sitosk(int i)
 397 {
 398   return (curl_socket_t)((ssize_t) i);
 399 }
 400
 401 #endif /* USE_WINSOCK */
 402
 403 #if defined(__INTEL_COMPILER) && defined(__unix__)
 404
 405 int curlx_FD_ISSET(int fd, fd_set *fdset)
 406 {
 407   #pragma warning(push)
 408   #pragma warning(disable:1469) /* clobber ignored */
 409   return FD_ISSET(fd, fdset);
 410   #pragma warning(pop)
 411 }
 412
 413 void curlx_FD_SET(int fd, fd_set *fdset)
 414 {
 415   #pragma warning(push)
 416   #pragma warning(disable:1469) /* clobber ignored */
 417   FD_SET(fd, fdset);
 418   #pragma warning(pop)
 419 }
 420
 421 void curlx_FD_ZERO(fd_set *fdset)
 422 {
 423   #pragma warning(push)
 424   #pragma warning(disable:593) /* variable was set but never used */
 425   FD_ZERO(fdset);
 426   #pragma warning(pop)
 427 }
 428
 429 unsigned short curlx_htons(unsigned short usnum)
 430 {
 431 #if (__INTEL_COMPILER == 910) && defined(__i386__)
 432   return (unsigned short)(((usnum << 8) & 0xFF00) | ((usnum >> 8) & 0x00FF));
 433 #else
 434   #pragma warning(push)
 435   #pragma warning(disable:810) /* conversion may lose significant bits */
 436   return htons(usnum);
 437   #pragma warning(pop)
 438 #endif
 439 }
 440
 441 unsigned short curlx_ntohs(unsigned short usnum)
 442 {
 443 #if (__INTEL_COMPILER == 910) && defined(__i386__)
 444   return (unsigned short)(((usnum << 8) & 0xFF00) | ((usnum >> 8) & 0x00FF));
 445 #else
 446   #pragma warning(push)
 447   #pragma warning(disable:810) /* conversion may lose significant bits */
 448   return ntohs(usnum);
 449   #pragma warning(pop)
 450 #endif
 451 }
 452
 453 #endif /* __INTEL_COMPILER && __unix__ */