1 #ifndef CURLINC_SYSTEM_H 2 #define CURLINC_SYSTEM_H 3 /*************************************************************************** 4 * _ _ ____ _ 5 * Project ___| | | | _ \| | 6 * / __| | | | |_) | | 7 * | (__| |_| | _ <| |___ 8 * \___|\___/|_| \_\_____| 9 * 10 * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al. 11 * 12 * This software is licensed as described in the file COPYING, which 13 * you should have received as part of this distribution. The terms 14 * are also available at https://curl.se/docs/copyright.html. 15 * 16 * You may opt to use, copy, modify, merge, publish, distribute and/or sell 17 * copies of the Software, and permit persons to whom the Software is 18 * furnished to do so, under the terms of the COPYING file. 19 * 20 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY 21 * KIND, either express or implied. 22 * 23 * SPDX-License-Identifier: curl 24 * 25 ***************************************************************************/ 26 27 /* 28 * Try to keep one section per platform, compiler and architecture, otherwise, 29 * if an existing section is reused for a different one and later on the 30 * original is adjusted, probably the piggybacking one can be adversely 31 * changed. 32 * 33 * In order to differentiate between platforms/compilers/architectures use 34 * only compiler built in predefined preprocessor symbols. 35 * 36 * curl_off_t 37 * ---------- 38 * 39 * For any given platform/compiler curl_off_t must be typedef'ed to a 64-bit 40 * wide signed integral data type. The width of this data type must remain 41 * constant and independent of any possible large file support settings. 42 * 43 * As an exception to the above, curl_off_t shall be typedef'ed to a 32-bit 44 * wide signed integral data type if there is no 64-bit type. 45 * 46 * As a general rule, curl_off_t shall not be mapped to off_t. This rule shall 47 * only be violated if off_t is the only 64-bit data type available and the 48 * size of off_t is independent of large file support settings. Keep your 49 * build on the safe side avoiding an off_t gating. If you have a 64-bit 50 * off_t then take for sure that another 64-bit data type exists, dig deeper 51 * and you will find it. 52 * 53 */ 54 55 #if defined(__DJGPP__) || defined(__GO32__) 56 # if defined(__DJGPP__) && (__DJGPP__ > 1) 57 # define CURL_TYPEOF_CURL_OFF_T long long 58 # define CURL_FORMAT_CURL_OFF_T "lld" 59 # define CURL_FORMAT_CURL_OFF_TU "llu" 60 # define CURL_SUFFIX_CURL_OFF_T LL 61 # define CURL_SUFFIX_CURL_OFF_TU ULL 62 # else 63 # define CURL_TYPEOF_CURL_OFF_T long 64 # define CURL_FORMAT_CURL_OFF_T "ld" 65 # define CURL_FORMAT_CURL_OFF_TU "lu" 66 # define CURL_SUFFIX_CURL_OFF_T L 67 # define CURL_SUFFIX_CURL_OFF_TU UL 68 # endif 69 # define CURL_TYPEOF_CURL_SOCKLEN_T int 70 71 #elif defined(__SALFORDC__) 72 # define CURL_TYPEOF_CURL_OFF_T long 73 # define CURL_FORMAT_CURL_OFF_T "ld" 74 # define CURL_FORMAT_CURL_OFF_TU "lu" 75 # define CURL_SUFFIX_CURL_OFF_T L 76 # define CURL_SUFFIX_CURL_OFF_TU UL 77 # define CURL_TYPEOF_CURL_SOCKLEN_T int 78 79 #elif defined(__BORLANDC__) 80 # if (__BORLANDC__ < 0x520) 81 # define CURL_TYPEOF_CURL_OFF_T long 82 # define CURL_FORMAT_CURL_OFF_T "ld" 83 # define CURL_FORMAT_CURL_OFF_TU "lu" 84 # define CURL_SUFFIX_CURL_OFF_T L 85 # define CURL_SUFFIX_CURL_OFF_TU UL 86 # else 87 # define CURL_TYPEOF_CURL_OFF_T __int64 88 # define CURL_FORMAT_CURL_OFF_T "I64d" 89 # define CURL_FORMAT_CURL_OFF_TU "I64u" 90 # define CURL_SUFFIX_CURL_OFF_T i64 91 # define CURL_SUFFIX_CURL_OFF_TU ui64 92 # endif 93 # define CURL_TYPEOF_CURL_SOCKLEN_T int 94 95 #elif defined(__TURBOC__) 96 # define CURL_TYPEOF_CURL_OFF_T long 97 # define CURL_FORMAT_CURL_OFF_T "ld" 98 # define CURL_FORMAT_CURL_OFF_TU "lu" 99 # define CURL_SUFFIX_CURL_OFF_T L 100 # define CURL_SUFFIX_CURL_OFF_TU UL 101 # define CURL_TYPEOF_CURL_SOCKLEN_T int 102 103 #elif defined(__POCC__) 104 # if (__POCC__ < 280) 105 # define CURL_TYPEOF_CURL_OFF_T long 106 # define CURL_FORMAT_CURL_OFF_T "ld" 107 # define CURL_FORMAT_CURL_OFF_TU "lu" 108 # define CURL_SUFFIX_CURL_OFF_T L 109 # define CURL_SUFFIX_CURL_OFF_TU UL 110 # elif defined(_MSC_VER) 111 # define CURL_TYPEOF_CURL_OFF_T __int64 112 # define CURL_FORMAT_CURL_OFF_T "I64d" 113 # define CURL_FORMAT_CURL_OFF_TU "I64u" 114 # define CURL_SUFFIX_CURL_OFF_T i64 115 # define CURL_SUFFIX_CURL_OFF_TU ui64 116 # else 117 # define CURL_TYPEOF_CURL_OFF_T long long 118 # define CURL_FORMAT_CURL_OFF_T "lld" 119 # define CURL_FORMAT_CURL_OFF_TU "llu" 120 # define CURL_SUFFIX_CURL_OFF_T LL 121 # define CURL_SUFFIX_CURL_OFF_TU ULL 122 # endif 123 # define CURL_TYPEOF_CURL_SOCKLEN_T int 124 125 #elif defined(__LCC__) 126 # if defined(__MCST__) /* MCST eLbrus Compiler Collection */ 127 # define CURL_TYPEOF_CURL_OFF_T long 128 # define CURL_FORMAT_CURL_OFF_T "ld" 129 # define CURL_FORMAT_CURL_OFF_TU "lu" 130 # define CURL_SUFFIX_CURL_OFF_T L 131 # define CURL_SUFFIX_CURL_OFF_TU UL 132 # define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t 133 # define CURL_PULL_SYS_TYPES_H 1 134 # define CURL_PULL_SYS_SOCKET_H 1 135 # else /* Local (or Little) C Compiler */ 136 # define CURL_TYPEOF_CURL_OFF_T long 137 # define CURL_FORMAT_CURL_OFF_T "ld" 138 # define CURL_FORMAT_CURL_OFF_TU "lu" 139 # define CURL_SUFFIX_CURL_OFF_T L 140 # define CURL_SUFFIX_CURL_OFF_TU UL 141 # define CURL_TYPEOF_CURL_SOCKLEN_T int 142 # endif 143 144 #elif defined(__SYMBIAN32__) 145 # if defined(__EABI__) /* Treat all ARM compilers equally */ 146 # define CURL_TYPEOF_CURL_OFF_T long long 147 # define CURL_FORMAT_CURL_OFF_T "lld" 148 # define CURL_FORMAT_CURL_OFF_TU "llu" 149 # define CURL_SUFFIX_CURL_OFF_T LL 150 # define CURL_SUFFIX_CURL_OFF_TU ULL 151 # elif defined(__CW32__) 152 # pragma longlong on 153 # define CURL_TYPEOF_CURL_OFF_T long long 154 # define CURL_FORMAT_CURL_OFF_T "lld" 155 # define CURL_FORMAT_CURL_OFF_TU "llu" 156 # define CURL_SUFFIX_CURL_OFF_T LL 157 # define CURL_SUFFIX_CURL_OFF_TU ULL 158 # elif defined(__VC32__) 159 # define CURL_TYPEOF_CURL_OFF_T __int64 160 # define CURL_FORMAT_CURL_OFF_T "lld" 161 # define CURL_FORMAT_CURL_OFF_TU "llu" 162 # define CURL_SUFFIX_CURL_OFF_T LL 163 # define CURL_SUFFIX_CURL_OFF_TU ULL 164 # endif 165 # define CURL_TYPEOF_CURL_SOCKLEN_T unsigned int 166 167 #elif defined(macintosh) 168 # include <ConditionalMacros.h> 169 # if TYPE_LONGLONG 170 # define CURL_TYPEOF_CURL_OFF_T long long 171 # define CURL_FORMAT_CURL_OFF_T "lld" 172 # define CURL_FORMAT_CURL_OFF_TU "llu" 173 # define CURL_SUFFIX_CURL_OFF_T LL 174 # define CURL_SUFFIX_CURL_OFF_TU ULL 175 # else 176 # define CURL_TYPEOF_CURL_OFF_T long 177 # define CURL_FORMAT_CURL_OFF_T "ld" 178 # define CURL_FORMAT_CURL_OFF_TU "lu" 179 # define CURL_SUFFIX_CURL_OFF_T L 180 # define CURL_SUFFIX_CURL_OFF_TU UL 181 # endif 182 # define CURL_TYPEOF_CURL_SOCKLEN_T unsigned int 183 184 #elif defined(__TANDEM) 185 # if ! defined(__LP64) 186 /* Required for 32-bit NonStop builds only. */ 187 # define CURL_TYPEOF_CURL_OFF_T long long 188 # define CURL_FORMAT_CURL_OFF_T "lld" 189 # define CURL_FORMAT_CURL_OFF_TU "llu" 190 # define CURL_SUFFIX_CURL_OFF_T LL 191 # define CURL_SUFFIX_CURL_OFF_TU ULL 192 # define CURL_TYPEOF_CURL_SOCKLEN_T int 193 # endif 194 195 #elif defined(_WIN32_WCE) 196 # define CURL_TYPEOF_CURL_OFF_T __int64 197 # define CURL_FORMAT_CURL_OFF_T "I64d" 198 # define CURL_FORMAT_CURL_OFF_TU "I64u" 199 # define CURL_SUFFIX_CURL_OFF_T i64 200 # define CURL_SUFFIX_CURL_OFF_TU ui64 201 # define CURL_TYPEOF_CURL_SOCKLEN_T int 202 203 #elif defined(__MINGW32__) 204 # define CURL_TYPEOF_CURL_OFF_T long long 205 # define CURL_FORMAT_CURL_OFF_T "I64d" 206 # define CURL_FORMAT_CURL_OFF_TU "I64u" 207 # define CURL_SUFFIX_CURL_OFF_T LL 208 # define CURL_SUFFIX_CURL_OFF_TU ULL 209 # define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t 210 # define CURL_PULL_SYS_TYPES_H 1 211 # define CURL_PULL_WS2TCPIP_H 1 212 213 #elif defined(__VMS) 214 # if defined(__VAX) 215 # define CURL_TYPEOF_CURL_OFF_T long 216 # define CURL_FORMAT_CURL_OFF_T "ld" 217 # define CURL_FORMAT_CURL_OFF_TU "lu" 218 # define CURL_SUFFIX_CURL_OFF_T L 219 # define CURL_SUFFIX_CURL_OFF_TU UL 220 # else 221 # define CURL_TYPEOF_CURL_OFF_T long long 222 # define CURL_FORMAT_CURL_OFF_T "lld" 223 # define CURL_FORMAT_CURL_OFF_TU "llu" 224 # define CURL_SUFFIX_CURL_OFF_T LL 225 # define CURL_SUFFIX_CURL_OFF_TU ULL 226 # endif 227 # define CURL_TYPEOF_CURL_SOCKLEN_T unsigned int 228 229 #elif defined(__OS400__) 230 # define CURL_TYPEOF_CURL_OFF_T long long 231 # define CURL_FORMAT_CURL_OFF_T "lld" 232 # define CURL_FORMAT_CURL_OFF_TU "llu" 233 # define CURL_SUFFIX_CURL_OFF_T LL 234 # define CURL_SUFFIX_CURL_OFF_TU ULL 235 # define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t 236 # define CURL_PULL_SYS_TYPES_H 1 237 # define CURL_PULL_SYS_SOCKET_H 1 238 239 #elif defined(__MVS__) 240 # if defined(__IBMC__) || defined(__IBMCPP__) 241 # if defined(_ILP32) 242 # elif defined(_LP64) 243 # endif 244 # if defined(_LONG_LONG) 245 # define CURL_TYPEOF_CURL_OFF_T long long 246 # define CURL_FORMAT_CURL_OFF_T "lld" 247 # define CURL_FORMAT_CURL_OFF_TU "llu" 248 # define CURL_SUFFIX_CURL_OFF_T LL 249 # define CURL_SUFFIX_CURL_OFF_TU ULL 250 # elif defined(_LP64) 251 # define CURL_TYPEOF_CURL_OFF_T long 252 # define CURL_FORMAT_CURL_OFF_T "ld" 253 # define CURL_FORMAT_CURL_OFF_TU "lu" 254 # define CURL_SUFFIX_CURL_OFF_T L 255 # define CURL_SUFFIX_CURL_OFF_TU UL 256 # else 257 # define CURL_TYPEOF_CURL_OFF_T long 258 # define CURL_FORMAT_CURL_OFF_T "ld" 259 # define CURL_FORMAT_CURL_OFF_TU "lu" 260 # define CURL_SUFFIX_CURL_OFF_T L 261 # define CURL_SUFFIX_CURL_OFF_TU UL 262 # endif 263 # define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t 264 # define CURL_PULL_SYS_TYPES_H 1 265 # define CURL_PULL_SYS_SOCKET_H 1 266 # endif 267 268 #elif defined(__370__) 269 # if defined(__IBMC__) || defined(__IBMCPP__) 270 # if defined(_ILP32) 271 # elif defined(_LP64) 272 # endif 273 # if defined(_LONG_LONG) 274 # define CURL_TYPEOF_CURL_OFF_T long long 275 # define CURL_FORMAT_CURL_OFF_T "lld" 276 # define CURL_FORMAT_CURL_OFF_TU "llu" 277 # define CURL_SUFFIX_CURL_OFF_T LL 278 # define CURL_SUFFIX_CURL_OFF_TU ULL 279 # elif defined(_LP64) 280 # define CURL_TYPEOF_CURL_OFF_T long 281 # define CURL_FORMAT_CURL_OFF_T "ld" 282 # define CURL_FORMAT_CURL_OFF_TU "lu" 283 # define CURL_SUFFIX_CURL_OFF_T L 284 # define CURL_SUFFIX_CURL_OFF_TU UL 285 # else 286 # define CURL_TYPEOF_CURL_OFF_T long 287 # define CURL_FORMAT_CURL_OFF_T "ld" 288 # define CURL_FORMAT_CURL_OFF_TU "lu" 289 # define CURL_SUFFIX_CURL_OFF_T L 290 # define CURL_SUFFIX_CURL_OFF_TU UL 291 # endif 292 # define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t 293 # define CURL_PULL_SYS_TYPES_H 1 294 # define CURL_PULL_SYS_SOCKET_H 1 295 # endif 296 297 #elif defined(TPF) 298 # define CURL_TYPEOF_CURL_OFF_T long 299 # define CURL_FORMAT_CURL_OFF_T "ld" 300 # define CURL_FORMAT_CURL_OFF_TU "lu" 301 # define CURL_SUFFIX_CURL_OFF_T L 302 # define CURL_SUFFIX_CURL_OFF_TU UL 303 # define CURL_TYPEOF_CURL_SOCKLEN_T int 304 305 #elif defined(__TINYC__) /* also known as tcc */ 306 # define CURL_TYPEOF_CURL_OFF_T long long 307 # define CURL_FORMAT_CURL_OFF_T "lld" 308 # define CURL_FORMAT_CURL_OFF_TU "llu" 309 # define CURL_SUFFIX_CURL_OFF_T LL 310 # define CURL_SUFFIX_CURL_OFF_TU ULL 311 # define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t 312 # define CURL_PULL_SYS_TYPES_H 1 313 # define CURL_PULL_SYS_SOCKET_H 1 314 315 #elif defined(__SUNPRO_C) || defined(__SUNPRO_CC) /* Oracle Solaris Studio */ 316 # if !defined(__LP64) && (defined(__ILP32) || \ 317 defined(__i386) || \ 318 defined(__sparcv8) || \ 319 defined(__sparcv8plus)) 320 # define CURL_TYPEOF_CURL_OFF_T long long 321 # define CURL_FORMAT_CURL_OFF_T "lld" 322 # define CURL_FORMAT_CURL_OFF_TU "llu" 323 # define CURL_SUFFIX_CURL_OFF_T LL 324 # define CURL_SUFFIX_CURL_OFF_TU ULL 325 # elif defined(__LP64) || \ 326 defined(__amd64) || defined(__sparcv9) 327 # define CURL_TYPEOF_CURL_OFF_T long 328 # define CURL_FORMAT_CURL_OFF_T "ld" 329 # define CURL_FORMAT_CURL_OFF_TU "lu" 330 # define CURL_SUFFIX_CURL_OFF_T L 331 # define CURL_SUFFIX_CURL_OFF_TU UL 332 # endif 333 # define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t 334 # define CURL_PULL_SYS_TYPES_H 1 335 # define CURL_PULL_SYS_SOCKET_H 1 336 337 #elif defined(__xlc__) /* IBM xlc compiler */ 338 # if !defined(_LP64) 339 # define CURL_TYPEOF_CURL_OFF_T long long 340 # define CURL_FORMAT_CURL_OFF_T "lld" 341 # define CURL_FORMAT_CURL_OFF_TU "llu" 342 # define CURL_SUFFIX_CURL_OFF_T LL 343 # define CURL_SUFFIX_CURL_OFF_TU ULL 344 # else 345 # define CURL_TYPEOF_CURL_OFF_T long 346 # define CURL_FORMAT_CURL_OFF_T "ld" 347 # define CURL_FORMAT_CURL_OFF_TU "lu" 348 # define CURL_SUFFIX_CURL_OFF_T L 349 # define CURL_SUFFIX_CURL_OFF_TU UL 350 # endif 351 # define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t 352 # define CURL_PULL_SYS_TYPES_H 1 353 # define CURL_PULL_SYS_SOCKET_H 1 354 355 /* ===================================== */ 356 /* KEEP MSVC THE PENULTIMATE ENTRY */ 357 /* ===================================== */ 358 359 #elif defined(_MSC_VER) 360 # if (_MSC_VER >= 900) && (_INTEGRAL_MAX_BITS >= 64) 361 # define CURL_TYPEOF_CURL_OFF_T __int64 362 # define CURL_FORMAT_CURL_OFF_T "I64d" 363 # define CURL_FORMAT_CURL_OFF_TU "I64u" 364 # define CURL_SUFFIX_CURL_OFF_T i64 365 # define CURL_SUFFIX_CURL_OFF_TU ui64 366 # else 367 # define CURL_TYPEOF_CURL_OFF_T long 368 # define CURL_FORMAT_CURL_OFF_T "ld" 369 # define CURL_FORMAT_CURL_OFF_TU "lu" 370 # define CURL_SUFFIX_CURL_OFF_T L 371 # define CURL_SUFFIX_CURL_OFF_TU UL 372 # endif 373 # define CURL_TYPEOF_CURL_SOCKLEN_T int 374 375 /* ===================================== */ 376 /* KEEP GENERIC GCC THE LAST ENTRY */ 377 /* ===================================== */ 378 379 #elif defined(__GNUC__) && !defined(_SCO_DS) 380 # if !defined(__LP64__) && \ 381 (defined(__ILP32__) || defined(__i386__) || defined(__hppa__) || \ 382 defined(__ppc__) || defined(__powerpc__) || defined(__arm__) || \ 383 defined(__sparc__) || defined(__mips__) || defined(__sh__) || \ 384 defined(__XTENSA__) || \ 385 (defined(__SIZEOF_LONG__) && __SIZEOF_LONG__ == 4) || \ 386 (defined(__LONG_MAX__) && __LONG_MAX__ == 2147483647L)) 387 # define CURL_TYPEOF_CURL_OFF_T long long 388 # define CURL_FORMAT_CURL_OFF_T "lld" 389 # define CURL_FORMAT_CURL_OFF_TU "llu" 390 # define CURL_SUFFIX_CURL_OFF_T LL 391 # define CURL_SUFFIX_CURL_OFF_TU ULL 392 # elif defined(__LP64__) || \ 393 defined(__x86_64__) || defined(__ppc64__) || defined(__sparc64__) || \ 394 defined(__e2k__) || \ 395 (defined(__SIZEOF_LONG__) && __SIZEOF_LONG__ == 8) || \ 396 (defined(__LONG_MAX__) && __LONG_MAX__ == 9223372036854775807L) 397 # define CURL_TYPEOF_CURL_OFF_T long 398 # define CURL_FORMAT_CURL_OFF_T "ld" 399 # define CURL_FORMAT_CURL_OFF_TU "lu" 400 # define CURL_SUFFIX_CURL_OFF_T L 401 # define CURL_SUFFIX_CURL_OFF_TU UL 402 # endif 403 # define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t 404 # define CURL_PULL_SYS_TYPES_H 1 405 # define CURL_PULL_SYS_SOCKET_H 1 406 407 #else 408 /* generic "safe guess" on old 32 bit style */ 409 # define CURL_TYPEOF_CURL_OFF_T long 410 # define CURL_FORMAT_CURL_OFF_T "ld" 411 # define CURL_FORMAT_CURL_OFF_TU "lu" 412 # define CURL_SUFFIX_CURL_OFF_T L 413 # define CURL_SUFFIX_CURL_OFF_TU UL 414 # define CURL_TYPEOF_CURL_SOCKLEN_T int 415 #endif 416 417 #ifdef _AIX 418 /* AIX needs <sys/poll.h> */ 419 #define CURL_PULL_SYS_POLL_H 420 #endif 421 422 423 /* CURL_PULL_WS2TCPIP_H is defined above when inclusion of header file */ 424 /* ws2tcpip.h is required here to properly make type definitions below. */ 425 #ifdef CURL_PULL_WS2TCPIP_H 426 # include <winsock2.h> 427 # include <windows.h> 428 # include <ws2tcpip.h> 429 #endif 430 431 /* CURL_PULL_SYS_TYPES_H is defined above when inclusion of header file */ 432 /* sys/types.h is required here to properly make type definitions below. */ 433 #ifdef CURL_PULL_SYS_TYPES_H 434 # include <sys/types.h> 435 #endif 436 437 /* CURL_PULL_SYS_SOCKET_H is defined above when inclusion of header file */ 438 /* sys/socket.h is required here to properly make type definitions below. */ 439 #ifdef CURL_PULL_SYS_SOCKET_H 440 # include <sys/socket.h> 441 #endif 442 443 /* CURL_PULL_SYS_POLL_H is defined above when inclusion of header file */ 444 /* sys/poll.h is required here to properly make type definitions below. */ 445 #ifdef CURL_PULL_SYS_POLL_H 446 # include <sys/poll.h> 447 #endif 448 449 /* Data type definition of curl_socklen_t. */ 450 #ifdef CURL_TYPEOF_CURL_SOCKLEN_T 451 typedef CURL_TYPEOF_CURL_SOCKLEN_T curl_socklen_t; 452 #endif 453 454 /* Data type definition of curl_off_t. */ 455 456 #ifdef CURL_TYPEOF_CURL_OFF_T 457 typedef CURL_TYPEOF_CURL_OFF_T curl_off_t; 458 #endif 459 460 /* 461 * CURL_ISOCPP and CURL_OFF_T_C definitions are done here in order to allow 462 * these to be visible and exported by the external libcurl interface API, 463 * while also making them visible to the library internals, simply including 464 * curl_setup.h, without actually needing to include curl.h internally. 465 * If some day this section would grow big enough, all this should be moved 466 * to its own header file. 467 */ 468 469 /* 470 * Figure out if we can use the ## preprocessor operator, which is supported 471 * by ISO/ANSI C and C++. Some compilers support it without setting __STDC__ 472 * or __cplusplus so we need to carefully check for them too. 473 */ 474 475 #if defined(__STDC__) || defined(_MSC_VER) || defined(__cplusplus) || \ 476 defined(__HP_aCC) || defined(__BORLANDC__) || defined(__LCC__) || \ 477 defined(__POCC__) || defined(__SALFORDC__) || defined(__HIGHC__) || \ 478 defined(__ILEC400__) 479 /* This compiler is believed to have an ISO compatible preprocessor */ 480 #define CURL_ISOCPP 481 #else 482 /* This compiler is believed NOT to have an ISO compatible preprocessor */ 483 #undef CURL_ISOCPP 484 #endif 485 486 /* 487 * Macros for minimum-width signed and unsigned curl_off_t integer constants. 488 */ 489 490 #if defined(__BORLANDC__) && (__BORLANDC__ == 0x0551) 491 # define CURLINC_OFF_T_C_HLPR2(x) x 492 # define CURLINC_OFF_T_C_HLPR1(x) CURLINC_OFF_T_C_HLPR2(x) 493 # define CURL_OFF_T_C(Val) CURLINC_OFF_T_C_HLPR1(Val) ## \ 494 CURLINC_OFF_T_C_HLPR1(CURL_SUFFIX_CURL_OFF_T) 495 # define CURL_OFF_TU_C(Val) CURLINC_OFF_T_C_HLPR1(Val) ## \ 496 CURLINC_OFF_T_C_HLPR1(CURL_SUFFIX_CURL_OFF_TU) 497 #else 498 # ifdef CURL_ISOCPP 499 # define CURLINC_OFF_T_C_HLPR2(Val,Suffix) Val ## Suffix 500 # else 501 # define CURLINC_OFF_T_C_HLPR2(Val,Suffix) Val/**/Suffix 502 # endif 503 # define CURLINC_OFF_T_C_HLPR1(Val,Suffix) CURLINC_OFF_T_C_HLPR2(Val,Suffix) 504 # define CURL_OFF_T_C(Val) CURLINC_OFF_T_C_HLPR1(Val,CURL_SUFFIX_CURL_OFF_T) 505 # define CURL_OFF_TU_C(Val) CURLINC_OFF_T_C_HLPR1(Val,CURL_SUFFIX_CURL_OFF_TU) 506 #endif 507 508 #endif /* CURLINC_SYSTEM_H */ 509