Victor Chang | 7322950 | 2020-09-17 13:39:19 +0100 | [diff] [blame] | 1 | // © 2016 and later: Unicode, Inc. and others. |
| 2 | // License & terms of use: http://www.unicode.org/copyright.html |
| 3 | /* |
| 4 | ****************************************************************************** |
| 5 | * |
| 6 | * Copyright (C) 1997-2016, International Business Machines |
| 7 | * Corporation and others. All Rights Reserved. |
| 8 | * |
| 9 | ****************************************************************************** |
| 10 | * |
| 11 | * FILE NAME : putilimp.h |
| 12 | * |
| 13 | * Date Name Description |
| 14 | * 10/17/04 grhoten Move internal functions from putil.h to this file. |
| 15 | ****************************************************************************** |
| 16 | */ |
| 17 | |
| 18 | #ifndef PUTILIMP_H |
| 19 | #define PUTILIMP_H |
| 20 | |
| 21 | #include "unicode/utypes.h" |
| 22 | #include "unicode/putil.h" |
| 23 | |
| 24 | /** |
| 25 | * \def U_SIGNED_RIGHT_SHIFT_IS_ARITHMETIC |
| 26 | * Nearly all CPUs and compilers implement a right-shift of a signed integer |
| 27 | * as an Arithmetic Shift Right which copies the sign bit (the Most Significant Bit (MSB)) |
| 28 | * into the vacated bits (sign extension). |
| 29 | * For example, (int32_t)0xfff5fff3>>4 becomes 0xffff5fff and -1>>1=-1. |
| 30 | * |
| 31 | * This can be useful for storing a signed value in the upper bits |
| 32 | * and another bit field in the lower bits. |
| 33 | * The signed value can be retrieved by simple right-shifting. |
| 34 | * |
| 35 | * This is consistent with the Java language. |
| 36 | * |
| 37 | * However, the C standard allows compilers to implement a right-shift of a signed integer |
| 38 | * as a Logical Shift Right which copies a 0 into the vacated bits. |
| 39 | * For example, (int32_t)0xfff5fff3>>4 becomes 0x0fff5fff and -1>>1=0x7fffffff. |
| 40 | * |
| 41 | * Code that depends on the natural behavior should be guarded with this macro, |
| 42 | * with an alternate path for unusual platforms. |
| 43 | * @internal |
| 44 | */ |
| 45 | #ifdef U_SIGNED_RIGHT_SHIFT_IS_ARITHMETIC |
| 46 | /* Use the predefined value. */ |
| 47 | #else |
| 48 | /* |
| 49 | * Nearly all CPUs & compilers implement a right-shift of a signed integer |
| 50 | * as an Arithmetic Shift Right (with sign extension). |
| 51 | */ |
| 52 | # define U_SIGNED_RIGHT_SHIFT_IS_ARITHMETIC 1 |
| 53 | #endif |
| 54 | |
| 55 | /** Define this to 1 if your platform supports IEEE 754 floating point, |
| 56 | to 0 if it does not. */ |
| 57 | #ifndef IEEE_754 |
| 58 | # define IEEE_754 1 |
| 59 | #endif |
| 60 | |
| 61 | /** |
| 62 | * uintptr_t is an optional part of the standard definitions in stdint.h. |
| 63 | * The opengroup.org documentation for stdint.h says |
| 64 | * "On XSI-conformant systems, the intptr_t and uintptr_t types are required; |
| 65 | * otherwise, they are optional." |
| 66 | * We assume that when uintptr_t is defined, UINTPTR_MAX is defined as well. |
| 67 | * |
| 68 | * Do not use ptrdiff_t since it is signed. size_t is unsigned. |
| 69 | */ |
| 70 | /* TODO: This check fails on some z environments. Filed a ticket #9357 for this. */ |
| 71 | #if !defined(__intptr_t_defined) && !defined(UINTPTR_MAX) && (U_PLATFORM != U_PF_OS390) |
| 72 | typedef size_t uintptr_t; |
| 73 | #endif |
| 74 | |
| 75 | /*===========================================================================*/ |
| 76 | /** @{ Information about POSIX support */ |
| 77 | /*===========================================================================*/ |
| 78 | |
| 79 | #ifdef U_HAVE_NL_LANGINFO_CODESET |
| 80 | /* Use the predefined value. */ |
| 81 | #elif U_PLATFORM_USES_ONLY_WIN32_API || U_PLATFORM == U_PF_ANDROID || U_PLATFORM == U_PF_QNX |
| 82 | # define U_HAVE_NL_LANGINFO_CODESET 0 |
| 83 | #else |
| 84 | # define U_HAVE_NL_LANGINFO_CODESET 1 |
| 85 | #endif |
| 86 | |
| 87 | #ifdef U_NL_LANGINFO_CODESET |
| 88 | /* Use the predefined value. */ |
| 89 | #elif !U_HAVE_NL_LANGINFO_CODESET |
| 90 | # define U_NL_LANGINFO_CODESET -1 |
| 91 | #elif U_PLATFORM == U_PF_OS400 |
| 92 | /* not defined */ |
| 93 | #else |
| 94 | # define U_NL_LANGINFO_CODESET CODESET |
| 95 | #endif |
| 96 | |
| 97 | #if defined(U_TZSET) || defined(U_HAVE_TZSET) |
| 98 | /* Use the predefined value. */ |
| 99 | #elif U_PLATFORM_USES_ONLY_WIN32_API |
| 100 | // UWP doesn't support tzset or environment variables for tz |
| 101 | #if U_PLATFORM_HAS_WINUWP_API == 0 |
| 102 | # define U_TZSET _tzset |
| 103 | #endif |
| 104 | #elif U_PLATFORM == U_PF_OS400 |
| 105 | /* not defined */ |
| 106 | #else |
| 107 | # define U_TZSET tzset |
| 108 | #endif |
| 109 | |
| 110 | #if defined(U_TIMEZONE) || defined(U_HAVE_TIMEZONE) |
| 111 | /* Use the predefined value. */ |
| 112 | #elif U_PLATFORM == U_PF_ANDROID |
| 113 | # define U_TIMEZONE timezone |
| 114 | #elif defined(__UCLIBC__) |
| 115 | // uClibc does not have __timezone or _timezone. |
| 116 | #elif defined(_NEWLIB_VERSION) |
| 117 | # define U_TIMEZONE _timezone |
| 118 | #elif defined(__GLIBC__) |
| 119 | // glibc |
| 120 | # define U_TIMEZONE __timezone |
| 121 | #elif U_PLATFORM_IS_LINUX_BASED |
| 122 | // not defined |
| 123 | #elif U_PLATFORM_USES_ONLY_WIN32_API |
| 124 | # define U_TIMEZONE _timezone |
| 125 | #elif U_PLATFORM == U_PF_BSD && !defined(__NetBSD__) |
| 126 | /* not defined */ |
| 127 | #elif U_PLATFORM == U_PF_OS400 |
| 128 | /* not defined */ |
| 129 | #elif U_PLATFORM == U_PF_IPHONE |
| 130 | /* not defined */ |
| 131 | #else |
| 132 | # define U_TIMEZONE timezone |
| 133 | #endif |
| 134 | |
| 135 | #if defined(U_TZNAME) || defined(U_HAVE_TZNAME) |
| 136 | /* Use the predefined value. */ |
| 137 | #elif U_PLATFORM_USES_ONLY_WIN32_API |
| 138 | /* not usable on all windows platforms */ |
| 139 | #if U_PLATFORM_HAS_WINUWP_API == 0 |
| 140 | # define U_TZNAME _tzname |
| 141 | #endif |
| 142 | #elif U_PLATFORM == U_PF_OS400 |
| 143 | /* not defined */ |
| 144 | #else |
| 145 | # define U_TZNAME tzname |
| 146 | #endif |
| 147 | |
| 148 | #ifdef U_HAVE_MMAP |
| 149 | /* Use the predefined value. */ |
| 150 | #elif U_PLATFORM_USES_ONLY_WIN32_API |
| 151 | # define U_HAVE_MMAP 0 |
| 152 | #else |
| 153 | # define U_HAVE_MMAP 1 |
| 154 | #endif |
| 155 | |
| 156 | #ifdef U_HAVE_POPEN |
| 157 | /* Use the predefined value. */ |
| 158 | #elif U_PLATFORM_USES_ONLY_WIN32_API |
| 159 | # define U_HAVE_POPEN 0 |
| 160 | #elif U_PLATFORM == U_PF_OS400 |
| 161 | # define U_HAVE_POPEN 0 |
| 162 | #else |
| 163 | # define U_HAVE_POPEN 1 |
| 164 | #endif |
| 165 | |
| 166 | /** |
| 167 | * \def U_HAVE_DIRENT_H |
| 168 | * Defines whether dirent.h is available. |
| 169 | * @internal |
| 170 | */ |
| 171 | #ifdef U_HAVE_DIRENT_H |
| 172 | /* Use the predefined value. */ |
| 173 | #elif U_PLATFORM_USES_ONLY_WIN32_API |
| 174 | # define U_HAVE_DIRENT_H 0 |
| 175 | #else |
| 176 | # define U_HAVE_DIRENT_H 1 |
| 177 | #endif |
| 178 | |
| 179 | /** @} */ |
| 180 | |
| 181 | /*===========================================================================*/ |
| 182 | /** @{ Programs used by ICU code */ |
| 183 | /*===========================================================================*/ |
| 184 | |
| 185 | /** |
| 186 | * \def U_MAKE_IS_NMAKE |
| 187 | * Defines whether the "make" program is Windows nmake. |
| 188 | */ |
| 189 | #ifdef U_MAKE_IS_NMAKE |
| 190 | /* Use the predefined value. */ |
| 191 | #elif U_PLATFORM == U_PF_WINDOWS |
| 192 | # define U_MAKE_IS_NMAKE 1 |
| 193 | #else |
| 194 | # define U_MAKE_IS_NMAKE 0 |
| 195 | #endif |
| 196 | |
| 197 | /** @} */ |
| 198 | |
| 199 | /*==========================================================================*/ |
| 200 | /* Platform utilities */ |
| 201 | /*==========================================================================*/ |
| 202 | |
| 203 | /** |
| 204 | * Platform utilities isolates the platform dependencies of the |
| 205 | * library. For each platform which this code is ported to, these |
| 206 | * functions may have to be re-implemented. |
| 207 | */ |
| 208 | |
| 209 | /** |
| 210 | * Floating point utility to determine if a double is Not a Number (NaN). |
| 211 | * @internal |
| 212 | */ |
Victor Chang | ce4bf3c | 2021-01-19 16:34:24 +0000 | [diff] [blame] | 213 | U_CAPI UBool U_EXPORT2 uprv_isNaN(double d); |
Victor Chang | 7322950 | 2020-09-17 13:39:19 +0100 | [diff] [blame] | 214 | /** |
| 215 | * Floating point utility to determine if a double has an infinite value. |
| 216 | * @internal |
| 217 | */ |
Victor Chang | ce4bf3c | 2021-01-19 16:34:24 +0000 | [diff] [blame] | 218 | U_CAPI UBool U_EXPORT2 uprv_isInfinite(double d); |
Victor Chang | 7322950 | 2020-09-17 13:39:19 +0100 | [diff] [blame] | 219 | /** |
| 220 | * Floating point utility to determine if a double has a positive infinite value. |
| 221 | * @internal |
| 222 | */ |
Victor Chang | ce4bf3c | 2021-01-19 16:34:24 +0000 | [diff] [blame] | 223 | U_CAPI UBool U_EXPORT2 uprv_isPositiveInfinity(double d); |
Victor Chang | 7322950 | 2020-09-17 13:39:19 +0100 | [diff] [blame] | 224 | /** |
| 225 | * Floating point utility to determine if a double has a negative infinite value. |
| 226 | * @internal |
| 227 | */ |
Victor Chang | ce4bf3c | 2021-01-19 16:34:24 +0000 | [diff] [blame] | 228 | U_CAPI UBool U_EXPORT2 uprv_isNegativeInfinity(double d); |
Victor Chang | 7322950 | 2020-09-17 13:39:19 +0100 | [diff] [blame] | 229 | /** |
| 230 | * Floating point utility that returns a Not a Number (NaN) value. |
| 231 | * @internal |
| 232 | */ |
Victor Chang | ce4bf3c | 2021-01-19 16:34:24 +0000 | [diff] [blame] | 233 | U_CAPI double U_EXPORT2 uprv_getNaN(void); |
Victor Chang | 7322950 | 2020-09-17 13:39:19 +0100 | [diff] [blame] | 234 | /** |
| 235 | * Floating point utility that returns an infinite value. |
| 236 | * @internal |
| 237 | */ |
Victor Chang | ce4bf3c | 2021-01-19 16:34:24 +0000 | [diff] [blame] | 238 | U_CAPI double U_EXPORT2 uprv_getInfinity(void); |
Victor Chang | 7322950 | 2020-09-17 13:39:19 +0100 | [diff] [blame] | 239 | |
| 240 | /** |
| 241 | * Floating point utility to truncate a double. |
| 242 | * @internal |
| 243 | */ |
Victor Chang | ce4bf3c | 2021-01-19 16:34:24 +0000 | [diff] [blame] | 244 | U_CAPI double U_EXPORT2 uprv_trunc(double d); |
Victor Chang | 7322950 | 2020-09-17 13:39:19 +0100 | [diff] [blame] | 245 | /** |
| 246 | * Floating point utility to calculate the floor of a double. |
| 247 | * @internal |
| 248 | */ |
Victor Chang | ce4bf3c | 2021-01-19 16:34:24 +0000 | [diff] [blame] | 249 | U_CAPI double U_EXPORT2 uprv_floor(double d); |
Victor Chang | 7322950 | 2020-09-17 13:39:19 +0100 | [diff] [blame] | 250 | /** |
| 251 | * Floating point utility to calculate the ceiling of a double. |
| 252 | * @internal |
| 253 | */ |
Victor Chang | ce4bf3c | 2021-01-19 16:34:24 +0000 | [diff] [blame] | 254 | U_CAPI double U_EXPORT2 uprv_ceil(double d); |
Victor Chang | 7322950 | 2020-09-17 13:39:19 +0100 | [diff] [blame] | 255 | /** |
| 256 | * Floating point utility to calculate the absolute value of a double. |
| 257 | * @internal |
| 258 | */ |
Victor Chang | ce4bf3c | 2021-01-19 16:34:24 +0000 | [diff] [blame] | 259 | U_CAPI double U_EXPORT2 uprv_fabs(double d); |
Victor Chang | 7322950 | 2020-09-17 13:39:19 +0100 | [diff] [blame] | 260 | /** |
| 261 | * Floating point utility to calculate the fractional and integer parts of a double. |
| 262 | * @internal |
| 263 | */ |
Victor Chang | ce4bf3c | 2021-01-19 16:34:24 +0000 | [diff] [blame] | 264 | U_CAPI double U_EXPORT2 uprv_modf(double d, double* pinteger); |
Victor Chang | 7322950 | 2020-09-17 13:39:19 +0100 | [diff] [blame] | 265 | /** |
| 266 | * Floating point utility to calculate the remainder of a double divided by another double. |
| 267 | * @internal |
| 268 | */ |
Victor Chang | ce4bf3c | 2021-01-19 16:34:24 +0000 | [diff] [blame] | 269 | U_CAPI double U_EXPORT2 uprv_fmod(double d, double y); |
Victor Chang | 7322950 | 2020-09-17 13:39:19 +0100 | [diff] [blame] | 270 | /** |
| 271 | * Floating point utility to calculate d to the power of exponent (d^exponent). |
| 272 | * @internal |
| 273 | */ |
Victor Chang | ce4bf3c | 2021-01-19 16:34:24 +0000 | [diff] [blame] | 274 | U_CAPI double U_EXPORT2 uprv_pow(double d, double exponent); |
Victor Chang | 7322950 | 2020-09-17 13:39:19 +0100 | [diff] [blame] | 275 | /** |
| 276 | * Floating point utility to calculate 10 to the power of exponent (10^exponent). |
| 277 | * @internal |
| 278 | */ |
Victor Chang | ce4bf3c | 2021-01-19 16:34:24 +0000 | [diff] [blame] | 279 | U_CAPI double U_EXPORT2 uprv_pow10(int32_t exponent); |
Victor Chang | 7322950 | 2020-09-17 13:39:19 +0100 | [diff] [blame] | 280 | /** |
| 281 | * Floating point utility to calculate the maximum value of two doubles. |
| 282 | * @internal |
| 283 | */ |
Victor Chang | ce4bf3c | 2021-01-19 16:34:24 +0000 | [diff] [blame] | 284 | U_CAPI double U_EXPORT2 uprv_fmax(double d, double y); |
Victor Chang | 7322950 | 2020-09-17 13:39:19 +0100 | [diff] [blame] | 285 | /** |
| 286 | * Floating point utility to calculate the minimum value of two doubles. |
| 287 | * @internal |
| 288 | */ |
Victor Chang | ce4bf3c | 2021-01-19 16:34:24 +0000 | [diff] [blame] | 289 | U_CAPI double U_EXPORT2 uprv_fmin(double d, double y); |
Victor Chang | 7322950 | 2020-09-17 13:39:19 +0100 | [diff] [blame] | 290 | /** |
| 291 | * Private utility to calculate the maximum value of two integers. |
| 292 | * @internal |
| 293 | */ |
Victor Chang | ce4bf3c | 2021-01-19 16:34:24 +0000 | [diff] [blame] | 294 | U_CAPI int32_t U_EXPORT2 uprv_max(int32_t d, int32_t y); |
Victor Chang | 7322950 | 2020-09-17 13:39:19 +0100 | [diff] [blame] | 295 | /** |
| 296 | * Private utility to calculate the minimum value of two integers. |
| 297 | * @internal |
| 298 | */ |
Victor Chang | ce4bf3c | 2021-01-19 16:34:24 +0000 | [diff] [blame] | 299 | U_CAPI int32_t U_EXPORT2 uprv_min(int32_t d, int32_t y); |
Victor Chang | 7322950 | 2020-09-17 13:39:19 +0100 | [diff] [blame] | 300 | |
| 301 | #if U_IS_BIG_ENDIAN |
| 302 | # define uprv_isNegative(number) (*((signed char *)&(number))<0) |
| 303 | #else |
| 304 | # define uprv_isNegative(number) (*((signed char *)&(number)+sizeof(number)-1)<0) |
| 305 | #endif |
| 306 | |
| 307 | /** |
| 308 | * Return the largest positive number that can be represented by an integer |
| 309 | * type of arbitrary bit length. |
| 310 | * @internal |
| 311 | */ |
Victor Chang | ce4bf3c | 2021-01-19 16:34:24 +0000 | [diff] [blame] | 312 | U_CAPI double U_EXPORT2 uprv_maxMantissa(void); |
Victor Chang | 7322950 | 2020-09-17 13:39:19 +0100 | [diff] [blame] | 313 | |
| 314 | /** |
| 315 | * Floating point utility to calculate the logarithm of a double. |
| 316 | * @internal |
| 317 | */ |
Victor Chang | ce4bf3c | 2021-01-19 16:34:24 +0000 | [diff] [blame] | 318 | U_CAPI double U_EXPORT2 uprv_log(double d); |
Victor Chang | 7322950 | 2020-09-17 13:39:19 +0100 | [diff] [blame] | 319 | |
| 320 | /** |
| 321 | * Does common notion of rounding e.g. uprv_floor(x + 0.5); |
| 322 | * @param x the double number |
| 323 | * @return the rounded double |
| 324 | * @internal |
| 325 | */ |
Victor Chang | ce4bf3c | 2021-01-19 16:34:24 +0000 | [diff] [blame] | 326 | U_CAPI double U_EXPORT2 uprv_round(double x); |
Victor Chang | 7322950 | 2020-09-17 13:39:19 +0100 | [diff] [blame] | 327 | |
| 328 | /** |
| 329 | * Adds the signed integers a and b, storing the result in res. |
| 330 | * Checks for signed integer overflow. |
| 331 | * Similar to the GCC/Clang extension __builtin_add_overflow |
| 332 | * |
| 333 | * @param a The first operand. |
| 334 | * @param b The second operand. |
| 335 | * @param res a + b |
| 336 | * @return true if overflow occurred; false if no overflow occurred. |
| 337 | * @internal |
| 338 | */ |
Victor Chang | ce4bf3c | 2021-01-19 16:34:24 +0000 | [diff] [blame] | 339 | U_CAPI UBool U_EXPORT2 uprv_add32_overflow(int32_t a, int32_t b, int32_t* res); |
Victor Chang | 7322950 | 2020-09-17 13:39:19 +0100 | [diff] [blame] | 340 | |
| 341 | /** |
| 342 | * Multiplies the signed integers a and b, storing the result in res. |
| 343 | * Checks for signed integer overflow. |
| 344 | * Similar to the GCC/Clang extension __builtin_mul_overflow |
| 345 | * |
| 346 | * @param a The first multiplicand. |
| 347 | * @param b The second multiplicand. |
| 348 | * @param res a * b |
| 349 | * @return true if overflow occurred; false if no overflow occurred. |
| 350 | * @internal |
| 351 | */ |
Victor Chang | ce4bf3c | 2021-01-19 16:34:24 +0000 | [diff] [blame] | 352 | U_CAPI UBool U_EXPORT2 uprv_mul32_overflow(int32_t a, int32_t b, int32_t* res); |
Victor Chang | 7322950 | 2020-09-17 13:39:19 +0100 | [diff] [blame] | 353 | |
| 354 | #if 0 |
| 355 | /** |
| 356 | * Returns the number of digits after the decimal point in a double number x. |
| 357 | * |
| 358 | * @param x the double number |
| 359 | * @return the number of digits after the decimal point in a double number x. |
| 360 | * @internal |
| 361 | */ |
Victor Chang | ce4bf3c | 2021-01-19 16:34:24 +0000 | [diff] [blame] | 362 | /*U_CAPI int32_t U_EXPORT2 uprv_digitsAfterDecimal(double x);*/ |
Victor Chang | 7322950 | 2020-09-17 13:39:19 +0100 | [diff] [blame] | 363 | #endif |
| 364 | |
| 365 | #if !U_CHARSET_IS_UTF8 |
| 366 | /** |
| 367 | * Please use ucnv_getDefaultName() instead. |
| 368 | * Return the default codepage for this platform and locale. |
| 369 | * This function can call setlocale() on Unix platforms. Please read the |
| 370 | * platform documentation on setlocale() before calling this function. |
Victor Chang | ce4bf3c | 2021-01-19 16:34:24 +0000 | [diff] [blame] | 371 | * @return the default codepage for this platform |
Victor Chang | 7322950 | 2020-09-17 13:39:19 +0100 | [diff] [blame] | 372 | * @internal |
| 373 | */ |
Victor Chang | ce4bf3c | 2021-01-19 16:34:24 +0000 | [diff] [blame] | 374 | U_CAPI const char* U_EXPORT2 uprv_getDefaultCodepage(void); |
Victor Chang | 7322950 | 2020-09-17 13:39:19 +0100 | [diff] [blame] | 375 | #endif |
| 376 | |
| 377 | /** |
| 378 | * Please use uloc_getDefault() instead. |
| 379 | * Return the default locale ID string by querying the system, or |
Victor Chang | ce4bf3c | 2021-01-19 16:34:24 +0000 | [diff] [blame] | 380 | * zero if one cannot be found. |
Victor Chang | 7322950 | 2020-09-17 13:39:19 +0100 | [diff] [blame] | 381 | * This function can call setlocale() on Unix platforms. Please read the |
| 382 | * platform documentation on setlocale() before calling this function. |
| 383 | * @return the default locale ID string |
| 384 | * @internal |
| 385 | */ |
Victor Chang | ce4bf3c | 2021-01-19 16:34:24 +0000 | [diff] [blame] | 386 | U_CAPI const char* U_EXPORT2 uprv_getDefaultLocaleID(void); |
Victor Chang | 7322950 | 2020-09-17 13:39:19 +0100 | [diff] [blame] | 387 | |
| 388 | /** |
| 389 | * Time zone utilities |
| 390 | * |
| 391 | * Wrappers for C runtime library functions relating to timezones. |
| 392 | * The t_tzset() function (similar to tzset) uses the current setting |
| 393 | * of the environment variable TZ to assign values to three global |
| 394 | * variables: daylight, timezone, and tzname. These variables have the |
| 395 | * following meanings, and are declared in <time.h>. |
| 396 | * |
| 397 | * daylight Nonzero if daylight-saving-time zone (DST) is specified |
| 398 | * in TZ; otherwise, 0. Default value is 1. |
| 399 | * timezone Difference in seconds between coordinated universal |
| 400 | * time and local time. E.g., -28,800 for PST (GMT-8hrs) |
| 401 | * tzname(0) Three-letter time-zone name derived from TZ environment |
| 402 | * variable. E.g., "PST". |
| 403 | * tzname(1) Three-letter DST zone name derived from TZ environment |
| 404 | * variable. E.g., "PDT". If DST zone is omitted from TZ, |
| 405 | * tzname(1) is an empty string. |
| 406 | * |
| 407 | * Notes: For example, to set the TZ environment variable to correspond |
| 408 | * to the current time zone in Germany, you can use one of the |
| 409 | * following statements: |
| 410 | * |
| 411 | * set TZ=GST1GDT |
| 412 | * set TZ=GST+1GDT |
| 413 | * |
| 414 | * If the TZ value is not set, t_tzset() attempts to use the time zone |
| 415 | * information specified by the operating system. Under Windows NT |
| 416 | * and Windows 95, this information is specified in the Control Panel's |
| 417 | * Date/Time application. |
| 418 | * @internal |
| 419 | */ |
Victor Chang | ce4bf3c | 2021-01-19 16:34:24 +0000 | [diff] [blame] | 420 | U_CAPI void U_EXPORT2 uprv_tzset(void); |
Victor Chang | 7322950 | 2020-09-17 13:39:19 +0100 | [diff] [blame] | 421 | |
| 422 | /** |
| 423 | * Difference in seconds between coordinated universal |
| 424 | * time and local time. E.g., -28,800 for PST (GMT-8hrs) |
| 425 | * @return the difference in seconds between coordinated universal time and local time. |
| 426 | * @internal |
| 427 | */ |
Victor Chang | ce4bf3c | 2021-01-19 16:34:24 +0000 | [diff] [blame] | 428 | U_CAPI int32_t U_EXPORT2 uprv_timezone(void); |
Victor Chang | 7322950 | 2020-09-17 13:39:19 +0100 | [diff] [blame] | 429 | |
| 430 | /** |
| 431 | * tzname(0) Three-letter time-zone name derived from TZ environment |
| 432 | * variable. E.g., "PST". |
| 433 | * tzname(1) Three-letter DST zone name derived from TZ environment |
| 434 | * variable. E.g., "PDT". If DST zone is omitted from TZ, |
| 435 | * tzname(1) is an empty string. |
| 436 | * @internal |
| 437 | */ |
Victor Chang | ce4bf3c | 2021-01-19 16:34:24 +0000 | [diff] [blame] | 438 | U_CAPI const char* U_EXPORT2 uprv_tzname(int n); |
Victor Chang | 7322950 | 2020-09-17 13:39:19 +0100 | [diff] [blame] | 439 | |
| 440 | /** |
| 441 | * Reset the global tzname cache. |
| 442 | * @internal |
| 443 | */ |
Victor Chang | ce4bf3c | 2021-01-19 16:34:24 +0000 | [diff] [blame] | 444 | U_CAPI void uprv_tzname_clear_cache(void); |
Victor Chang | 7322950 | 2020-09-17 13:39:19 +0100 | [diff] [blame] | 445 | |
| 446 | /** |
| 447 | * Get UTC (GMT) time measured in milliseconds since 0:00 on 1/1/1970. |
| 448 | * This function is affected by 'faketime' and should be the bottleneck for all user-visible ICU time functions. |
| 449 | * @return the UTC time measured in milliseconds |
| 450 | * @internal |
| 451 | */ |
Victor Chang | ce4bf3c | 2021-01-19 16:34:24 +0000 | [diff] [blame] | 452 | U_CAPI UDate U_EXPORT2 uprv_getUTCtime(void); |
Victor Chang | 7322950 | 2020-09-17 13:39:19 +0100 | [diff] [blame] | 453 | |
| 454 | /** |
| 455 | * Get UTC (GMT) time measured in milliseconds since 0:00 on 1/1/1970. |
| 456 | * This function is not affected by 'faketime', so it should only be used by low level test functions- not by anything that |
| 457 | * exposes time to the end user. |
| 458 | * @return the UTC time measured in milliseconds |
| 459 | * @internal |
| 460 | */ |
Victor Chang | ce4bf3c | 2021-01-19 16:34:24 +0000 | [diff] [blame] | 461 | U_CAPI UDate U_EXPORT2 uprv_getRawUTCtime(void); |
Victor Chang | 7322950 | 2020-09-17 13:39:19 +0100 | [diff] [blame] | 462 | |
| 463 | /** |
| 464 | * Determine whether a pathname is absolute or not, as defined by the platform. |
| 465 | * @param path Pathname to test |
Victor Chang | ce4bf3c | 2021-01-19 16:34:24 +0000 | [diff] [blame] | 466 | * @return true if the path is absolute |
Victor Chang | 7322950 | 2020-09-17 13:39:19 +0100 | [diff] [blame] | 467 | * @internal (ICU 3.0) |
| 468 | */ |
Victor Chang | ce4bf3c | 2021-01-19 16:34:24 +0000 | [diff] [blame] | 469 | U_CAPI UBool U_EXPORT2 uprv_pathIsAbsolute(const char *path); |
Victor Chang | 7322950 | 2020-09-17 13:39:19 +0100 | [diff] [blame] | 470 | |
| 471 | /** |
| 472 | * Use U_MAX_PTR instead of this function. |
| 473 | * @param void pointer to test |
| 474 | * @return the largest possible pointer greater than the base |
| 475 | * @internal (ICU 3.8) |
| 476 | */ |
Victor Chang | ce4bf3c | 2021-01-19 16:34:24 +0000 | [diff] [blame] | 477 | U_CAPI void * U_EXPORT2 uprv_maximumPtr(void *base); |
Victor Chang | 7322950 | 2020-09-17 13:39:19 +0100 | [diff] [blame] | 478 | |
| 479 | /** |
| 480 | * Maximum value of a (void*) - use to indicate the limit of an 'infinite' buffer. |
| 481 | * In fact, buffer sizes must not exceed 2GB so that the difference between |
| 482 | * the buffer limit and the buffer start can be expressed in an int32_t. |
| 483 | * |
| 484 | * The definition of U_MAX_PTR must fulfill the following conditions: |
| 485 | * - return the largest possible pointer greater than base |
| 486 | * - return a valid pointer according to the machine architecture (AS/400, 64-bit, etc.) |
| 487 | * - avoid wrapping around at high addresses |
| 488 | * - make sure that the returned pointer is not farther from base than 0x7fffffff bytes |
| 489 | * |
| 490 | * @param base The beginning of a buffer to find the maximum offset from |
| 491 | * @internal |
| 492 | */ |
| 493 | #ifndef U_MAX_PTR |
| 494 | # if U_PLATFORM == U_PF_OS390 && !defined(_LP64) |
| 495 | /* We have 31-bit pointers. */ |
| 496 | # define U_MAX_PTR(base) ((void *)0x7fffffff) |
| 497 | # elif U_PLATFORM == U_PF_OS400 |
| 498 | # define U_MAX_PTR(base) uprv_maximumPtr((void *)base) |
| 499 | # elif 0 |
| 500 | /* |
| 501 | * For platforms where pointers are scalar values (which is normal, but unlike i5/OS) |
| 502 | * but that do not define uintptr_t. |
| 503 | * |
| 504 | * However, this does not work on modern compilers: |
| 505 | * The C++ standard does not define pointer overflow, and allows compilers to |
| 506 | * assume that p+u>p for any pointer p and any integer u>0. |
| 507 | * Thus, modern compilers optimize away the ">" comparison. |
| 508 | * (See ICU tickets #7187 and #8096.) |
| 509 | */ |
| 510 | # define U_MAX_PTR(base) \ |
| 511 | ((void *)(((char *)(base)+0x7fffffffu) > (char *)(base) \ |
| 512 | ? ((char *)(base)+0x7fffffffu) \ |
| 513 | : (char *)-1)) |
| 514 | # else |
| 515 | /* Default version. C++ standard compliant for scalar pointers. */ |
| 516 | # define U_MAX_PTR(base) \ |
| 517 | ((void *)(((uintptr_t)(base)+0x7fffffffu) > (uintptr_t)(base) \ |
| 518 | ? ((uintptr_t)(base)+0x7fffffffu) \ |
| 519 | : (uintptr_t)-1)) |
| 520 | # endif |
| 521 | #endif |
| 522 | |
| 523 | |
| 524 | #ifdef __cplusplus |
| 525 | /** |
| 526 | * Pin a buffer capacity such that doing pointer arithmetic |
| 527 | * on the destination pointer and capacity cannot overflow. |
| 528 | * |
| 529 | * The pinned capacity must fulfill the following conditions (for positive capacities): |
| 530 | * - dest + capacity is a valid pointer according to the machine arcitecture (AS/400, 64-bit, etc.) |
| 531 | * - (dest + capacity) >= dest |
| 532 | * - The size (in bytes) of T[capacity] does not exceed 0x7fffffff |
| 533 | * |
| 534 | * @param dest the destination buffer pointer. |
| 535 | * @param capacity the requested buffer capacity, in units of type T. |
| 536 | * @return the pinned capacity. |
| 537 | * @internal |
| 538 | */ |
| 539 | template <typename T> |
| 540 | inline int32_t pinCapacity(T *dest, int32_t capacity) { |
| 541 | if (capacity <= 0) { return capacity; } |
| 542 | |
| 543 | uintptr_t destInt = (uintptr_t)dest; |
| 544 | uintptr_t maxInt; |
| 545 | |
| 546 | # if U_PLATFORM == U_PF_OS390 && !defined(_LP64) |
| 547 | // We have 31-bit pointers. |
| 548 | maxInt = 0x7fffffff; |
| 549 | # elif U_PLATFORM == U_PF_OS400 |
| 550 | maxInt = (uintptr_t)uprv_maximumPtr((void *)dest); |
| 551 | # else |
| 552 | maxInt = destInt + 0x7fffffffu; |
| 553 | if (maxInt < destInt) { |
| 554 | // Less than 2GB to the end of the address space. |
| 555 | // Pin to that to prevent address overflow. |
| 556 | maxInt = (uintptr_t)-1; |
| 557 | } |
| 558 | # endif |
| 559 | |
| 560 | uintptr_t maxBytes = maxInt - destInt; // max. 2GB |
| 561 | int32_t maxCapacity = (int32_t)(maxBytes / sizeof(T)); |
| 562 | return capacity <= maxCapacity ? capacity : maxCapacity; |
| 563 | } |
| 564 | #endif // __cplusplus |
| 565 | |
| 566 | /* Dynamic Library Functions */ |
| 567 | |
| 568 | typedef void (UVoidFunction)(void); |
| 569 | |
| 570 | #if U_ENABLE_DYLOAD |
| 571 | /** |
| 572 | * Load a library |
| 573 | * @internal (ICU 4.4) |
| 574 | */ |
Victor Chang | ce4bf3c | 2021-01-19 16:34:24 +0000 | [diff] [blame] | 575 | U_CAPI void * U_EXPORT2 uprv_dl_open(const char *libName, UErrorCode *status); |
Victor Chang | 7322950 | 2020-09-17 13:39:19 +0100 | [diff] [blame] | 576 | |
| 577 | /** |
| 578 | * Close a library |
| 579 | * @internal (ICU 4.4) |
| 580 | */ |
Victor Chang | ce4bf3c | 2021-01-19 16:34:24 +0000 | [diff] [blame] | 581 | U_CAPI void U_EXPORT2 uprv_dl_close( void *lib, UErrorCode *status); |
Victor Chang | 7322950 | 2020-09-17 13:39:19 +0100 | [diff] [blame] | 582 | |
| 583 | /** |
| 584 | * Extract a symbol from a library (function) |
| 585 | * @internal (ICU 4.8) |
| 586 | */ |
Victor Chang | ce4bf3c | 2021-01-19 16:34:24 +0000 | [diff] [blame] | 587 | U_CAPI UVoidFunction* U_EXPORT2 uprv_dlsym_func( void *lib, const char *symbolName, UErrorCode *status); |
Victor Chang | 7322950 | 2020-09-17 13:39:19 +0100 | [diff] [blame] | 588 | |
| 589 | /** |
| 590 | * Extract a symbol from a library (function) |
| 591 | * Not implemented, no clients. |
| 592 | * @internal |
| 593 | */ |
Victor Chang | ce4bf3c | 2021-01-19 16:34:24 +0000 | [diff] [blame] | 594 | /* U_CAPI void * U_EXPORT2 uprv_dlsym_data( void *lib, const char *symbolName, UErrorCode *status); */ |
Victor Chang | 7322950 | 2020-09-17 13:39:19 +0100 | [diff] [blame] | 595 | |
| 596 | #endif |
| 597 | |
| 598 | /** |
| 599 | * Define malloc and related functions |
| 600 | * @internal |
| 601 | */ |
| 602 | #if U_PLATFORM == U_PF_OS400 |
| 603 | # define uprv_default_malloc(x) _C_TS_malloc(x) |
| 604 | # define uprv_default_realloc(x,y) _C_TS_realloc(x,y) |
| 605 | # define uprv_default_free(x) _C_TS_free(x) |
| 606 | /* also _C_TS_calloc(x) */ |
| 607 | #else |
| 608 | /* C defaults */ |
| 609 | # define uprv_default_malloc(x) malloc(x) |
| 610 | # define uprv_default_realloc(x,y) realloc(x,y) |
| 611 | # define uprv_default_free(x) free(x) |
| 612 | #endif |
| 613 | |
| 614 | |
| 615 | #endif |