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__) 56 # define CURL_TYPEOF_CURL_OFF_T long long 57 # define CURL_FORMAT_CURL_OFF_T "lld" 58 # define CURL_FORMAT_CURL_OFF_TU "llu" 59 # define CURL_SUFFIX_CURL_OFF_T LL 60 # define CURL_SUFFIX_CURL_OFF_TU ULL 61 # define CURL_TYPEOF_CURL_SOCKLEN_T int 62 63 #elif defined(__BORLANDC__) 64 # define CURL_TYPEOF_CURL_OFF_T __int64 65 # define CURL_FORMAT_CURL_OFF_T "I64d" 66 # define CURL_FORMAT_CURL_OFF_TU "I64u" 67 # define CURL_SUFFIX_CURL_OFF_T i64 68 # define CURL_SUFFIX_CURL_OFF_TU ui64 69 # define CURL_TYPEOF_CURL_SOCKLEN_T int 70 71 #elif defined(__POCC__) 72 # if defined(_MSC_VER) 73 # define CURL_TYPEOF_CURL_OFF_T __int64 74 # define CURL_FORMAT_CURL_OFF_T "I64d" 75 # define CURL_FORMAT_CURL_OFF_TU "I64u" 76 # define CURL_SUFFIX_CURL_OFF_T i64 77 # define CURL_SUFFIX_CURL_OFF_TU ui64 78 # else 79 # define CURL_TYPEOF_CURL_OFF_T long long 80 # define CURL_FORMAT_CURL_OFF_T "lld" 81 # define CURL_FORMAT_CURL_OFF_TU "llu" 82 # define CURL_SUFFIX_CURL_OFF_T LL 83 # define CURL_SUFFIX_CURL_OFF_TU ULL 84 # endif 85 # define CURL_TYPEOF_CURL_SOCKLEN_T int 86 87 #elif defined(__LCC__) 88 # if defined(__MCST__) /* MCST eLbrus Compiler Collection */ 89 # define CURL_TYPEOF_CURL_OFF_T long 90 # define CURL_FORMAT_CURL_OFF_T "ld" 91 # define CURL_FORMAT_CURL_OFF_TU "lu" 92 # define CURL_SUFFIX_CURL_OFF_T L 93 # define CURL_SUFFIX_CURL_OFF_TU UL 94 # define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t 95 # define CURL_PULL_SYS_TYPES_H 1 96 # define CURL_PULL_SYS_SOCKET_H 1 97 # else /* Local (or Little) C Compiler */ 98 # define CURL_TYPEOF_CURL_OFF_T long 99 # define CURL_FORMAT_CURL_OFF_T "ld" 100 # define CURL_FORMAT_CURL_OFF_TU "lu" 101 # define CURL_SUFFIX_CURL_OFF_T L 102 # define CURL_SUFFIX_CURL_OFF_TU UL 103 # define CURL_TYPEOF_CURL_SOCKLEN_T int 104 # endif 105 106 #elif defined(macintosh) 107 # include <ConditionalMacros.h> 108 # if TYPE_LONGLONG 109 # define CURL_TYPEOF_CURL_OFF_T long long 110 # define CURL_FORMAT_CURL_OFF_T "lld" 111 # define CURL_FORMAT_CURL_OFF_TU "llu" 112 # define CURL_SUFFIX_CURL_OFF_T LL 113 # define CURL_SUFFIX_CURL_OFF_TU ULL 114 # else 115 # define CURL_TYPEOF_CURL_OFF_T long 116 # define CURL_FORMAT_CURL_OFF_T "ld" 117 # define CURL_FORMAT_CURL_OFF_TU "lu" 118 # define CURL_SUFFIX_CURL_OFF_T L 119 # define CURL_SUFFIX_CURL_OFF_TU UL 120 # endif 121 # define CURL_TYPEOF_CURL_SOCKLEN_T unsigned int 122 123 #elif defined(__TANDEM) 124 # if !defined(__LP64) 125 # define CURL_TYPEOF_CURL_OFF_T long long 126 # define CURL_FORMAT_CURL_OFF_T "lld" 127 # define CURL_FORMAT_CURL_OFF_TU "llu" 128 # define CURL_SUFFIX_CURL_OFF_T LL 129 # define CURL_SUFFIX_CURL_OFF_TU ULL 130 # define CURL_TYPEOF_CURL_SOCKLEN_T int 131 # else 132 # define CURL_TYPEOF_CURL_OFF_T long 133 # define CURL_FORMAT_CURL_OFF_T "ld" 134 # define CURL_FORMAT_CURL_OFF_TU "lu" 135 # define CURL_SUFFIX_CURL_OFF_T L 136 # define CURL_SUFFIX_CURL_OFF_TU UL 137 # define CURL_TYPEOF_CURL_SOCKLEN_T unsigned int 138 # endif 139 140 #elif defined(_WIN32_WCE) 141 # define CURL_TYPEOF_CURL_OFF_T __int64 142 # define CURL_FORMAT_CURL_OFF_T "I64d" 143 # define CURL_FORMAT_CURL_OFF_TU "I64u" 144 # define CURL_SUFFIX_CURL_OFF_T i64 145 # define CURL_SUFFIX_CURL_OFF_TU ui64 146 # define CURL_TYPEOF_CURL_SOCKLEN_T int 147 148 #elif defined(__MINGW32__) 149 # include <inttypes.h> 150 # define CURL_TYPEOF_CURL_OFF_T long long 151 # define CURL_FORMAT_CURL_OFF_T PRId64 152 # define CURL_FORMAT_CURL_OFF_TU PRIu64 153 # define CURL_SUFFIX_CURL_OFF_T LL 154 # define CURL_SUFFIX_CURL_OFF_TU ULL 155 # define CURL_TYPEOF_CURL_SOCKLEN_T int 156 # define CURL_PULL_SYS_TYPES_H 1 157 158 #elif defined(__VMS) 159 # if defined(__VAX) 160 # define CURL_TYPEOF_CURL_OFF_T long 161 # define CURL_FORMAT_CURL_OFF_T "ld" 162 # define CURL_FORMAT_CURL_OFF_TU "lu" 163 # define CURL_SUFFIX_CURL_OFF_T L 164 # define CURL_SUFFIX_CURL_OFF_TU UL 165 # else 166 # define CURL_TYPEOF_CURL_OFF_T long long 167 # define CURL_FORMAT_CURL_OFF_T "lld" 168 # define CURL_FORMAT_CURL_OFF_TU "llu" 169 # define CURL_SUFFIX_CURL_OFF_T LL 170 # define CURL_SUFFIX_CURL_OFF_TU ULL 171 # endif 172 # define CURL_TYPEOF_CURL_SOCKLEN_T unsigned int 173 174 #elif defined(__OS400__) 175 # define CURL_TYPEOF_CURL_OFF_T long long 176 # define CURL_FORMAT_CURL_OFF_T "lld" 177 # define CURL_FORMAT_CURL_OFF_TU "llu" 178 # define CURL_SUFFIX_CURL_OFF_T LL 179 # define CURL_SUFFIX_CURL_OFF_TU ULL 180 # define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t 181 # define CURL_PULL_SYS_TYPES_H 1 182 # define CURL_PULL_SYS_SOCKET_H 1 183 184 #elif defined(__MVS__) 185 # if defined(_LONG_LONG) 186 # define CURL_TYPEOF_CURL_OFF_T long long 187 # define CURL_FORMAT_CURL_OFF_T "lld" 188 # define CURL_FORMAT_CURL_OFF_TU "llu" 189 # define CURL_SUFFIX_CURL_OFF_T LL 190 # define CURL_SUFFIX_CURL_OFF_TU ULL 191 # else /* _LP64 and default */ 192 # define CURL_TYPEOF_CURL_OFF_T long 193 # define CURL_FORMAT_CURL_OFF_T "ld" 194 # define CURL_FORMAT_CURL_OFF_TU "lu" 195 # define CURL_SUFFIX_CURL_OFF_T L 196 # define CURL_SUFFIX_CURL_OFF_TU UL 197 # endif 198 # define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t 199 # define CURL_PULL_SYS_TYPES_H 1 200 # define CURL_PULL_SYS_SOCKET_H 1 201 202 #elif defined(__370__) 203 # if defined(__IBMC__) || defined(__IBMCPP__) 204 # if defined(_LONG_LONG) 205 # define CURL_TYPEOF_CURL_OFF_T long long 206 # define CURL_FORMAT_CURL_OFF_T "lld" 207 # define CURL_FORMAT_CURL_OFF_TU "llu" 208 # define CURL_SUFFIX_CURL_OFF_T LL 209 # define CURL_SUFFIX_CURL_OFF_TU ULL 210 # else /* _LP64 and default */ 211 # define CURL_TYPEOF_CURL_OFF_T long 212 # define CURL_FORMAT_CURL_OFF_T "ld" 213 # define CURL_FORMAT_CURL_OFF_TU "lu" 214 # define CURL_SUFFIX_CURL_OFF_T L 215 # define CURL_SUFFIX_CURL_OFF_TU UL 216 # endif 217 # define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t 218 # define CURL_PULL_SYS_TYPES_H 1 219 # define CURL_PULL_SYS_SOCKET_H 1 220 # endif 221 222 #elif defined(TPF) 223 # define CURL_TYPEOF_CURL_OFF_T long 224 # define CURL_FORMAT_CURL_OFF_T "ld" 225 # define CURL_FORMAT_CURL_OFF_TU "lu" 226 # define CURL_SUFFIX_CURL_OFF_T L 227 # define CURL_SUFFIX_CURL_OFF_TU UL 228 # define CURL_TYPEOF_CURL_SOCKLEN_T int 229 230 #elif defined(__TINYC__) /* also known as tcc */ 231 # define CURL_TYPEOF_CURL_OFF_T long long 232 # define CURL_FORMAT_CURL_OFF_T "lld" 233 # define CURL_FORMAT_CURL_OFF_TU "llu" 234 # define CURL_SUFFIX_CURL_OFF_T LL 235 # define CURL_SUFFIX_CURL_OFF_TU ULL 236 # define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t 237 # define CURL_PULL_SYS_TYPES_H 1 238 # define CURL_PULL_SYS_SOCKET_H 1 239 240 #elif defined(__SUNPRO_C) || defined(__SUNPRO_CC) /* Oracle Solaris Studio */ 241 # if !defined(__LP64) && (defined(__ILP32) || \ 242 defined(__i386) || \ 243 defined(__sparcv8) || \ 244 defined(__sparcv8plus)) 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 defined(__amd64) || defined(__sparcv9) 252 # define CURL_TYPEOF_CURL_OFF_T long 253 # define CURL_FORMAT_CURL_OFF_T "ld" 254 # define CURL_FORMAT_CURL_OFF_TU "lu" 255 # define CURL_SUFFIX_CURL_OFF_T L 256 # define CURL_SUFFIX_CURL_OFF_TU UL 257 # endif 258 # define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t 259 # define CURL_PULL_SYS_TYPES_H 1 260 # define CURL_PULL_SYS_SOCKET_H 1 261 262 #elif defined(__xlc__) /* IBM xlc compiler */ 263 # if !defined(_LP64) 264 # define CURL_TYPEOF_CURL_OFF_T long long 265 # define CURL_FORMAT_CURL_OFF_T "lld" 266 # define CURL_FORMAT_CURL_OFF_TU "llu" 267 # define CURL_SUFFIX_CURL_OFF_T LL 268 # define CURL_SUFFIX_CURL_OFF_TU ULL 269 # else 270 # define CURL_TYPEOF_CURL_OFF_T long 271 # define CURL_FORMAT_CURL_OFF_T "ld" 272 # define CURL_FORMAT_CURL_OFF_TU "lu" 273 # define CURL_SUFFIX_CURL_OFF_T L 274 # define CURL_SUFFIX_CURL_OFF_TU UL 275 # endif 276 # define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t 277 # define CURL_PULL_SYS_TYPES_H 1 278 # define CURL_PULL_SYS_SOCKET_H 1 279 280 #elif defined(__hpux) /* HP aCC compiler */ 281 # if !defined(_LP64) 282 # define CURL_TYPEOF_CURL_OFF_T long long 283 # define CURL_FORMAT_CURL_OFF_T "lld" 284 # define CURL_FORMAT_CURL_OFF_TU "llu" 285 # define CURL_SUFFIX_CURL_OFF_T LL 286 # define CURL_SUFFIX_CURL_OFF_TU ULL 287 # else 288 # define CURL_TYPEOF_CURL_OFF_T long 289 # define CURL_FORMAT_CURL_OFF_T "ld" 290 # define CURL_FORMAT_CURL_OFF_TU "lu" 291 # define CURL_SUFFIX_CURL_OFF_T L 292 # define CURL_SUFFIX_CURL_OFF_TU UL 293 # endif 294 # define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t 295 # define CURL_PULL_SYS_TYPES_H 1 296 # define CURL_PULL_SYS_SOCKET_H 1 297 298 /* ===================================== */ 299 /* KEEP MSVC THE PENULTIMATE ENTRY */ 300 /* ===================================== */ 301 302 #elif defined(_MSC_VER) 303 # if (_MSC_VER >= 1800) 304 # include <inttypes.h> 305 # define CURL_FORMAT_CURL_OFF_T PRId64 306 # define CURL_FORMAT_CURL_OFF_TU PRIu64 307 # else 308 # define CURL_FORMAT_CURL_OFF_T "I64d" 309 # define CURL_FORMAT_CURL_OFF_TU "I64u" 310 # endif 311 # define CURL_TYPEOF_CURL_OFF_T __int64 312 # define CURL_SUFFIX_CURL_OFF_T i64 313 # define CURL_SUFFIX_CURL_OFF_TU ui64 314 # define CURL_TYPEOF_CURL_SOCKLEN_T int 315 316 /* ===================================== */ 317 /* KEEP GENERIC GCC THE LAST ENTRY */ 318 /* ===================================== */ 319 320 #elif defined(__GNUC__) && !defined(_SCO_DS) 321 # if !defined(__LP64__) && \ 322 (defined(__ILP32__) || defined(__i386__) || defined(__hppa__) || \ 323 defined(__ppc__) || defined(__powerpc__) || defined(__arm__) || \ 324 defined(__sparc__) || defined(__mips__) || defined(__sh__) || \ 325 defined(__XTENSA__) || \ 326 (defined(__SIZEOF_LONG__) && __SIZEOF_LONG__ == 4) || \ 327 (defined(__LONG_MAX__) && __LONG_MAX__ == 2147483647L)) 328 # define CURL_TYPEOF_CURL_OFF_T long long 329 # define CURL_FORMAT_CURL_OFF_T "lld" 330 # define CURL_FORMAT_CURL_OFF_TU "llu" 331 # define CURL_SUFFIX_CURL_OFF_T LL 332 # define CURL_SUFFIX_CURL_OFF_TU ULL 333 # elif defined(__LP64__) || \ 334 defined(__x86_64__) || defined(__ppc64__) || defined(__sparc64__) || \ 335 defined(__e2k__) || \ 336 (defined(__SIZEOF_LONG__) && __SIZEOF_LONG__ == 8) || \ 337 (defined(__LONG_MAX__) && __LONG_MAX__ == 9223372036854775807L) 338 # define CURL_TYPEOF_CURL_OFF_T long 339 # define CURL_FORMAT_CURL_OFF_T "ld" 340 # define CURL_FORMAT_CURL_OFF_TU "lu" 341 # define CURL_SUFFIX_CURL_OFF_T L 342 # define CURL_SUFFIX_CURL_OFF_TU UL 343 # endif 344 # define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t 345 # define CURL_PULL_SYS_TYPES_H 1 346 # define CURL_PULL_SYS_SOCKET_H 1 347 348 #else 349 /* generic "safe guess" on old 32-bit style */ 350 # define CURL_TYPEOF_CURL_OFF_T long 351 # define CURL_FORMAT_CURL_OFF_T "ld" 352 # define CURL_FORMAT_CURL_OFF_TU "lu" 353 # define CURL_SUFFIX_CURL_OFF_T L 354 # define CURL_SUFFIX_CURL_OFF_TU UL 355 # define CURL_TYPEOF_CURL_SOCKLEN_T int 356 #endif 357 358 #ifdef _AIX 359 /* AIX needs <sys/poll.h> */ 360 #define CURL_PULL_SYS_POLL_H 361 #endif 362 363 /* CURL_PULL_SYS_TYPES_H is defined above when inclusion of header file */ 364 /* sys/types.h is required here to properly make type definitions below. */ 365 #ifdef CURL_PULL_SYS_TYPES_H 366 # include <sys/types.h> 367 #endif 368 369 /* CURL_PULL_SYS_SOCKET_H is defined above when inclusion of header file */ 370 /* sys/socket.h is required here to properly make type definitions below. */ 371 #ifdef CURL_PULL_SYS_SOCKET_H 372 # include <sys/socket.h> 373 #endif 374 375 /* CURL_PULL_SYS_POLL_H is defined above when inclusion of header file */ 376 /* sys/poll.h is required here to properly make type definitions below. */ 377 #ifdef CURL_PULL_SYS_POLL_H 378 # include <sys/poll.h> 379 #endif 380 381 /* Data type definition of curl_socklen_t. */ 382 #ifdef CURL_TYPEOF_CURL_SOCKLEN_T 383 typedef CURL_TYPEOF_CURL_SOCKLEN_T curl_socklen_t; 384 #endif 385 386 /* Data type definition of curl_off_t. */ 387 388 #ifdef CURL_TYPEOF_CURL_OFF_T 389 typedef CURL_TYPEOF_CURL_OFF_T curl_off_t; 390 #endif 391 392 /* 393 * CURL_ISOCPP and CURL_OFF_T_C definitions are done here in order to allow 394 * these to be visible and exported by the external libcurl interface API, 395 * while also making them visible to the library internals, simply including 396 * curl_setup.h, without actually needing to include curl.h internally. 397 * If some day this section would grow big enough, all this should be moved 398 * to its own header file. 399 */ 400 401 /* 402 * Figure out if we can use the ## preprocessor operator, which is supported 403 * by ISO/ANSI C and C++. Some compilers support it without setting __STDC__ 404 * or __cplusplus so we need to carefully check for them too. 405 */ 406 407 #if defined(__STDC__) || defined(_MSC_VER) || defined(__cplusplus) || \ 408 defined(__HP_aCC) || defined(__BORLANDC__) || defined(__LCC__) || \ 409 defined(__POCC__) || defined(__HIGHC__) || \ 410 defined(__ILEC400__) 411 /* This compiler is believed to have an ISO compatible preprocessor */ 412 #define CURL_ISOCPP 413 #else 414 /* This compiler is believed NOT to have an ISO compatible preprocessor */ 415 #undef CURL_ISOCPP 416 #endif 417 418 /* 419 * Macros for minimum-width signed and unsigned curl_off_t integer constants. 420 */ 421 422 #if defined(__BORLANDC__) && (__BORLANDC__ == 0x0551) 423 # define CURLINC_OFF_T_C_HLPR2(x) x 424 # define CURLINC_OFF_T_C_HLPR1(x) CURLINC_OFF_T_C_HLPR2(x) 425 # define CURL_OFF_T_C(Val) CURLINC_OFF_T_C_HLPR1(Val) ## \ 426 CURLINC_OFF_T_C_HLPR1(CURL_SUFFIX_CURL_OFF_T) 427 # define CURL_OFF_TU_C(Val) CURLINC_OFF_T_C_HLPR1(Val) ## \ 428 CURLINC_OFF_T_C_HLPR1(CURL_SUFFIX_CURL_OFF_TU) 429 #else 430 # ifdef CURL_ISOCPP 431 # define CURLINC_OFF_T_C_HLPR2(Val,Suffix) Val ## Suffix 432 # else 433 # define CURLINC_OFF_T_C_HLPR2(Val,Suffix) Val/**/Suffix 434 # endif 435 # define CURLINC_OFF_T_C_HLPR1(Val,Suffix) CURLINC_OFF_T_C_HLPR2(Val,Suffix) 436 # define CURL_OFF_T_C(Val) CURLINC_OFF_T_C_HLPR1(Val,CURL_SUFFIX_CURL_OFF_T) 437 # define CURL_OFF_TU_C(Val) CURLINC_OFF_T_C_HLPR1(Val,CURL_SUFFIX_CURL_OFF_TU) 438 #endif 439 440 #endif /* CURLINC_SYSTEM_H */ 441