static Unicode UnicodeTrimInternal(ConstUnicode str, // IN UnicodeTrimSide side) // IN { Unicode trimmed; utf16_t *utf16; utf16_t *utf16Start; utf16_t *utf16End; ASSERT(str); utf16 = Unicode_GetAllocBytes(str, STRING_ENCODING_UTF16); utf16Start = utf16; utf16End = utf16 + Unicode_UTF16Strlen(utf16); if (side & UNICODE_TRIMLEFT) { while (utf16Start != utf16End && UnicodeSimpleIsWhiteSpace(*utf16Start)) { utf16Start++; } } if (side & UNICODE_TRIMRIGHT) { while (utf16End != utf16Start && UnicodeSimpleIsWhiteSpace(*(utf16End - 1))) { utf16End--; } } *utf16End = 0; trimmed = Unicode_AllocWithUTF16(utf16Start); free(utf16); return trimmed; }
char * VixToolsGetNextEnvVar(VixToolsEnvIterator *envItr) // IN { char *envVar; if (NULL == envItr) { return NULL; } #ifdef _WIN32 if (VIX_TOOLS_ENV_TYPE_ENV_BLOCK == envItr->envType) { if (L'\0' == envItr->data.eb.currEnvVar[0]) { envVar = NULL; } else { envVar = Unicode_AllocWithUTF16(envItr->data.eb.currEnvVar); while(*envItr->data.eb.currEnvVar++); } } else if (VIX_TOOLS_ENV_TYPE_ENVIRON == envItr->envType) { if (NULL == *envItr->data.environ) { envVar = NULL; } else { envVar = Unicode_AllocWithUTF16(*envItr->data.environ); envItr->data.environ++; } } else { /* Is someone using uninitialized memory? */ NOT_IMPLEMENTED(); } #else if (NULL == *envItr->environ) { envVar = NULL; } else { envVar = Unicode_Alloc(*envItr->environ, STRING_ENCODING_DEFAULT); envItr->environ++; } #endif return envVar; }
Unicode Unicode_FoldCase(ConstUnicode str) // IN { Unicode folded; utf16_t *utf16; utf16_t *utf16Current; ASSERT(str); utf16 = Unicode_GetAllocBytes(str, STRING_ENCODING_UTF16); utf16Current = utf16; while (*utf16Current) { *utf16Current = UnicodeSimpleCaseFold(*utf16Current); utf16Current++; } folded = Unicode_AllocWithUTF16(utf16); free(utf16); return folded; }
/* *---------------------------------------------------------------------- * * TimeUtil_GetLocalWindowsTimeZoneIndexAndName -- * * Determines the name and index for the computer's current time zone. The * name is always the name of the time zone in standard time, even if Daylight * Saving is currently in effect. This name is not localized, and is * intended to be used when Easy Installing a Vista or later guest. * * Results: * The index of the computer's current time zone. The name of the time zone * in standard time is returned in *ptzName. The caller is responsible for * freeing the returned string with free. * If an error occurs, returns -1 and sets *ptzName to NULL. * * Side effects: * On non-Win32 platforms, calls localtime_r() which sets globals * variables (e.g. 'timezone' and 'tzname' for Linux) * *---------------------------------------------------------------------- */ int TimeUtil_GetLocalWindowsTimeZoneIndexAndName(char **ptzName) // OUT: returning TZ Name { int utcStdOffMins = 0; int winTimeZoneIndex = (-1); const char *tzNameByUTCOffset = NULL; char *englishTzName = NULL; *ptzName = NULL; #if defined(_WIN32) { /* * Hosted products don't support XP hosts anymore, but we use * GetProcAddress instead of linking statically to * GetDynamicTimeZoneInformation to avoid impacting Tools and Cascadia, * which consume this lib and still need to run on XP. */ DYNAMIC_TIME_ZONE_INFORMATION tzInfo = {0}; typedef DWORD (WINAPI* PFNGetTZInfo)(PDYNAMIC_TIME_ZONE_INFORMATION); PFNGetTZInfo pfnGetTZInfo = NULL; pfnGetTZInfo = (PFNGetTZInfo) GetProcAddress(GetModuleHandleW(L"kernel32"), "GetDynamicTimeZoneInformation"); if (pfnGetTZInfo == NULL || pfnGetTZInfo(&tzInfo) == TIME_ZONE_ID_INVALID) { return (-1); } /* * Save the unlocalized time zone name. We use it below to look up the * time zone's index. */ englishTzName = Unicode_AllocWithUTF16(tzInfo.TimeZoneKeyName); /* 'Bias' = diff between UTC and local standard time */ utcStdOffMins = 0 - tzInfo.Bias; // already in minutes } #else // NOT _WIN32 { /* * Use localtime_r() to get offset between our local * time and UTC. This varies by platform. Also, the structure * fields are named "*gmt*" but the man pages claim offsets are * to UTC, not GMT. */ time_t now = time(NULL); struct tm tim; localtime_r(&now, &tim); #if defined(sun) /* * Offset is to standard (no need for DST adjustment). * Negative is east of prime meridian. */ utcStdOffMins = 0 - timezone/60; #else /* * FreeBSD, Apple, Linux only: * Offset is to local (need to adjust for DST). * Negative is west of prime meridian. */ utcStdOffMins = tim.tm_gmtoff/60; if (tim.tm_isdst) { utcStdOffMins -= 60; } #endif /* can't figure this out directly for non-Win32 */ winTimeZoneIndex = (-1); } #endif /* Look up the name and index in a table. */ winTimeZoneIndex = TimeUtilFindIndexAndName(utcStdOffMins, englishTzName, &tzNameByUTCOffset); if (winTimeZoneIndex >= 0) { *ptzName = Unicode_AllocWithUTF8(tzNameByUTCOffset); } free(englishTzName); englishTzName = NULL; return winTimeZoneIndex; }
/* *---------------------------------------------------------------------- * * TimeUtil_GetLocalWindowsTimeZoneIndexAndName -- * * Gets Windows TZ Index and Name for local time zone. * * Results: * -1 if there is any error, else the Windows Time Zone ID of the * current timezone (non-negative value). * * Side effects: * On non-Win32 platforms, calls localtime_r() which sets globals * variables (e.g. 'timezone' and 'tzname' for Linux) * *---------------------------------------------------------------------- */ int TimeUtil_GetLocalWindowsTimeZoneIndexAndName(char **ptzName) // OUT: returning TZ Name { int utcStdOffMins = 0; int winTimeZoneIndex = (-1); const char *tzNameByUTCOffset = NULL; *ptzName = NULL; #if defined(_WIN32) { TIME_ZONE_INFORMATION tz; if (GetTimeZoneInformation(&tz) == TIME_ZONE_ID_INVALID) { return (-1); } /* 'Bias' = diff between UTC and local standard time */ utcStdOffMins = 0 - tz.Bias; // already in minutes /* Find Windows TZ index */ *ptzName = Unicode_AllocWithUTF16(tz.StandardName); winTimeZoneIndex = Win32TimeUtilLookupZoneIndex(*ptzName); if (winTimeZoneIndex < 0) { Unicode_Free(*ptzName); *ptzName = NULL; } } #else // NOT _WIN32 { /* * Use localtime_r() to get offset between our local * time and UTC. This varies by platform. Also, the structure * fields are named "*gmt*" but the man pages claim offsets are * to UTC, not GMT. */ time_t now = time(NULL); struct tm tim; localtime_r(&now, &tim); #if defined(sun) /* * Offset is to standard (no need for DST adjustment). * Negative is east of prime meridian. */ utcStdOffMins = 0 - timezone/60; #else /* * FreeBSD, Apple, Linux only: * Offset is to local (need to adjust for DST). * Negative is west of prime meridian. */ utcStdOffMins = tim.tm_gmtoff/60; if (tim.tm_isdst) { utcStdOffMins -= 60; } #endif /* can't figure this out directly for non-Win32 */ winTimeZoneIndex = (-1); } #endif /* If we don't have it yet, look up windowsCode. */ if (winTimeZoneIndex < 0) { winTimeZoneIndex = TimeUtilFindIndexAndNameByUTCOffset(utcStdOffMins, &tzNameByUTCOffset); if (winTimeZoneIndex >= 0) { *ptzName = Unicode_AllocWithUTF8(tzNameByUTCOffset); } } return winTimeZoneIndex; }