Bug 1300925 - Change Intl.cpp stubs to an anonymous namespace. r=Waldo
authorVladimir Vukicevic <vladimir@pobox.com>
Tue, 15 Nov 2016 14:08:05 -0600
changeset 367750 9822e0525b82bcca19078eab6532c8972977a156
parent 367749 07fa89dfac8390c8529181cbf818b6e5c1a75bf1
child 367751 e66c6309387c05577e0e698f69c8c70a8d16221d
push id6996
push userjlorenzo@mozilla.com
push dateMon, 06 Mar 2017 20:48:21 +0000
treeherdermozilla-beta@d89512dab048 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersWaldo
bugs1300925
milestone53.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1300925 - Change Intl.cpp stubs to an anonymous namespace. r=Waldo MozReview-Commit-ID: 9Ed1gglWsby
js/src/builtin/Intl.cpp
--- a/js/src/builtin/Intl.cpp
+++ b/js/src/builtin/Intl.cpp
@@ -69,26 +69,28 @@ using mozilla::PodCopy;
  * against ICU. However, we still want to compile this code in order to prevent
  * bit rot. The following stub implementations for ICU functions make this
  * possible. The functions using them should never be called, so they assert
  * and return error codes. Signatures adapted from ICU header files locid.h,
  * numsys.h, ucal.h, ucol.h, udat.h, udatpg.h, uenum.h, unum.h; see the ICU
  * directory for license.
  */
 
+namespace {
+
 typedef bool UBool;
 typedef char16_t UChar;
 typedef double UDate;
 
 enum UErrorCode {
     U_ZERO_ERROR,
     U_BUFFER_OVERFLOW_ERROR,
 };
 
-static inline UBool
+inline UBool
 U_FAILURE(UErrorCode code)
 {
     MOZ_CRASH("U_FAILURE: Intl API disabled");
 }
 
 inline const UChar*
 Char16ToUChar(const char16_t* chars)
 {
@@ -96,37 +98,37 @@ Char16ToUChar(const char16_t* chars)
 }
 
 inline UChar*
 Char16ToUChar(char16_t* chars)
 {
     MOZ_CRASH("Char16ToUChar: Intl API disabled");
 }
 
-static int32_t
+int32_t
 u_strlen(const UChar* s)
 {
     MOZ_CRASH("u_strlen: Intl API disabled");
 }
 
 struct UEnumeration;
 
-static int32_t
+int32_t
 uenum_count(UEnumeration* en, UErrorCode* status)
 {
     MOZ_CRASH("uenum_count: Intl API disabled");
 }
 
-static const char*
+const char*
 uenum_next(UEnumeration* en, int32_t* resultLength, UErrorCode* status)
 {
     MOZ_CRASH("uenum_next: Intl API disabled");
 }
 
-static void
+void
 uenum_close(UEnumeration* en)
 {
     MOZ_CRASH("uenum_close: Intl API disabled");
 }
 
 struct UCollator;
 
 enum UColAttribute {
@@ -151,54 +153,54 @@ enum UColAttributeValue {
 };
 
 enum UCollationResult {
     UCOL_EQUAL = 0,
     UCOL_GREATER = 1,
     UCOL_LESS = -1
 };
 
-static int32_t
+int32_t
 ucol_countAvailable()
 {
     MOZ_CRASH("ucol_countAvailable: Intl API disabled");
 }
 
-static const char*
+const char*
 ucol_getAvailable(int32_t localeIndex)
 {
     MOZ_CRASH("ucol_getAvailable: Intl API disabled");
 }
 
-static UCollator*
+UCollator*
 ucol_open(const char* loc, UErrorCode* status)
 {
     MOZ_CRASH("ucol_open: Intl API disabled");
 }
 
-static void
+void
 ucol_setAttribute(UCollator* coll, UColAttribute attr, UColAttributeValue value, UErrorCode* status)
 {
     MOZ_CRASH("ucol_setAttribute: Intl API disabled");
 }
 
-static UCollationResult
+UCollationResult
 ucol_strcoll(const UCollator* coll, const UChar* source, int32_t sourceLength,
              const UChar* target, int32_t targetLength)
 {
     MOZ_CRASH("ucol_strcoll: Intl API disabled");
 }
 
-static void
+void
 ucol_close(UCollator* coll)
 {
     MOZ_CRASH("ucol_close: Intl API disabled");
 }
 
-static UEnumeration*
+UEnumeration*
 ucol_getKeywordValuesForLocale(const char* key, const char* locale, UBool commonlyUsed,
                                UErrorCode* status)
 {
     MOZ_CRASH("ucol_getKeywordValuesForLocale: Intl API disabled");
 }
 
 struct UParseError;
 struct UFieldPosition;
@@ -227,76 +229,76 @@ enum UNumberFormatAttribute {
     UNUM_MIN_SIGNIFICANT_DIGITS,
     UNUM_MAX_SIGNIFICANT_DIGITS,
 };
 
 enum UNumberFormatTextAttribute {
     UNUM_CURRENCY_CODE,
 };
 
-static int32_t
+int32_t
 unum_countAvailable()
 {
     MOZ_CRASH("unum_countAvailable: Intl API disabled");
 }
 
-static const char*
+const char*
 unum_getAvailable(int32_t localeIndex)
 {
     MOZ_CRASH("unum_getAvailable: Intl API disabled");
 }
 
-static UNumberFormat*
+UNumberFormat*
 unum_open(UNumberFormatStyle style, const UChar* pattern, int32_t patternLength,
           const char* locale, UParseError* parseErr, UErrorCode* status)
 {
     MOZ_CRASH("unum_open: Intl API disabled");
 }
 
-static void
+void
 unum_setAttribute(UNumberFormat* fmt, UNumberFormatAttribute  attr, int32_t newValue)
 {
     MOZ_CRASH("unum_setAttribute: Intl API disabled");
 }
 
-static int32_t
+int32_t
 unum_formatDouble(const UNumberFormat* fmt, double number, UChar* result,
                   int32_t resultLength, UFieldPosition* pos, UErrorCode* status)
 {
     MOZ_CRASH("unum_formatDouble: Intl API disabled");
 }
 
-static void
+void
 unum_close(UNumberFormat* fmt)
 {
     MOZ_CRASH("unum_close: Intl API disabled");
 }
 
-static void
+void
 unum_setTextAttribute(UNumberFormat* fmt, UNumberFormatTextAttribute tag, const UChar* newValue,
                       int32_t newValueLength, UErrorCode* status)
 {
     MOZ_CRASH("unum_setTextAttribute: Intl API disabled");
 }
 
 typedef void* UNumberingSystem;
 
-static UNumberingSystem*
+UNumberingSystem*
 unumsys_open(const char* locale, UErrorCode* status)
 {
     MOZ_CRASH("unumsys_open: Intl API disabled");
 }
 
-static const char*
+const char*
 unumsys_getName(const UNumberingSystem* unumsys)
 {
     MOZ_CRASH("unumsys_getName: Intl API disabled");
 }
 
-static void
+void
 unumsys_close(UNumberingSystem* unumsys)
 {
     MOZ_CRASH("unumsys_close: Intl API disabled");
 }
 
 typedef void* UCalendar;
 
 enum UCalendarType {
@@ -350,97 +352,97 @@ enum UCalendarDateFields {
     UCAL_EXTENDED_YEAR,
     UCAL_JULIAN_DAY,
     UCAL_MILLISECONDS_IN_DAY,
     UCAL_IS_LEAP_MONTH,
     UCAL_FIELD_COUNT,
     UCAL_DAY_OF_MONTH = UCAL_DATE
 };
 
-static UCalendar*
+UCalendar*
 ucal_open(const UChar* zoneID, int32_t len, const char* locale,
           UCalendarType type, UErrorCode* status)
 {
     MOZ_CRASH("ucal_open: Intl API disabled");
 }
 
-static const char*
+const char*
 ucal_getType(const UCalendar* cal, UErrorCode* status)
 {
     MOZ_CRASH("ucal_getType: Intl API disabled");
 }
 
-static UEnumeration*
+UEnumeration*
 ucal_getKeywordValuesForLocale(const char* key, const char* locale,
                                UBool commonlyUsed, UErrorCode* status)
 {
     MOZ_CRASH("ucal_getKeywordValuesForLocale: Intl API disabled");
 }
 
-static void
+void
 ucal_close(UCalendar* cal)
 {
     MOZ_CRASH("ucal_close: Intl API disabled");
 }
 
-static UCalendarWeekdayType
+UCalendarWeekdayType
 ucal_getDayOfWeekType(const UCalendar *cal, UCalendarDaysOfWeek dayOfWeek, UErrorCode* status)
 {
     MOZ_CRASH("ucal_getDayOfWeekType: Intl API disabled");
 }
 
-static int32_t
+int32_t
 ucal_getAttribute(const UCalendar*    cal,
                   UCalendarAttribute  attr)
 {
     MOZ_CRASH("ucal_getAttribute: Intl API disabled");
 }
 
-static int32_t
+int32_t
 ucal_get(const UCalendar *cal, UCalendarDateFields field, UErrorCode *status)
 {
     MOZ_CRASH("ucal_get: Intl API disabled");
 }
 
-static UEnumeration*
+UEnumeration*
 ucal_openTimeZones(UErrorCode* status)
 {
     MOZ_CRASH("ucal_openTimeZones: Intl API disabled");
 }
 
-static int32_t
+int32_t
 ucal_getCanonicalTimeZoneID(const UChar* id, int32_t len, UChar* result, int32_t resultCapacity,
                             UBool* isSystemID, UErrorCode* status)
 {
     MOZ_CRASH("ucal_getCanonicalTimeZoneID: Intl API disabled");
 }
 
-static int32_t
+int32_t
 ucal_getDefaultTimeZone(UChar* result, int32_t resultCapacity, UErrorCode* status)
 {
     MOZ_CRASH("ucal_getDefaultTimeZone: Intl API disabled");
 }
 
 typedef void* UDateTimePatternGenerator;
 
-static UDateTimePatternGenerator*
+UDateTimePatternGenerator*
 udatpg_open(const char* locale, UErrorCode* pErrorCode)
 {
     MOZ_CRASH("udatpg_open: Intl API disabled");
 }
 
-static int32_t
+int32_t
 udatpg_getBestPattern(UDateTimePatternGenerator* dtpg, const UChar* skeleton,
                       int32_t length, UChar* bestPattern, int32_t capacity,
                       UErrorCode* pErrorCode)
 {
     MOZ_CRASH("udatpg_getBestPattern: Intl API disabled");
 }
 
-static void
+void
 udatpg_close(UDateTimePatternGenerator* dtpg)
 {
     MOZ_CRASH("udatpg_close: Intl API disabled");
 }
 
 typedef void* UCalendar;
 typedef void* UDateFormat;
 
@@ -486,87 +488,89 @@ enum UDateFormatField {
     UDAT_FIELD_COUNT = 38
 };
 
 enum UDateFormatStyle {
     UDAT_PATTERN = -2,
     UDAT_IGNORE = UDAT_PATTERN
 };
 
-static int32_t
+int32_t
 udat_countAvailable()
 {
     MOZ_CRASH("udat_countAvailable: Intl API disabled");
 }
 
-static const char*
+const char*
 udat_getAvailable(int32_t localeIndex)
 {
     MOZ_CRASH("udat_getAvailable: Intl API disabled");
 }
 
-static UDateFormat*
+UDateFormat*
 udat_open(UDateFormatStyle timeStyle, UDateFormatStyle dateStyle, const char* locale,
           const UChar* tzID, int32_t tzIDLength, const UChar* pattern,
           int32_t patternLength, UErrorCode* status)
 {
     MOZ_CRASH("udat_open: Intl API disabled");
 }
 
-static const UCalendar*
+const UCalendar*
 udat_getCalendar(const UDateFormat* fmt)
 {
     MOZ_CRASH("udat_getCalendar: Intl API disabled");
 }
 
-static void
+void
 ucal_setGregorianChange(UCalendar* cal, UDate date, UErrorCode* pErrorCode)
 {
     MOZ_CRASH("ucal_setGregorianChange: Intl API disabled");
 }
 
-static int32_t
+int32_t
 udat_format(const UDateFormat* format, UDate dateToFormat, UChar* result,
             int32_t resultLength, UFieldPosition* position, UErrorCode* status)
 {
     MOZ_CRASH("udat_format: Intl API disabled");
 }
 
-static int32_t
+int32_t
 udat_formatForFields(const UDateFormat* format, UDate dateToFormat,
                      UChar* result, int32_t resultLength, UFieldPositionIterator* fpositer,
                      UErrorCode* status)
 {
     MOZ_CRASH("udat_formatForFields: Intl API disabled");
 }
 
-static UFieldPositionIterator*
+UFieldPositionIterator*
 ufieldpositer_open(UErrorCode* status)
 {
     MOZ_CRASH("ufieldpositer_open: Intl API disabled");
 }
 
-static void
+void
 ufieldpositer_close(UFieldPositionIterator* fpositer)
 {
     MOZ_CRASH("ufieldpositer_close: Intl API disabled");
 }
 
-static int32_t
+int32_t
 ufieldpositer_next(UFieldPositionIterator* fpositer, int32_t* beginIndex, int32_t* endIndex)
 {
     MOZ_CRASH("ufieldpositer_next: Intl API disabled");
 }
 
-static void
+void
 udat_close(UDateFormat* format)
 {
     MOZ_CRASH("udat_close: Intl API disabled");
 }
 
+} // anonymous namespace
+
 #endif
 
 
 /******************** Common to Intl constructors ********************/
 
 static bool
 IntlInitialize(JSContext* cx, HandleObject obj, Handle<PropertyName*> initializer,
                HandleValue locales, HandleValue options)