Remove use of icu::Locale C++ type

Remove all the uses of the icu::Locale type in favor of just using a
char* which is the raw locale id (which is exactly what all the ICU C
apis use for a locale).

The meat of this change si in locale.cpp to actually handle doing the
conversion from UChar* to char*.  The rest of the places are dealing
with the fallout (GetLocale now has a different signiture and the
.getName() dance is no longer needed as we have a raw locale name all
the time now).

Author: ellismg

src/corefx/System.Globalization.Native/calendarData.cpp

@@ -209,12 +209,14 @@ Returns the list of CalendarIds that are available for the specified locale.
 */
 extern "C" int32_t GetCalendars(const UChar* localeName, CalendarId* calendars, int32_t calendarsCapacity)
 {
-    Locale locale = GetLocale(localeName);
-    if (locale.isBogus())
+    UErrorCode err = U_ZERO_ERROR;
+    char locale[ULOC_FULLNAME_CAPACITY];
+    GetLocale(localeName, locale, ULOC_FULLNAME_CAPACITY, false, &err);
+
+    if (U_FAILURE(err))
         return 0;
 
-    UErrorCode err = U_ZERO_ERROR;
-    UEnumeration* pEnum = ucal_getKeywordValuesForLocale("calendar", locale.getName(), TRUE, &err);
+    UEnumeration* pEnum = ucal_getKeywordValuesForLocale("calendar", locale, TRUE, &err);
     UEnumerationHolder enumHolder(pEnum, err);
 
     if (U_FAILURE(err))
@@ -291,16 +293,19 @@ with the requested value.
 extern "C" CalendarDataResult GetCalendarInfo(
     const UChar* localeName, CalendarId calendarId, CalendarDataType dataType, UChar* result, int32_t resultCapacity)
 {
-    Locale locale = GetLocale(localeName);
-    if (locale.isBogus())
+    UErrorCode err = U_ZERO_ERROR;
+    char locale[ULOC_FULLNAME_CAPACITY];
+    GetLocale(localeName, locale, ULOC_FULLNAME_CAPACITY, false, &err);
+
+    if (U_FAILURE(err))
         return UnknownError;
 
     switch (dataType)
     {
         case NativeName:
-            return GetNativeCalendarName(locale.getName(), calendarId, result, resultCapacity);
+            return GetNativeCalendarName(locale, calendarId, result, resultCapacity);
         case MonthDay:
-            return GetMonthDayPattern(locale.getName(), result, resultCapacity);
+            return GetMonthDayPattern(locale, result, resultCapacity);
         default:
             assert(false);
             return UnknownError;
@@ -557,8 +562,11 @@ extern "C" int32_t EnumCalendarInfo(EnumCalendarInfoCallback callback,
                                     CalendarDataType dataType,
                                     const void* context)
 {
-    Locale locale = GetLocale(localeName);
-    if (locale.isBogus())
+    UErrorCode err = U_ZERO_ERROR;
+    char locale[ULOC_FULLNAME_CAPACITY];
+    GetLocale(localeName, locale, ULOC_FULLNAME_CAPACITY, false, &err);
+
+    if (U_FAILURE(err))
         return false;
 
     switch (dataType)
@@ -567,38 +575,37 @@ extern "C" int32_t EnumCalendarInfo(EnumCalendarInfoCallback callback,
             // ShortDates to map kShort and kMedium in ICU, but also adding the "yMd"
             // skeleton as well, as this
             // closely matches what is used on Windows
-            return InvokeCallbackForDateTimePattern(
-                       locale.getName(), UDAT_YEAR_NUM_MONTH_DAY_UCHAR, callback, context) &&
-                   InvokeCallbackForDatePattern(locale.getName(), UDAT_SHORT, callback, context) &&
-                   InvokeCallbackForDatePattern(locale.getName(), UDAT_MEDIUM, callback, context);
+            return InvokeCallbackForDateTimePattern(locale, UDAT_YEAR_NUM_MONTH_DAY_UCHAR, callback, context) &&
+                   InvokeCallbackForDatePattern(locale, UDAT_SHORT, callback, context) &&
+                   InvokeCallbackForDatePattern(locale, UDAT_MEDIUM, callback, context);
         case LongDates:
             // LongDates map to kFull and kLong in ICU.
-            return InvokeCallbackForDatePattern(locale.getName(), UDAT_FULL, callback, context) &&
-                   InvokeCallbackForDatePattern(locale.getName(), UDAT_LONG, callback, context);
+            return InvokeCallbackForDatePattern(locale, UDAT_FULL, callback, context) &&
+                   InvokeCallbackForDatePattern(locale, UDAT_LONG, callback, context);
         case YearMonths:
-            return InvokeCallbackForDateTimePattern(locale.getName(), UDAT_YEAR_MONTH_UCHAR, callback, context);
+            return InvokeCallbackForDateTimePattern(locale, UDAT_YEAR_MONTH_UCHAR, callback, context);
         case DayNames:
-            return EnumSymbols(locale.getName(), calendarId, UDAT_STANDALONE_WEEKDAYS, 1, callback, context);
+            return EnumSymbols(locale, calendarId, UDAT_STANDALONE_WEEKDAYS, 1, callback, context);
         case AbbrevDayNames:
-            return EnumSymbols(locale.getName(), calendarId, UDAT_STANDALONE_SHORT_WEEKDAYS, 1, callback, context);
+            return EnumSymbols(locale, calendarId, UDAT_STANDALONE_SHORT_WEEKDAYS, 1, callback, context);
         case MonthNames:
-            return EnumSymbols(locale.getName(), calendarId, UDAT_STANDALONE_MONTHS, 0, callback, context);
+            return EnumSymbols(locale, calendarId, UDAT_STANDALONE_MONTHS, 0, callback, context);
         case AbbrevMonthNames:
-            return EnumSymbols(locale.getName(), calendarId, UDAT_STANDALONE_SHORT_MONTHS, 0, callback, context);
+            return EnumSymbols(locale, calendarId, UDAT_STANDALONE_SHORT_MONTHS, 0, callback, context);
         case SuperShortDayNames:
 #ifdef HAVE_DTWIDTHTYPE_SHORT
-            return EnumSymbols(locale.getName(), calendarId, UDAT_STANDALONE_SHORTER_WEEKDAYS, 1, callback, context);
+            return EnumSymbols(locale, calendarId, UDAT_STANDALONE_SHORTER_WEEKDAYS, 1, callback, context);
 #else
-            return EnumSymbols(locale.getName(), calendarId, UDAT_STANDALONE_NARROW_WEEKDAYS, 1, callback, context);
+            return EnumSymbols(locale, calendarId, UDAT_STANDALONE_NARROW_WEEKDAYS, 1, callback, context);
 #endif
         case MonthGenitiveNames:
-            return EnumSymbols(locale.getName(), calendarId, UDAT_MONTHS, 0, callback, context);
+            return EnumSymbols(locale, calendarId, UDAT_MONTHS, 0, callback, context);
         case AbbrevMonthGenitiveNames:
-            return EnumSymbols(locale.getName(), calendarId, UDAT_SHORT_MONTHS, 0, callback, context);
+            return EnumSymbols(locale, calendarId, UDAT_SHORT_MONTHS, 0, callback, context);
         case EraNames:
-            return EnumSymbols(locale.getName(), calendarId, UDAT_ERAS, 0, callback, context);
+            return EnumSymbols(locale, calendarId, UDAT_ERAS, 0, callback, context);
         case AbbrevEraNames:
-            return EnumAbbrevEraNames(locale.getName(), calendarId, callback, context);
+            return EnumAbbrevEraNames(locale, calendarId, callback, context);
         default:
             assert(false);
             return false;

src/corefx/System.Globalization.Native/locale.cpp

@@ -31,45 +31,76 @@ int32_t UErrorCodeToBool(UErrorCode status)
     return 0;
 }
 
-Locale GetLocale(const UChar* localeName, bool canonize)
+int32_t GetLocale(
+    const UChar* localeName, char* localeNameResult, int32_t localeNameResultLength, bool canonicalize, UErrorCode* err)
 {
-    char localeNameTemp[ULOC_FULLNAME_CAPACITY];
+    char localeNameTemp[ULOC_FULLNAME_CAPACITY] = {0};
+    int32_t localeLength;
 
-    if (localeName != NULL)
+    // Convert ourselves instead of doing u_UCharsToChars as that function considers '@' a variant and stops.
+    for (int i = 0; i < ULOC_FULLNAME_CAPACITY - 1; i++)
     {
-        // use UnicodeString.extract instead of u_UCharsToChars; u_UCharsToChars
-        // considers '@' a variant and stops
-        UnicodeString str(localeName, -1, ULOC_FULLNAME_CAPACITY);
-        str.extract(0, str.length(), localeNameTemp);
+        UChar c = localeName[i];
+
+        if (c > (UChar)0x7F)
+        {
+            *err = U_ILLEGAL_ARGUMENT_ERROR;
+            return ULOC_FULLNAME_CAPACITY;
+        }
+
+        localeNameTemp[i] = (char)c;
+
+        if (c == (UChar)0x0)
+        {
+            break;
+        }
     }
 
-    Locale loc;
-    if (canonize)
+    if (canonicalize)
     {
-        loc = Locale::createCanonical(localeName == NULL ? NULL : localeNameTemp);
+        localeLength = uloc_canonicalize(localeNameTemp, localeNameResult, localeNameResultLength, err);
     }
     else
     {
-        loc = Locale::createFromName(localeName == NULL ? NULL : localeNameTemp);
+        localeLength = uloc_getName(localeNameTemp, localeNameResult, localeNameResultLength, err);
+    }
+
+    if (U_SUCCESS(*err))
+    {
+        // Make sure the "language" part of the locale is reasonable (i.e. we can fetch it and it is within range).
+        // This mimics how the C++ ICU API determines if a locale is "bogus" or not.
+
+        char language[ULOC_LANG_CAPACITY];
+        uloc_getLanguage(localeNameTemp, language, ULOC_LANG_CAPACITY, err);
+
+        if (*err == U_STRING_NOT_TERMINATED_WARNING)
+        {
+            // ULOC_LANG_CAPACITY includes the null terminator, so if we couldn't extract the language with the null
+            // terminator, the language must be invalid.
+
+            *err = U_ILLEGAL_ARGUMENT_ERROR;
+        }
     }
 
-    return loc;
+    return localeLength;
 }
 
 UErrorCode u_charsToUChars_safe(const char* str, UChar* value, int32_t valueLength)
 {
     int len = strlen(str);
+
     if (len >= valueLength)
     {
         return U_BUFFER_OVERFLOW_ERROR;
     }
+
     u_charsToUChars(str, value, len + 1);
     return U_ZERO_ERROR;
 }
 
-int FixupLocaleName(UChar* value, int32_t valueLength)
+int32_t FixupLocaleName(UChar* value, int32_t valueLength)
 {
-    int i = 0;
+    int32_t i = 0;
     for (; i < valueLength; i++)
     {
         if (value[i] == (UChar)'\0')
@@ -87,50 +118,55 @@ int FixupLocaleName(UChar* value, int32_t valueLength)
 
 extern "C" int32_t GetLocaleName(const UChar* localeName, UChar* value, int32_t valueLength)
 {
-    Locale locale = GetLocale(localeName, true);
-
-    if (locale.isBogus())
-    {
-        // localeName not properly formatted
-        return UErrorCodeToBool(U_ILLEGAL_ARGUMENT_ERROR);
-    }
+    UErrorCode status = U_ZERO_ERROR;
 
-    // other validation done on managed side
+    char localeNameBuffer[ULOC_FULLNAME_CAPACITY];
+    GetLocale(localeName, localeNameBuffer, ULOC_FULLNAME_CAPACITY, true, &status);
 
-    UErrorCode status = u_charsToUChars_safe(locale.getName(), value, valueLength);
     if (U_SUCCESS(status))
     {
-        FixupLocaleName(value, valueLength);
+        status = u_charsToUChars_safe(localeNameBuffer, value, valueLength);
+
+        if (U_SUCCESS(status))
+        {
+            FixupLocaleName(value, valueLength);
+        }
     }
 
     return UErrorCodeToBool(status);
 }
 
 extern "C" int32_t GetDefaultLocaleName(UChar* value, int32_t valueLength)
 {
-    Locale locale = GetLocale(NULL);
-    if (locale.isBogus())
-    {
-        // ICU should be able to get default locale
-        return UErrorCodeToBool(U_INTERNAL_PROGRAM_ERROR);
-    }
+    char localeNameBuffer[ULOC_FULLNAME_CAPACITY];
+    UErrorCode status = U_ZERO_ERROR;
+
+    const char* defaultLocale = uloc_getDefault();
+
+    uloc_getBaseName(defaultLocale, localeNameBuffer, ULOC_FULLNAME_CAPACITY, &status);
 
-    UErrorCode status = u_charsToUChars_safe(locale.getBaseName(), value, valueLength);
     if (U_SUCCESS(status))
     {
-        int localeNameLen = FixupLocaleName(value, valueLength);
+        status = u_charsToUChars_safe(localeNameBuffer, value, valueLength);
 
-        // if collation is present, return that to managed side
-        char collationValueTemp[ULOC_KEYWORDS_CAPACITY];
-        if (locale.getKeywordValue("collation", collationValueTemp, ULOC_KEYWORDS_CAPACITY, status) > 0)
+        if (U_SUCCESS(status))
         {
-            // copy the collation; managed uses a "_" to represent collation (not
-            // "@collation=")
-            status = u_charsToUChars_safe("_", &value[localeNameLen], valueLength - localeNameLen);
-            if (U_SUCCESS(status))
+            int localeNameLen = FixupLocaleName(value, valueLength);
+
+            char collationValueTemp[ULOC_KEYWORDS_CAPACITY];
+            int32_t collationLen =
+                uloc_getKeywordValue(defaultLocale, "collation", collationValueTemp, ULOC_KEYWORDS_CAPACITY, &status);
+
+            if (U_SUCCESS(status) && collationLen > 0)
             {
-                status = u_charsToUChars_safe(
-                    collationValueTemp, &value[localeNameLen + 1], valueLength - localeNameLen - 1);
+                // copy the collation; managed uses a "_" to represent collation (not
+                // "@collation=")
+                status = u_charsToUChars_safe("_", &value[localeNameLen], valueLength - localeNameLen);
+                if (U_SUCCESS(status))
+                {
+                    status = u_charsToUChars_safe(
+                        collationValueTemp, &value[localeNameLen + 1], valueLength - localeNameLen - 1);
+                }
             }
         }
     }

src/corefx/System.Globalization.Native/locale.hpp

@@ -27,9 +27,13 @@ int32_t UErrorCodeToBool(UErrorCode code);
 Function:
 GetLocale
 
-Returns a locale given the locale name
+Converts a managed localeName into something ICU understands and can use as a localeName.
 */
-Locale GetLocale(const UChar* localeName, bool canonize = false);
+int32_t GetLocale(const UChar* localeName,
+                  char* localeNameResult,
+                  int32_t localeNameResultLength,
+                  bool canonicalize,
+                  UErrorCode* err);
 
 /*
 Function: