// © 2016 and later: Unicode, Inc. and others. // License & terms of use: http://www.unicode.org/copyright.html /* ****************************************************************************** * * Copyright (C) 1997-2016, International Business Machines * Corporation and others. All Rights Reserved. * ****************************************************************************** * * FILE NAME : putil.c (previously putil.cpp and ptypes.cpp) * * Date Name Description * 04/14/97 aliu Creation. * 04/24/97 aliu Added getDefaultDataDirectory() and * getDefaultLocaleID(). * 04/28/97 aliu Rewritten to assume Unix and apply general methods * for assumed case. Non-UNIX platforms must be * special-cased. Rewrote numeric methods dealing * with NaN and Infinity to be platform independent * over all IEEE 754 platforms. * 05/13/97 aliu Restored sign of timezone * (semantics are hours West of GMT) * 06/16/98 erm Added IEEE_754 stuff, cleaned up isInfinite, isNan, * nextDouble.. * 07/22/98 stephen Added remainder, max, min, trunc * 08/13/98 stephen Added isNegativeInfinity, isPositiveInfinity * 08/24/98 stephen Added longBitsFromDouble * 09/08/98 stephen Minor changes for Mac Port * 03/02/99 stephen Removed openFile(). Added AS400 support. * Fixed EBCDIC tables * 04/15/99 stephen Converted to C. * 06/28/99 stephen Removed mutex locking in u_isBigEndian(). * 08/04/99 jeffrey R. Added OS/2 changes * 11/15/99 helena Integrated S/390 IEEE support. * 04/26/01 Barry N. OS/400 support for uprv_getDefaultLocaleID * 08/15/01 Steven H. OS/400 support for uprv_getDefaultCodepage * 01/03/08 Steven L. Fake Time Support ****************************************************************************** */ // Defines _XOPEN_SOURCE for access to POSIX functions. // Must be before any other #includes. #include "uposixdefs.h" // First, the platform type. Need this for U_PLATFORM. #include "unicode/platform.h" /* * Cygwin with GCC requires inclusion of time.h after the above disabling strict asci mode statement. */ #include <time.h> #if !U_PLATFORM_USES_ONLY_WIN32_API #include <sys/time.h> #endif /* include the rest of the ICU headers */ #include "unicode/putil.h" #include "unicode/ustring.h" #include "putilimp.h" #include "uassert.h" #include "umutex.h" #include "cmemory.h" #include "cstring.h" #include "locmap.h" #include "ucln_cmn.h" #include "charstr.h" /* Include standard headers. */ #include <stdio.h> #include <stdlib.h> #include <string.h> #include <math.h> #include <locale.h> #include <float.h> #ifndef U_COMMON_IMPLEMENTATION #error U_COMMON_IMPLEMENTATION not set - must be set for all ICU source files in common/ - see https://unicode-org.github.io/icu/userguide/howtouseicu #endif /* include system headers */ #if U_PLATFORM_USES_ONLY_WIN32_API /* * TODO: U_PLATFORM_USES_ONLY_WIN32_API includes MinGW. * Should Cygwin be included as well (U_PLATFORM_HAS_WIN32_API) * to use native APIs as much as possible? */ #ifndef WIN32_LEAN_AND_MEAN #define WIN32_LEAN_AND_MEAN #endif #define VC_EXTRALEAN #define NOUSER #define NOSERVICE #define NOIME #define NOMCX # include <windows.h> # include "unicode/uloc.h" # include "wintz.h" #elif U_PLATFORM == U_PF_OS400 # include <float.h> # include <qusec.h> /* error code structure */ # include <qusrjobi.h> # include <qliept.h> /* EPT_CALL macro - this include must be after all other "QSYSINCs" */ # include <mih/testptr.h> /* For uprv_maximumPtr */ #elif U_PLATFORM == U_PF_OS390 # include "unicode/ucnv.h" /* Needed for UCNV_SWAP_LFNL_OPTION_STRING */ #elif U_PLATFORM_IS_DARWIN_BASED || U_PLATFORM_IS_LINUX_BASED || U_PLATFORM == U_PF_BSD || U_PLATFORM == U_PF_SOLARIS # include <limits.h> # include <unistd.h> # if U_PLATFORM == U_PF_SOLARIS # ifndef _XPG4_2 #define _XPG4_2 # endif # elif U_PLATFORM == U_PF_ANDROID # include <sys/system_properties.h> # include <dlfcn.h> # endif #elif U_PLATFORM == U_PF_QNX # include <sys/neutrino.h> #endif /* * Only include langinfo.h if we have a way to get the codeset. If we later * depend on more feature, we can test on U_HAVE_NL_LANGINFO. * */ #if U_HAVE_NL_LANGINFO_CODESET #include <langinfo.h> #endif /** * Simple things (presence of functions, etc) should just go in configure.in and be added to * icucfg.h via autoheader. */ #if U_PLATFORM_IMPLEMENTS_POSIX # if U_PLATFORM == U_PF_OS400 #define HAVE_DLFCN_H … #define HAVE_DLOPEN … # else # ifndef HAVE_DLFCN_H #define HAVE_DLFCN_H … # endif # ifndef HAVE_DLOPEN #define HAVE_DLOPEN … # endif # endif # ifndef HAVE_GETTIMEOFDAY #define HAVE_GETTIMEOFDAY … # endif #else #define HAVE_DLFCN_H … #define HAVE_DLOPEN … #define HAVE_GETTIMEOFDAY … #endif U_NAMESPACE_USE /* Define the extension for data files, again... */ #define DATA_TYPE … /* Leave this copyright notice here! */ static const char copyright[] = …; /* floating point implementations ------------------------------------------- */ /* We return QNAN rather than SNAN*/ #define SIGN … /* Make it easy to define certain types of constants */ BitPatternConversion; static const BitPatternConversion gNan = …; static const BitPatternConversion gInf = …; /*--------------------------------------------------------------------------- Platform utilities Our general strategy is to assume we're on a POSIX platform. Platforms which are non-POSIX must declare themselves so. The default POSIX implementation will sometimes work for non-POSIX platforms as well (e.g., the NaN-related functions). ---------------------------------------------------------------------------*/ #if U_PLATFORM_USES_ONLY_WIN32_API || U_PLATFORM == U_PF_OS400 # undef U_POSIX_LOCALE #else #define U_POSIX_LOCALE … #endif /* WARNING! u_topNBytesOfDouble and u_bottomNBytesOfDouble can't be properly optimized by the gcc compiler sometimes (i.e. gcc 3.2). */ #if !IEEE_754 static char* u_topNBytesOfDouble(double* d, int n) { #if U_IS_BIG_ENDIAN return (char*)d; #else return (char*)(d + 1) - n; #endif } static char* u_bottomNBytesOfDouble(double* d, int n) { #if U_IS_BIG_ENDIAN return (char*)(d + 1) - n; #else return (char*)d; #endif } #endif /* !IEEE_754 */ #if IEEE_754 static UBool u_signBit(double d) { … } #endif #if defined (U_DEBUG_FAKETIME) /* Override the clock to test things without having to move the system clock. * Assumes POSIX gettimeofday() will function */ UDate fakeClock_t0 = 0; /** Time to start the clock from **/ UDate fakeClock_dt = 0; /** Offset (fake time - real time) **/ UBool fakeClock_set = false; /** True if fake clock has spun up **/ static UDate getUTCtime_real() { struct timeval posixTime; gettimeofday(&posixTime, nullptr); return (UDate)(((int64_t)posixTime.tv_sec * U_MILLIS_PER_SECOND) + (posixTime.tv_usec/1000)); } static UDate getUTCtime_fake() { static UMutex fakeClockMutex; umtx_lock(&fakeClockMutex); if(!fakeClock_set) { UDate real = getUTCtime_real(); const char *fake_start = getenv("U_FAKETIME_START"); if((fake_start!=nullptr) && (fake_start[0]!=0)) { sscanf(fake_start,"%lf",&fakeClock_t0); fakeClock_dt = fakeClock_t0 - real; fprintf(stderr,"U_DEBUG_FAKETIME was set at compile time, so the ICU clock will start at a preset value\n" "env variable U_FAKETIME_START=%.0f (%s) for an offset of %.0f ms from the current time %.0f\n", fakeClock_t0, fake_start, fakeClock_dt, real); } else { fakeClock_dt = 0; fprintf(stderr,"U_DEBUG_FAKETIME was set at compile time, but U_FAKETIME_START was not set.\n" "Set U_FAKETIME_START to the number of milliseconds since 1/1/1970 to set the ICU clock.\n"); } fakeClock_set = true; } umtx_unlock(&fakeClockMutex); return getUTCtime_real() + fakeClock_dt; } #endif #if U_PLATFORM_USES_ONLY_WIN32_API typedef union { int64_t int64; FILETIME fileTime; } FileTimeConversion; /* This is like a ULARGE_INTEGER */ /* Number of 100 nanoseconds from 1/1/1601 to 1/1/1970 */ #define EPOCH_BIAS … #define HECTONANOSECOND_PER_MILLISECOND … #endif /*--------------------------------------------------------------------------- Universal Implementations These are designed to work on all platforms. Try these, and if they don't work on your platform, then special case your platform with new implementations. ---------------------------------------------------------------------------*/ U_CAPI UDate U_EXPORT2 uprv_getUTCtime() { … } /* Return UTC (GMT) time measured in milliseconds since 0:00 on 1/1/70.*/ U_CAPI UDate U_EXPORT2 uprv_getRawUTCtime() { … } /*----------------------------------------------------------------------------- IEEE 754 These methods detect and return NaN and infinity values for doubles conforming to IEEE 754. Platforms which support this standard include X86, Mac 680x0, Mac PowerPC, AIX RS/6000, and most others. If this doesn't work on your platform, you have non-IEEE floating-point, and will need to code your own versions. A naive implementation is to return 0.0 for getNaN and getInfinity, and false for isNaN and isInfinite. ---------------------------------------------------------------------------*/ U_CAPI UBool U_EXPORT2 uprv_isNaN(double number) { … } U_CAPI UBool U_EXPORT2 uprv_isInfinite(double number) { … } U_CAPI UBool U_EXPORT2 uprv_isPositiveInfinity(double number) { … } U_CAPI UBool U_EXPORT2 uprv_isNegativeInfinity(double number) { … } U_CAPI double U_EXPORT2 uprv_getNaN() { … } U_CAPI double U_EXPORT2 uprv_getInfinity() { … } U_CAPI double U_EXPORT2 uprv_floor(double x) { … } U_CAPI double U_EXPORT2 uprv_ceil(double x) { … } U_CAPI double U_EXPORT2 uprv_round(double x) { … } U_CAPI double U_EXPORT2 uprv_fabs(double x) { … } U_CAPI double U_EXPORT2 uprv_modf(double x, double* y) { … } U_CAPI double U_EXPORT2 uprv_fmod(double x, double y) { … } U_CAPI double U_EXPORT2 uprv_pow(double x, double y) { … } U_CAPI double U_EXPORT2 uprv_pow10(int32_t x) { … } U_CAPI double U_EXPORT2 uprv_fmax(double x, double y) { … } U_CAPI double U_EXPORT2 uprv_fmin(double x, double y) { … } U_CAPI UBool U_EXPORT2 uprv_add32_overflow(int32_t a, int32_t b, int32_t* res) { … } U_CAPI UBool U_EXPORT2 uprv_mul32_overflow(int32_t a, int32_t b, int32_t* res) { … } /** * Truncates the given double. * trunc(3.3) = 3.0, trunc (-3.3) = -3.0 * This is different than calling floor() or ceil(): * floor(3.3) = 3, floor(-3.3) = -4 * ceil(3.3) = 4, ceil(-3.3) = -3 */ U_CAPI double U_EXPORT2 uprv_trunc(double d) { … } /** * Return the largest positive number that can be represented by an integer * type of arbitrary bit length. */ U_CAPI double U_EXPORT2 uprv_maxMantissa() { … } U_CAPI double U_EXPORT2 uprv_log(double d) { … } U_CAPI void * U_EXPORT2 uprv_maximumPtr(void * base) { … } /*--------------------------------------------------------------------------- Platform-specific Implementations Try these, and if they don't work on your platform, then special case your platform with new implementations. ---------------------------------------------------------------------------*/ /* Generic time zone layer -------------------------------------------------- */ /* Time zone utilities */ U_CAPI void U_EXPORT2 uprv_tzset() { … } U_CAPI int32_t U_EXPORT2 uprv_timezone() { … } /* Note that U_TZNAME does *not* have to be tzname, but if it is, some platforms need to have it declared here. */ #if defined(U_TZNAME) && (U_PLATFORM == U_PF_IRIX || U_PLATFORM_IS_DARWIN_BASED) /* RS6000 and others reject char **tzname. */ extern U_IMPORT char *U_TZNAME[]; #endif #if !UCONFIG_NO_FILE_IO && ((U_PLATFORM_IS_DARWIN_BASED && (U_PLATFORM != U_PF_IPHONE || defined(U_TIMEZONE))) || U_PLATFORM_IS_LINUX_BASED || U_PLATFORM == U_PF_BSD || U_PLATFORM == U_PF_SOLARIS) /* These platforms are likely to use Olson timezone IDs. */ /* common targets of the symbolic link at TZDEFAULT are: * "/usr/share/zoneinfo/<olsonID>" default, older Linux distros, macOS to 10.12 * "../usr/share/zoneinfo/<olsonID>" newer Linux distros: Red Hat Enterprise Linux 7, Ubuntu 16, SuSe Linux 12 * "/usr/share/lib/zoneinfo/<olsonID>" Solaris * "../usr/share/lib/zoneinfo/<olsonID>" Solaris * "/var/db/timezone/zoneinfo/<olsonID>" macOS 10.13 * To avoid checking lots of paths, just check that the target path * before the <olsonID> ends with "/zoneinfo/", and the <olsonID> is valid. */ #define CHECK_LOCALTIME_LINK … #if U_PLATFORM_IS_DARWIN_BASED #include <tzfile.h> #define TZZONEINFO … #elif U_PLATFORM == U_PF_SOLARIS #define TZDEFAULT … #define TZZONEINFO … #define TZ_ENV_CHECK … #else #define TZDEFAULT … #define TZZONEINFO … #endif #define TZZONEINFOTAIL … #if U_HAVE_DIRENT_H #define TZFILE_SKIP … /* Some Linux distributions have 'localtime' in /usr/share/zoneinfo symlinked to /etc/localtime, which makes searchForTZFile return 'localtime' when it's the first match. */ #define TZFILE_SKIP2 … #define SEARCH_TZFILE #include <dirent.h> /* Needed to search through system timezone files */ #endif static char gTimeZoneBuffer[PATH_MAX]; static const char *gTimeZoneBufferPtr = nullptr; #endif #if !U_PLATFORM_USES_ONLY_WIN32_API #define isNonDigit(ch) … #define isDigit(ch) … static UBool isValidOlsonID(const char *id) { … } /* On some Unix-like OS, 'posix' subdirectory in /usr/share/zoneinfo replicates the top-level contents. 'right' subdirectory has the same set of files, but individual files are different from those in the top-level directory or 'posix' because 'right' has files for TAI (Int'l Atomic Time) while 'posix' has files for UTC. When the first match for /etc/localtime is in either of them (usually in posix because 'right' has different file contents), or TZ environment variable points to one of them, createTimeZone fails because, say, 'posix/America/New_York' is not an Olson timezone id ('America/New_York' is). So, we have to skip 'posix/' and 'right/' at the beginning. */ static void skipZoneIDPrefix(const char** id) { … } #endif #if defined(U_TZNAME) && !U_PLATFORM_USES_ONLY_WIN32_API #define CONVERT_HOURS_TO_SECONDS(offset) … OffsetZoneMapping; enum { … }; /* This list tries to disambiguate a set of abbreviated timezone IDs and offsets and maps it to an Olson ID. Before adding anything to this list, take a look at icu/source/tools/tzcode/tz.alias Sometimes no daylight savings (0) is important to define due to aliases. This list can be tested with icu/source/test/compat/tzone.pl More values could be added to daylightType to increase precision. */ static const struct OffsetZoneMapping OFFSET_ZONE_MAPPINGS[] = …; /*#define DEBUG_TZNAME*/ static const char* remapShortTimeZone(const char *stdID, const char *dstID, int32_t daylightType, int32_t offset) { … } #endif #ifdef SEARCH_TZFILE #define MAX_READ_SIZE … typedef struct DefaultTZInfo { char* defaultTZBuffer; int64_t defaultTZFileSize; FILE* defaultTZFilePtr; UBool defaultTZstatus; int32_t defaultTZPosition; } DefaultTZInfo; /* * This method compares the two files given to see if they are a match. * It is currently use to compare two TZ files. */ static UBool compareBinaryFiles(const char* defaultTZFileName, const char* TZFileName, DefaultTZInfo* tzInfo) { FILE* file; int64_t sizeFile; int64_t sizeFileLeft; int32_t sizeFileRead; int32_t sizeFileToRead; char bufferFile[MAX_READ_SIZE]; UBool result = true; if (tzInfo->defaultTZFilePtr == nullptr) { tzInfo->defaultTZFilePtr = fopen(defaultTZFileName, "r"); } file = fopen(TZFileName, "r"); tzInfo->defaultTZPosition = 0; /* reset position to begin search */ if (file != nullptr && tzInfo->defaultTZFilePtr != nullptr) { /* First check that the file size are equal. */ if (tzInfo->defaultTZFileSize == 0) { fseek(tzInfo->defaultTZFilePtr, 0, SEEK_END); tzInfo->defaultTZFileSize = ftell(tzInfo->defaultTZFilePtr); } fseek(file, 0, SEEK_END); sizeFile = ftell(file); sizeFileLeft = sizeFile; if (sizeFile != tzInfo->defaultTZFileSize) { result = false; } else { /* Store the data from the files in separate buffers and * compare each byte to determine equality. */ if (tzInfo->defaultTZBuffer == nullptr) { rewind(tzInfo->defaultTZFilePtr); tzInfo->defaultTZBuffer = static_cast<char*>(uprv_malloc(sizeof(char) * tzInfo->defaultTZFileSize)); sizeFileRead = fread(tzInfo->defaultTZBuffer, 1, tzInfo->defaultTZFileSize, tzInfo->defaultTZFilePtr); } rewind(file); while(sizeFileLeft > 0) { uprv_memset(bufferFile, 0, MAX_READ_SIZE); sizeFileToRead = sizeFileLeft < MAX_READ_SIZE ? sizeFileLeft : MAX_READ_SIZE; sizeFileRead = fread(bufferFile, 1, sizeFileToRead, file); if (memcmp(tzInfo->defaultTZBuffer + tzInfo->defaultTZPosition, bufferFile, sizeFileRead) != 0) { result = false; break; } sizeFileLeft -= sizeFileRead; tzInfo->defaultTZPosition += sizeFileRead; } } } else { result = false; } if (file != nullptr) { fclose(file); } return result; } /* dirent also lists two entries: "." and ".." that we can safely ignore. */ #define SKIP1 … #define SKIP2 … static UBool U_CALLCONV putil_cleanup(); static CharString *gSearchTZFileResult = nullptr; /* * This method recursively traverses the directory given for a matching TZ file and returns the first match. * This function is not thread safe - it uses a global, gSearchTZFileResult, to hold its results. */ static char* searchForTZFile(const char* path, DefaultTZInfo* tzInfo) { DIR* dirp = nullptr; struct dirent* dirEntry = nullptr; char* result = nullptr; UErrorCode status = U_ZERO_ERROR; /* Save the current path */ CharString curpath(path, -1, status); if (U_FAILURE(status)) { goto cleanupAndReturn; } dirp = opendir(path); if (dirp == nullptr) { goto cleanupAndReturn; } if (gSearchTZFileResult == nullptr) { gSearchTZFileResult = new CharString; if (gSearchTZFileResult == nullptr) { goto cleanupAndReturn; } ucln_common_registerCleanup(UCLN_COMMON_PUTIL, putil_cleanup); } /* Check each entry in the directory. */ while((dirEntry = readdir(dirp)) != nullptr) { const char* dirName = dirEntry->d_name; if (uprv_strcmp(dirName, SKIP1) != 0 && uprv_strcmp(dirName, SKIP2) != 0 && uprv_strcmp(TZFILE_SKIP, dirName) != 0 && uprv_strcmp(TZFILE_SKIP2, dirName) != 0) { /* Create a newpath with the new entry to test each entry in the directory. */ CharString newpath(curpath, status); newpath.append(dirName, -1, status); if (U_FAILURE(status)) { break; } DIR* subDirp = nullptr; if ((subDirp = opendir(newpath.data())) != nullptr) { /* If this new path is a directory, make a recursive call with the newpath. */ closedir(subDirp); newpath.append('/', status); if (U_FAILURE(status)) { break; } result = searchForTZFile(newpath.data(), tzInfo); /* Have to get out here. Otherwise, we'd keep looking and return the first match in the top-level directory if there's a match in the top-level. If not, this function would return nullptr and set gTimeZoneBufferPtr to nullptr in initDefault(). It worked without this in most cases because we have a fallback of calling localtime_r to figure out the default timezone. */ if (result != nullptr) break; } else { if(compareBinaryFiles(TZDEFAULT, newpath.data(), tzInfo)) { int32_t amountToSkip = sizeof(TZZONEINFO) - 1; if (amountToSkip > newpath.length()) { amountToSkip = newpath.length(); } const char* zoneid = newpath.data() + amountToSkip; skipZoneIDPrefix(&zoneid); gSearchTZFileResult->clear(); gSearchTZFileResult->append(zoneid, -1, status); if (U_FAILURE(status)) { break; } result = gSearchTZFileResult->data(); /* Get out after the first one found. */ break; } } } } cleanupAndReturn: if (dirp) { closedir(dirp); } return result; } #endif #if U_PLATFORM == U_PF_ANDROID typedef int(system_property_read_callback)(const prop_info* info, void (*callback)(void* cookie, const char* name, const char* value, uint32_t serial), void* cookie); typedef int(system_property_get)(const char*, char*); static char gAndroidTimeZone[PROP_VALUE_MAX] = { '\0' }; static void u_property_read(void* cookie, const char* name, const char* value, uint32_t serial) { uprv_strcpy((char* )cookie, value); } #endif U_CAPI void U_EXPORT2 uprv_tzname_clear_cache() { … } U_CAPI const char* U_EXPORT2 uprv_tzname(int n) { … } /* Get and set the ICU data directory --------------------------------------- */ static icu::UInitOnce gDataDirInitOnce { … }; static char *gDataDirectory = …; struct icu_76_godot::UInitOnce gTimeZoneFilesInitOnce {}; static CharString *gTimeZoneFilesDirectory = …; #if U_POSIX_LOCALE || U_PLATFORM_USES_ONLY_WIN32_API static const char *gCorrectedPOSIXLocale = …; /* Sometimes heap allocated */ static bool gCorrectedPOSIXLocaleHeapAllocated = …; #endif static UBool U_CALLCONV putil_cleanup() { … } /* * Set the data directory. * Make a copy of the passed string, and set the global data dir to point to it. */ U_CAPI void U_EXPORT2 u_setDataDirectory(const char *directory) { … } U_CAPI UBool U_EXPORT2 uprv_pathIsAbsolute(const char *path) { … } /* Backup setting of ICU_DATA_DIR_PREFIX_ENV_VAR (needed for some Darwin ICU build environments) */ #if U_PLATFORM_IS_DARWIN_BASED && defined(TARGET_OS_SIMULATOR) && TARGET_OS_SIMULATOR # if !defined(ICU_DATA_DIR_PREFIX_ENV_VAR) #define ICU_DATA_DIR_PREFIX_ENV_VAR … # endif #endif #if defined(ICU_DATA_DIR_WINDOWS) // Helper function to get the ICU Data Directory under the Windows directory location. static BOOL U_CALLCONV getIcuDataDirectoryUnderWindowsDirectory(char* directoryBuffer, UINT bufferLength) { wchar_t windowsPath[MAX_PATH]; char windowsPathUtf8[MAX_PATH]; UINT length = GetSystemWindowsDirectoryW(windowsPath, UPRV_LENGTHOF(windowsPath)); if ((length > 0) && (length < (UPRV_LENGTHOF(windowsPath) - 1))) { // Convert UTF-16 to a UTF-8 string. UErrorCode status = U_ZERO_ERROR; int32_t windowsPathUtf8Len = 0; u_strToUTF8(windowsPathUtf8, static_cast<int32_t>(UPRV_LENGTHOF(windowsPathUtf8)), &windowsPathUtf8Len, reinterpret_cast<const char16_t*>(windowsPath), -1, &status); if (U_SUCCESS(status) && (status != U_STRING_NOT_TERMINATED_WARNING) && (windowsPathUtf8Len < (UPRV_LENGTHOF(windowsPathUtf8) - 1))) { // Ensure it always has a separator, so we can append the ICU data path. if (windowsPathUtf8[windowsPathUtf8Len - 1] != U_FILE_SEP_CHAR) { windowsPathUtf8[windowsPathUtf8Len++] = U_FILE_SEP_CHAR; windowsPathUtf8[windowsPathUtf8Len] = '\0'; } // Check if the concatenated string will fit. if ((windowsPathUtf8Len + UPRV_LENGTHOF(ICU_DATA_DIR_WINDOWS)) < bufferLength) { uprv_strcpy(directoryBuffer, windowsPathUtf8); uprv_strcat(directoryBuffer, ICU_DATA_DIR_WINDOWS); return true; } } } return false; } #endif static void U_CALLCONV dataDirectoryInitFn() { … } U_CAPI const char * U_EXPORT2 u_getDataDirectory() { … } static void setTimeZoneFilesDir(const char *path, UErrorCode &status) { … } #define TO_STRING(x) … #define TO_STRING_2(x) … static void U_CALLCONV TimeZoneDataDirInitFn(UErrorCode &status) { … } U_CAPI const char * U_EXPORT2 u_getTimeZoneFilesDirectory(UErrorCode *status) { … } U_CAPI void U_EXPORT2 u_setTimeZoneFilesDirectory(const char *path, UErrorCode *status) { … } #if U_POSIX_LOCALE /* A helper function used by uprv_getPOSIXIDForDefaultLocale and * uprv_getPOSIXIDForDefaultCodepage. Returns the posix locale id for * LC_CTYPE and LC_MESSAGES. It doesn't support other locale categories. */ static const char *uprv_getPOSIXIDForCategory(int category) { … } /* Return just the POSIX id for the default locale, whatever happens to be in * it. It gets the value from LC_MESSAGES and indirectly from LC_ALL and LANG. */ static const char *uprv_getPOSIXIDForDefaultLocale() { … } #if !U_CHARSET_IS_UTF8 /* Return just the POSIX id for the default codepage, whatever happens to be in * it. It gets the value from LC_CTYPE and indirectly from LC_ALL and LANG. */ static const char *uprv_getPOSIXIDForDefaultCodepage() { static const char* posixID = nullptr; if (posixID == 0) { posixID = uprv_getPOSIXIDForCategory(LC_CTYPE); } return posixID; } #endif #endif /* NOTE: The caller should handle thread safety */ U_CAPI const char* U_EXPORT2 uprv_getDefaultLocaleID() { … } #if !U_CHARSET_IS_UTF8 #if U_POSIX_LOCALE /* Due to various platform differences, one platform may specify a charset, when they really mean a different charset. Remap the names so that they are compatible with ICU. Only conflicting/ambiguous aliases should be resolved here. Before adding anything to this function, please consider adding unique names to the ICU alias table in the data directory. */ static const char* remapPlatformDependentCodepage(const char *locale, const char *name) { if (locale != nullptr && *locale == 0) { /* Make sure that an empty locale is handled the same way. */ locale = nullptr; } if (name == nullptr) { return nullptr; } #if U_PLATFORM == U_PF_AIX if (uprv_strcmp(name, "IBM-943") == 0) { /* Use the ASCII compatible ibm-943 */ name = "Shift-JIS"; } else if (uprv_strcmp(name, "IBM-1252") == 0) { /* Use the windows-1252 that contains the Euro */ name = "IBM-5348"; } #elif U_PLATFORM == U_PF_SOLARIS if (locale != nullptr && uprv_strcmp(name, "EUC") == 0) { /* Solaris underspecifies the "EUC" name. */ if (uprv_strcmp(locale, "zh_CN") == 0) { name = "EUC-CN"; } else if (uprv_strcmp(locale, "zh_TW") == 0) { name = "EUC-TW"; } else if (uprv_strcmp(locale, "ko_KR") == 0) { name = "EUC-KR"; } } else if (uprv_strcmp(name, "eucJP") == 0) { /* ibm-954 is the best match. ibm-33722 is the default for eucJP (similar to Windows). */ name = "eucjis"; } else if (uprv_strcmp(name, "646") == 0) { /* * The default codepage given by Solaris is 646 but the C library routines treat it as if it was * ISO-8859-1 instead of US-ASCII(646). */ name = "ISO-8859-1"; } #elif U_PLATFORM_IS_DARWIN_BASED if (locale == nullptr && *name == 0) { /* No locale was specified, and an empty name was passed in. This usually indicates that nl_langinfo didn't return valid information. Mac OS X uses UTF-8 by default (especially the locale data and console). */ name = "UTF-8"; } else if (uprv_strcmp(name, "CP949") == 0) { /* Remap CP949 to a similar codepage to avoid issues with backslash and won symbol. */ name = "EUC-KR"; } else if (locale != nullptr && uprv_strcmp(locale, "en_US_POSIX") != 0 && uprv_strcmp(name, "US-ASCII") == 0) { /* * For non C/POSIX locale, default the code page to UTF-8 instead of US-ASCII. */ name = "UTF-8"; } #elif U_PLATFORM == U_PF_BSD if (uprv_strcmp(name, "CP949") == 0) { /* Remap CP949 to a similar codepage to avoid issues with backslash and won symbol. */ name = "EUC-KR"; } #elif U_PLATFORM == U_PF_HPUX if (locale != nullptr && uprv_strcmp(locale, "zh_HK") == 0 && uprv_strcmp(name, "big5") == 0) { /* HP decided to extend big5 as hkbig5 even though it's not compatible :-( */ /* zh_TW.big5 is not the same charset as zh_HK.big5! */ name = "hkbig5"; } else if (uprv_strcmp(name, "eucJP") == 0) { /* ibm-1350 is the best match, but unavailable. ibm-954 is mostly a superset of ibm-1350. ibm-33722 is the default for eucJP (similar to Windows). */ name = "eucjis"; } #elif U_PLATFORM == U_PF_LINUX if (locale != nullptr && uprv_strcmp(name, "euc") == 0) { /* Linux underspecifies the "EUC" name. */ if (uprv_strcmp(locale, "korean") == 0) { name = "EUC-KR"; } else if (uprv_strcmp(locale, "japanese") == 0) { /* See comment below about eucJP */ name = "eucjis"; } } else if (uprv_strcmp(name, "eucjp") == 0) { /* ibm-1350 is the best match, but unavailable. ibm-954 is mostly a superset of ibm-1350. ibm-33722 is the default for eucJP (similar to Windows). */ name = "eucjis"; } else if (locale != nullptr && uprv_strcmp(locale, "en_US_POSIX") != 0 && (uprv_strcmp(name, "ANSI_X3.4-1968") == 0 || uprv_strcmp(name, "US-ASCII") == 0)) { /* * For non C/POSIX locale, default the code page to UTF-8 instead of US-ASCII. */ name = "UTF-8"; } /* * Linux returns ANSI_X3.4-1968 for C/POSIX, but the call site takes care of * it by falling back to 'US-ASCII' when nullptr is returned from this * function. So, we don't have to worry about it here. */ #endif /* return nullptr when "" is passed in */ if (*name == 0) { name = nullptr; } return name; } static const char* getCodepageFromPOSIXID(const char *localeName, char * buffer, int32_t buffCapacity) { char localeBuf[100]; const char *name = nullptr; char *variant = nullptr; if (localeName != nullptr && (name = (uprv_strchr(localeName, '.'))) != nullptr) { size_t localeCapacity = uprv_min(sizeof(localeBuf), (name-localeName)+1); uprv_strncpy(localeBuf, localeName, localeCapacity); localeBuf[localeCapacity-1] = 0; /* ensure NUL termination */ name = uprv_strncpy(buffer, name+1, buffCapacity); buffer[buffCapacity-1] = 0; /* ensure NUL termination */ if ((variant = const_cast<char *>(uprv_strchr(name, '@'))) != nullptr) { *variant = 0; } name = remapPlatformDependentCodepage(localeBuf, name); } return name; } #endif static const char* int_getDefaultCodepage() { #if U_PLATFORM == U_PF_OS400 uint32_t ccsid = 37; /* Default to ibm-37 */ static char codepage[64]; Qwc_JOBI0400_t jobinfo; Qus_EC_t error = { sizeof(Qus_EC_t) }; /* SPI error code */ EPT_CALL(QUSRJOBI)(&jobinfo, sizeof(jobinfo), "JOBI0400", "* ", " ", &error); if (error.Bytes_Available == 0) { if (jobinfo.Coded_Char_Set_ID != 0xFFFF) { ccsid = (uint32_t)jobinfo.Coded_Char_Set_ID; } else if (jobinfo.Default_Coded_Char_Set_Id != 0xFFFF) { ccsid = (uint32_t)jobinfo.Default_Coded_Char_Set_Id; } /* else use the default */ } snprintf(codepage, sizeof(codepage), "ibm-%d", ccsid); return codepage; #elif U_PLATFORM == U_PF_OS390 static char codepage[64]; strncpy(codepage, nl_langinfo(CODESET),63-strlen(UCNV_SWAP_LFNL_OPTION_STRING)); strcat(codepage,UCNV_SWAP_LFNL_OPTION_STRING); codepage[63] = 0; /* NUL terminate */ return codepage; #elif U_PLATFORM_USES_ONLY_WIN32_API static char codepage[64]; DWORD codepageNumber = 0; #if U_PLATFORM_HAS_WINUWP_API == 1 // UWP doesn't have a direct API to get the default ACP as Microsoft would rather // have folks use Unicode than a "system" code page, however this is the same // codepage as the system default locale codepage. (FWIW, the system locale is // ONLY used for codepage, it should never be used for anything else) GetLocaleInfoEx(LOCALE_NAME_SYSTEM_DEFAULT, LOCALE_IDEFAULTANSICODEPAGE | LOCALE_RETURN_NUMBER, (LPWSTR)&codepageNumber, sizeof(codepageNumber) / sizeof(WCHAR)); #else // Win32 apps can call GetACP codepageNumber = GetACP(); #endif // Special case for UTF-8 if (codepageNumber == 65001) { return "UTF-8"; } // Windows codepages can look like windows-1252, so format the found number // the numbers are eclectic, however all valid system code pages, besides UTF-8 // are between 3 and 19999 if (codepageNumber > 0 && codepageNumber < 20000) { snprintf(codepage, sizeof(codepage), "windows-%ld", codepageNumber); return codepage; } // If the codepage number call failed then return UTF-8 return "UTF-8"; #elif U_POSIX_LOCALE static char codesetName[100]; const char *localeName = nullptr; const char *name = nullptr; localeName = uprv_getPOSIXIDForDefaultCodepage(); uprv_memset(codesetName, 0, sizeof(codesetName)); /* On Solaris nl_langinfo returns C locale values unless setlocale * was called earlier. */ #if (U_HAVE_NL_LANGINFO_CODESET && U_PLATFORM != U_PF_SOLARIS) /* When available, check nl_langinfo first because it usually gives more useful names. It depends on LC_CTYPE. nl_langinfo may use the same buffer as setlocale. */ { const char *codeset = nl_langinfo(U_NL_LANGINFO_CODESET); #if U_PLATFORM_IS_DARWIN_BASED || U_PLATFORM_IS_LINUX_BASED /* * On Linux and MacOSX, ensure that default codepage for non C/POSIX locale is UTF-8 * instead of ASCII. */ if (uprv_strcmp(localeName, "en_US_POSIX") != 0) { codeset = remapPlatformDependentCodepage(localeName, codeset); } else #endif { codeset = remapPlatformDependentCodepage(nullptr, codeset); } if (codeset != nullptr) { uprv_strncpy(codesetName, codeset, sizeof(codesetName)); codesetName[sizeof(codesetName)-1] = 0; return codesetName; } } #endif /* Use setlocale in a nice way, and then check some environment variables. Maybe the application used setlocale already. */ uprv_memset(codesetName, 0, sizeof(codesetName)); name = getCodepageFromPOSIXID(localeName, codesetName, sizeof(codesetName)); if (name) { /* if we can find the codeset name from setlocale, return that. */ return name; } if (*codesetName == 0) { /* Everything failed. Return US ASCII (ISO 646). */ (void)uprv_strcpy(codesetName, "US-ASCII"); } return codesetName; #else return "US-ASCII"; #endif } U_CAPI const char* U_EXPORT2 uprv_getDefaultCodepage() { static char const *name = nullptr; umtx_lock(nullptr); if (name == nullptr) { name = int_getDefaultCodepage(); } umtx_unlock(nullptr); return name; } #endif /* !U_CHARSET_IS_UTF8 */ /* end of platform-specific implementation -------------- */ /* version handling --------------------------------------------------------- */ U_CAPI void U_EXPORT2 u_versionFromString(UVersionInfo versionArray, const char *versionString) { … } U_CAPI void U_EXPORT2 u_versionFromUString(UVersionInfo versionArray, const char16_t *versionString) { … } U_CAPI void U_EXPORT2 u_versionToString(const UVersionInfo versionArray, char *versionString) { … } U_CAPI void U_EXPORT2 u_getVersion(UVersionInfo versionArray) { … } /** * icucfg.h dependent code */ #if U_ENABLE_DYLOAD && HAVE_DLOPEN && !U_PLATFORM_USES_ONLY_WIN32_API #if HAVE_DLFCN_H #ifdef __MVS__ #ifndef __SUSV3 #define __SUSV3 … #endif #endif #include <dlfcn.h> #endif /* HAVE_DLFCN_H */ U_CAPI void * U_EXPORT2 uprv_dl_open(const char *libName, UErrorCode *status) { void *ret = nullptr; if(U_FAILURE(*status)) return ret; ret = dlopen(libName, RTLD_NOW|RTLD_GLOBAL); if(ret==nullptr) { #ifdef U_TRACE_DYLOAD printf("dlerror on dlopen(%s): %s\n", libName, dlerror()); #endif *status = U_MISSING_RESOURCE_ERROR; } return ret; } U_CAPI void U_EXPORT2 uprv_dl_close(void *lib, UErrorCode *status) { if(U_FAILURE(*status)) return; dlclose(lib); } U_CAPI UVoidFunction* U_EXPORT2 uprv_dlsym_func(void *lib, const char* sym, UErrorCode *status) { union { UVoidFunction *fp; void *vp; } uret; uret.fp = nullptr; if(U_FAILURE(*status)) return uret.fp; uret.vp = dlsym(lib, sym); if(uret.vp == nullptr) { #ifdef U_TRACE_DYLOAD printf("dlerror on dlsym(%p,%s): %s\n", lib,sym, dlerror()); #endif *status = U_MISSING_RESOURCE_ERROR; } return uret.fp; } #elif U_ENABLE_DYLOAD && U_PLATFORM_USES_ONLY_WIN32_API && !U_PLATFORM_HAS_WINUWP_API /* Windows API implementation. */ // Note: UWP does not expose/allow these APIs, so the UWP version gets the null implementation. */ U_CAPI void * U_EXPORT2 uprv_dl_open(const char *libName, UErrorCode *status) { HMODULE lib = nullptr; if(U_FAILURE(*status)) return nullptr; lib = LoadLibraryA(libName); if(lib==nullptr) { *status = U_MISSING_RESOURCE_ERROR; } return (void*)lib; } U_CAPI void U_EXPORT2 uprv_dl_close(void *lib, UErrorCode *status) { HMODULE handle = (HMODULE)lib; if(U_FAILURE(*status)) return; FreeLibrary(handle); return; } U_CAPI UVoidFunction* U_EXPORT2 uprv_dlsym_func(void *lib, const char* sym, UErrorCode *status) { HMODULE handle = (HMODULE)lib; UVoidFunction* addr = nullptr; if(U_FAILURE(*status) || lib==nullptr) return nullptr; addr = (UVoidFunction*)GetProcAddress(handle, sym); if(addr==nullptr) { DWORD lastError = GetLastError(); if(lastError == ERROR_PROC_NOT_FOUND) { *status = U_MISSING_RESOURCE_ERROR; } else { *status = U_UNSUPPORTED_ERROR; /* other unknown error. */ } } return addr; } #else /* No dynamic loading, null (nonexistent) implementation. */ U_CAPI void * U_EXPORT2 uprv_dl_open(const char *libName, UErrorCode *status) { … } U_CAPI void U_EXPORT2 uprv_dl_close(void *lib, UErrorCode *status) { … } U_CAPI UVoidFunction* U_EXPORT2 uprv_dlsym_func(void *lib, const char* sym, UErrorCode *status) { … } #endif /* * Hey, Emacs, please set the following: * * Local Variables: * indent-tabs-mode: nil * End: * */
Codebase Browser
godot