wuggy/Dactyloidae
wuggy/Dactyloidae
1
0
Fork 0
mirror of https://repo.dactyloidae.xyz/Dactyloidae/UXP.git synced 2026-10-27 17:47:34 +09:00
Code Issues Projects Releases Packages Wiki Activity

Issue #325 Part 5: Remove non-Intl legacy code paths from js.

Browse source
This commit is contained in:
wolfbeast 2018-05-04 12:08:48 +02:00 • committed by Roy Tam
commit d1c16b1326
10 changed files with 17 additions and 632 deletions
Download patch file Download diff file Expand all files Collapse all files

602
js/src/builtin/Intl.cpp
View file

@ -23,7 +23,6 @@
#include "jsobj.h" #include "jsobj.h"
#include "builtin/IntlTimeZoneData.h" #include "builtin/IntlTimeZoneData.h"
#if ENABLE_INTL_API
#include "unicode/ucal.h" #include "unicode/ucal.h"
#include "unicode/ucol.h" #include "unicode/ucol.h"
#include "unicode/udat.h" #include "unicode/udat.h"
@ -32,7 +31,6 @@
#include "unicode/unum.h" #include "unicode/unum.h"
#include "unicode/unumsys.h" #include "unicode/unumsys.h"
#include "unicode/ustring.h" #include "unicode/ustring.h"
#endif
#include "vm/DateTime.h" #include "vm/DateTime.h"
#include "vm/GlobalObject.h" #include "vm/GlobalObject.h"
#include "vm/Interpreter.h" #include "vm/Interpreter.h"
@ -60,603 +58,6 @@ using mozilla::PodCopy;
* http://userguide.icu-project.org/design#TOC-Error-Handling * http://userguide.icu-project.org/design#TOC-Error-Handling
*/ */
/******************** ICU stubs ********************/
#if !ENABLE_INTL_API
/*
* When the Internationalization API isn't enabled, we also shouldn't link
* 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.
*/
typedef bool UBool;
typedef char16_t UChar;
typedef double UDate;
enum UErrorCode {
U_ZERO_ERROR,
U_BUFFER_OVERFLOW_ERROR,
};
static inline UBool
U_FAILURE(UErrorCode code)
{
MOZ_CRASH("U_FAILURE: Intl API disabled");
}
inline const UChar*
Char16ToUChar(const char16_t* chars)
{
MOZ_CRASH("Char16ToUChar: Intl API disabled");
}
inline UChar*
Char16ToUChar(char16_t* chars)
{
MOZ_CRASH("Char16ToUChar: Intl API disabled");
}
inline char16_t*
UCharToChar16(UChar* chars)
{
MOZ_CRASH("UCharToChar16: Intl API disabled");
}
inline const char16_t*
UCharToChar16(const UChar* chars)
{
MOZ_CRASH("UCharToChar16: Intl API disabled");
}
static int32_t
u_strlen(const UChar* s)
{
MOZ_CRASH("u_strlen: Intl API disabled");
}
struct UEnumeration;
static int32_t
uenum_count(UEnumeration* en, UErrorCode* status)
{
MOZ_CRASH("uenum_count: Intl API disabled");
}
static const char*
uenum_next(UEnumeration* en, int32_t* resultLength, UErrorCode* status)
{
MOZ_CRASH("uenum_next: Intl API disabled");
}
static void
uenum_close(UEnumeration* en)
{
MOZ_CRASH("uenum_close: Intl API disabled");
}
struct UCollator;
enum UColAttribute {
UCOL_ALTERNATE_HANDLING,
UCOL_CASE_FIRST,
UCOL_CASE_LEVEL,
UCOL_NORMALIZATION_MODE,
UCOL_STRENGTH,
UCOL_NUMERIC_COLLATION,
};
enum UColAttributeValue {
UCOL_DEFAULT = -1,
UCOL_PRIMARY = 0,
UCOL_SECONDARY = 1,
UCOL_TERTIARY = 2,
UCOL_OFF = 16,
UCOL_ON = 17,
UCOL_SHIFTED = 20,
UCOL_LOWER_FIRST = 24,
UCOL_UPPER_FIRST = 25,
};
enum UCollationResult {
UCOL_EQUAL = 0,
UCOL_GREATER = 1,
UCOL_LESS = -1
};
static int32_t
ucol_countAvailable()
{
MOZ_CRASH("ucol_countAvailable: Intl API disabled");
}
static const char*
ucol_getAvailable(int32_t localeIndex)
{
MOZ_CRASH("ucol_getAvailable: Intl API disabled");
}
static UCollator*
ucol_open(const char* loc, UErrorCode* status)
{
MOZ_CRASH("ucol_open: Intl API disabled");
}
static void
ucol_setAttribute(UCollator* coll, UColAttribute attr, UColAttributeValue value, UErrorCode* status)
{
MOZ_CRASH("ucol_setAttribute: Intl API disabled");
}
static 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
ucol_close(UCollator* coll)
{
MOZ_CRASH("ucol_close: Intl API disabled");
}
static UEnumeration*
ucol_getKeywordValuesForLocale(const char* key, const char* locale, UBool commonlyUsed,
UErrorCode* status)
{
MOZ_CRASH("ucol_getKeywordValuesForLocale: Intl API disabled");
}
struct UParseError;
struct UFieldPosition;
struct UFieldPositionIterator;
typedef void* UNumberFormat;
enum UNumberFormatStyle {
UNUM_DECIMAL = 1,
UNUM_CURRENCY,
UNUM_PERCENT,
UNUM_CURRENCY_ISO,
UNUM_CURRENCY_PLURAL,
};
enum UNumberFormatRoundingMode {
UNUM_ROUND_HALFUP,
};
enum UNumberFormatAttribute {
UNUM_GROUPING_USED,
UNUM_MIN_INTEGER_DIGITS,
UNUM_MAX_FRACTION_DIGITS,
UNUM_MIN_FRACTION_DIGITS,
UNUM_ROUNDING_MODE,
UNUM_SIGNIFICANT_DIGITS_USED,
UNUM_MIN_SIGNIFICANT_DIGITS,
UNUM_MAX_SIGNIFICANT_DIGITS,
};
enum UNumberFormatTextAttribute {
UNUM_CURRENCY_CODE,
};
static int32_t
unum_countAvailable()
{
MOZ_CRASH("unum_countAvailable: Intl API disabled");
}
static const char*
unum_getAvailable(int32_t localeIndex)
{
MOZ_CRASH("unum_getAvailable: Intl API disabled");
}
static 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
unum_setAttribute(UNumberFormat* fmt, UNumberFormatAttribute attr, int32_t newValue)
{
MOZ_CRASH("unum_setAttribute: Intl API disabled");
}
static 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
unum_close(UNumberFormat* fmt)
{
MOZ_CRASH("unum_close: Intl API disabled");
}
static 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*
unumsys_open(const char* locale, UErrorCode* status)
{
MOZ_CRASH("unumsys_open: Intl API disabled");
}
static const char*
unumsys_getName(const UNumberingSystem* unumsys)
{
MOZ_CRASH("unumsys_getName: Intl API disabled");
}
static void
unumsys_close(UNumberingSystem* unumsys)
{
MOZ_CRASH("unumsys_close: Intl API disabled");
}
typedef void* UCalendar;
enum UCalendarType {
UCAL_TRADITIONAL,
UCAL_DEFAULT = UCAL_TRADITIONAL,
UCAL_GREGORIAN
};
enum UCalendarAttribute {
UCAL_FIRST_DAY_OF_WEEK,
UCAL_MINIMAL_DAYS_IN_FIRST_WEEK
};
enum UCalendarDaysOfWeek {
UCAL_SUNDAY,
UCAL_MONDAY,
UCAL_TUESDAY,
UCAL_WEDNESDAY,
UCAL_THURSDAY,
UCAL_FRIDAY,
UCAL_SATURDAY
};
enum UCalendarWeekdayType {
UCAL_WEEKDAY,
UCAL_WEEKEND,
UCAL_WEEKEND_ONSET,
UCAL_WEEKEND_CEASE
};
enum UCalendarDateFields {
UCAL_ERA,
UCAL_YEAR,
UCAL_MONTH,
UCAL_WEEK_OF_YEAR,
UCAL_WEEK_OF_MONTH,
UCAL_DATE,
UCAL_DAY_OF_YEAR,
UCAL_DAY_OF_WEEK,
UCAL_DAY_OF_WEEK_IN_MONTH,
UCAL_AM_PM,
UCAL_HOUR,
UCAL_HOUR_OF_DAY,
UCAL_MINUTE,
UCAL_SECOND,
UCAL_MILLISECOND,
UCAL_ZONE_OFFSET,
UCAL_DST_OFFSET,
UCAL_YEAR_WOY,
UCAL_DOW_LOCAL,
UCAL_EXTENDED_YEAR,
UCAL_JULIAN_DAY,
UCAL_MILLISECONDS_IN_DAY,
UCAL_IS_LEAP_MONTH,
UCAL_FIELD_COUNT,
UCAL_DAY_OF_MONTH = UCAL_DATE
};
enum UCalendarMonths {
UCAL_JANUARY,
UCAL_FEBRUARY,
UCAL_MARCH,
UCAL_APRIL,
UCAL_MAY,
UCAL_JUNE,
UCAL_JULY,
UCAL_AUGUST,
UCAL_SEPTEMBER,
UCAL_OCTOBER,
UCAL_NOVEMBER,
UCAL_DECEMBER,
UCAL_UNDECIMBER
};
enum UCalendarAMPMs {
UCAL_AM,
UCAL_PM
};
static 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*
ucal_getType(const UCalendar* cal, UErrorCode* status)
{
MOZ_CRASH("ucal_getType: Intl API disabled");
}
static UEnumeration*
ucal_getKeywordValuesForLocale(const char* key, const char* locale,
UBool commonlyUsed, UErrorCode* status)
{
MOZ_CRASH("ucal_getKeywordValuesForLocale: Intl API disabled");
}
static void
ucal_close(UCalendar* cal)
{
MOZ_CRASH("ucal_close: Intl API disabled");
}
static UCalendarWeekdayType
ucal_getDayOfWeekType(const UCalendar *cal, UCalendarDaysOfWeek dayOfWeek, UErrorCode* status)
{
MOZ_CRASH("ucal_getDayOfWeekType: Intl API disabled");
}
static int32_t
ucal_getAttribute(const UCalendar* cal,
UCalendarAttribute attr)
{
MOZ_CRASH("ucal_getAttribute: Intl API disabled");
}
static int32_t
ucal_get(const UCalendar *cal, UCalendarDateFields field, UErrorCode *status)
{
MOZ_CRASH("ucal_get: Intl API disabled");
}
static UEnumeration*
ucal_openTimeZones(UErrorCode* status)
{
MOZ_CRASH("ucal_openTimeZones: Intl API disabled");
}
static 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
ucal_getDefaultTimeZone(UChar* result, int32_t resultCapacity, UErrorCode* status)
{
MOZ_CRASH("ucal_getDefaultTimeZone: Intl API disabled");
}
enum UDateTimePatternField {
UDATPG_YEAR_FIELD,
UDATPG_MONTH_FIELD,
UDATPG_WEEK_OF_YEAR_FIELD,
UDATPG_DAY_FIELD,
};
typedef void* UDateTimePatternGenerator;
static UDateTimePatternGenerator*
udatpg_open(const char* locale, UErrorCode* pErrorCode)
{
MOZ_CRASH("udatpg_open: Intl API disabled");
}
static 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 const UChar *
udatpg_getAppendItemName(const UDateTimePatternGenerator *dtpg,
UDateTimePatternField field,
int32_t *pLength)
{
MOZ_CRASH("udatpg_getAppendItemName: Intl API disabled");
}
static void
udatpg_close(UDateTimePatternGenerator* dtpg)
{
MOZ_CRASH("udatpg_close: Intl API disabled");
}
typedef void* UCalendar;
typedef void* UDateFormat;
enum UDateFormatField {
UDAT_ERA_FIELD = 0,
UDAT_YEAR_FIELD = 1,
UDAT_MONTH_FIELD = 2,
UDAT_DATE_FIELD = 3,
UDAT_HOUR_OF_DAY1_FIELD = 4,
UDAT_HOUR_OF_DAY0_FIELD = 5,
UDAT_MINUTE_FIELD = 6,
UDAT_SECOND_FIELD = 7,
UDAT_FRACTIONAL_SECOND_FIELD = 8,
UDAT_DAY_OF_WEEK_FIELD = 9,
UDAT_DAY_OF_YEAR_FIELD = 10,
UDAT_DAY_OF_WEEK_IN_MONTH_FIELD = 11,
UDAT_WEEK_OF_YEAR_FIELD = 12,
UDAT_WEEK_OF_MONTH_FIELD = 13,
UDAT_AM_PM_FIELD = 14,
UDAT_HOUR1_FIELD = 15,
UDAT_HOUR0_FIELD = 16,
UDAT_TIMEZONE_FIELD = 17,
UDAT_YEAR_WOY_FIELD = 18,
UDAT_DOW_LOCAL_FIELD = 19,
UDAT_EXTENDED_YEAR_FIELD = 20,
UDAT_JULIAN_DAY_FIELD = 21,
UDAT_MILLISECONDS_IN_DAY_FIELD = 22,
UDAT_TIMEZONE_RFC_FIELD = 23,
UDAT_TIMEZONE_GENERIC_FIELD = 24,
UDAT_STANDALONE_DAY_FIELD = 25,
UDAT_STANDALONE_MONTH_FIELD = 26,
UDAT_QUARTER_FIELD = 27,
UDAT_STANDALONE_QUARTER_FIELD = 28,
UDAT_TIMEZONE_SPECIAL_FIELD = 29,
UDAT_YEAR_NAME_FIELD = 30,
UDAT_TIMEZONE_LOCALIZED_GMT_OFFSET_FIELD = 31,
UDAT_TIMEZONE_ISO_FIELD = 32,
UDAT_TIMEZONE_ISO_LOCAL_FIELD = 33,
UDAT_RELATED_YEAR_FIELD = 34,
UDAT_AM_PM_MIDNIGHT_NOON_FIELD = 35,
UDAT_FLEXIBLE_DAY_PERIOD_FIELD = 36,
UDAT_TIME_SEPARATOR_FIELD = 37,
UDAT_FIELD_COUNT = 38
};
enum UDateFormatStyle {
UDAT_FULL,
UDAT_LONG,
UDAT_MEDIUM,
UDAT_SHORT,
UDAT_DEFAULT = UDAT_MEDIUM,
UDAT_PATTERN = -2,
UDAT_IGNORE = UDAT_PATTERN
};
enum UDateFormatSymbolType {
UDAT_ERAS,
UDAT_MONTHS,
UDAT_SHORT_MONTHS,
UDAT_WEEKDAYS,
UDAT_SHORT_WEEKDAYS,
UDAT_AM_PMS,
UDAT_LOCALIZED_CHARS,
UDAT_ERA_NAMES,
UDAT_NARROW_MONTHS,
UDAT_NARROW_WEEKDAYS,
UDAT_STANDALONE_MONTHS,
UDAT_STANDALONE_SHORT_MONTHS,
UDAT_STANDALONE_NARROW_MONTHS,
UDAT_STANDALONE_WEEKDAYS,
UDAT_STANDALONE_SHORT_WEEKDAYS,
UDAT_STANDALONE_NARROW_WEEKDAYS,
UDAT_QUARTERS,
UDAT_SHORT_QUARTERS,
UDAT_STANDALONE_QUARTERS,
UDAT_STANDALONE_SHORT_QUARTERS,
UDAT_SHORTER_WEEKDAYS,
UDAT_STANDALONE_SHORTER_WEEKDAYS,
UDAT_CYCLIC_YEARS_WIDE,
UDAT_CYCLIC_YEARS_ABBREVIATED,
UDAT_CYCLIC_YEARS_NARROW,
UDAT_ZODIAC_NAMES_WIDE,
UDAT_ZODIAC_NAMES_ABBREVIATED,
UDAT_ZODIAC_NAMES_NARROW
};
static int32_t
udat_countAvailable()
{
MOZ_CRASH("udat_countAvailable: Intl API disabled");
}
static const char*
udat_getAvailable(int32_t localeIndex)
{
MOZ_CRASH("udat_getAvailable: Intl API disabled");
}
static 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*
udat_getCalendar(const UDateFormat* fmt)
{
MOZ_CRASH("udat_getCalendar: Intl API disabled");
}
static void
ucal_setGregorianChange(UCalendar* cal, UDate date, UErrorCode* pErrorCode)
{
MOZ_CRASH("ucal_setGregorianChange: Intl API disabled");
}
static 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
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*
ufieldpositer_open(UErrorCode* status)
{
MOZ_CRASH("ufieldpositer_open: Intl API disabled");
}
static void
ufieldpositer_close(UFieldPositionIterator* fpositer)
{
MOZ_CRASH("ufieldpositer_close: Intl API disabled");
}
static int32_t
ufieldpositer_next(UFieldPositionIterator* fpositer, int32_t* beginIndex, int32_t* endIndex)
{
MOZ_CRASH("ufieldpositer_next: Intl API disabled");
}
static void
udat_close(UDateFormat* format)
{
MOZ_CRASH("udat_close: Intl API disabled");
}
static int32_t
udat_getSymbols(const UDateFormat *fmt, UDateFormatSymbolType type, int32_t symbolIndex,
UChar *result, int32_t resultLength, UErrorCode *status)
{
MOZ_CRASH("udat_getSymbols: Intl API disabled");
}
#endif
/******************** Common to Intl constructors ********************/ /******************** Common to Intl constructors ********************/
static bool static bool
@ -706,7 +107,6 @@ intl_availableLocales(JSContext* cx, CountAvailable countAvailable,
if (!locales) if (!locales)
return false; return false;
#if ENABLE_INTL_API
uint32_t count = countAvailable(); uint32_t count = countAvailable();
RootedValue t(cx, BooleanValue(true)); RootedValue t(cx, BooleanValue(true));
for (uint32_t i = 0; i < count; i++) { for (uint32_t i = 0; i < count; i++) {
@ -726,7 +126,7 @@ intl_availableLocales(JSContext* cx, CountAvailable countAvailable,
return false; return false;
} }
} }
#endif
result.setObject(*locales); result.setObject(*locales);
return true; return true;
} }

4
js/src/builtin/Intl.h
View file

@ -16,9 +16,7 @@
#include "js/GCAPI.h" #include "js/GCAPI.h"
#include "js/GCHashTable.h" #include "js/GCHashTable.h"
#if ENABLE_INTL_API
#include "unicode/utypes.h" #include "unicode/utypes.h"
#endif
/* /*
* The Intl module specified by standard ECMA-402, * The Intl module specified by standard ECMA-402,
@ -429,7 +427,6 @@ intl_GetCalendarInfo(JSContext* cx, unsigned argc, Value* vp);
extern MOZ_MUST_USE bool extern MOZ_MUST_USE bool
intl_ComputeDisplayNames(JSContext* cx, unsigned argc, Value* vp); intl_ComputeDisplayNames(JSContext* cx, unsigned argc, Value* vp);
#if ENABLE_INTL_API
/** /**
* Cast char16_t* strings to UChar* strings used by ICU. * Cast char16_t* strings to UChar* strings used by ICU.
*/ */
@ -456,7 +453,6 @@ UCharToChar16(const UChar* chars)
{ {
return reinterpret_cast<const char16_t*>(chars); return reinterpret_cast<const char16_t*>(chars);
} }
#endif // ENABLE_INTL_API
} // namespace js } // namespace js

2
js/src/gdb/moz.build
View file

@ -34,7 +34,7 @@ USE_LIBS += [
'static:js', 'static:js',
] ]
if CONFIG['ENABLE_INTL_API'] and CONFIG['MOZ_ICU_DATA_ARCHIVE']: if CONFIG['MOZ_ICU_DATA_ARCHIVE']:
# The ICU libraries linked into libmozjs will not include the ICU data, # The ICU libraries linked into libmozjs will not include the ICU data,
# so link it directly. # so link it directly.
USE_LIBS += ['icudata'] USE_LIBS += ['icudata']

2
js/src/jsapi-tests/moz.build
View file

@ -135,7 +135,7 @@ LOCAL_INCLUDES += [
'..', '..',
] ]
if CONFIG['ENABLE_INTL_API'] and CONFIG['MOZ_ICU_DATA_ARCHIVE']: if CONFIG['MOZ_ICU_DATA_ARCHIVE']:
# The ICU libraries linked into libmozjs will not include the ICU data, # The ICU libraries linked into libmozjs will not include the ICU data,
# so link it directly. # so link it directly.
USE_LIBS += ['icudata'] USE_LIBS += ['icudata']

2
js/src/jsstr.cpp
View file

@ -36,9 +36,7 @@
#include "jit/InlinableNatives.h" #include "jit/InlinableNatives.h"
#include "js/Conversions.h" #include "js/Conversions.h"
#include "js/UniquePtr.h" #include "js/UniquePtr.h"
#if ENABLE_INTL_API
#include "unicode/unorm.h" #include "unicode/unorm.h"
#endif
#include "vm/GlobalObject.h" #include "vm/GlobalObject.h"
#include "vm/Interpreter.h" #include "vm/Interpreter.h"
#include "vm/Opcodes.h" #include "vm/Opcodes.h"

23
js/src/moz.build
View file

@ -645,18 +645,17 @@ else:
FORCE_STATIC_LIB = True FORCE_STATIC_LIB = True
STATIC_LIBRARY_NAME = 'js_static' STATIC_LIBRARY_NAME = 'js_static'
if CONFIG['ENABLE_INTL_API']: if not CONFIG['MOZ_ICU_DATA_ARCHIVE']:
if not CONFIG['MOZ_ICU_DATA_ARCHIVE']: USE_LIBS += [
USE_LIBS += [ 'icu',
'icu', ]
] else:
else: # Linking 'icu' will pull in the stubdata library,
# Linking 'icu' will pull in the stubdata library, # which the shell doesn't want, so link the other bits.
# which the shell doesn't want, so link the other bits. USE_LIBS += [
USE_LIBS += [ 'icui18n',
'icui18n', 'icuuc',
'icuuc', ]
]
USE_LIBS += [ USE_LIBS += [
'nspr', 'nspr',

4
js/src/shell/js.cpp
View file

@ -893,7 +893,6 @@ SetPromiseRejectionTrackerCallback(JSContext* cx, unsigned argc, Value* vp)
return true; return true;
} }
#ifdef ENABLE_INTL_API
static bool static bool
AddIntlExtras(JSContext* cx, unsigned argc, Value* vp) AddIntlExtras(JSContext* cx, unsigned argc, Value* vp)
{ {
@ -916,7 +915,6 @@ AddIntlExtras(JSContext* cx, unsigned argc, Value* vp)
args.rval().setUndefined(); args.rval().setUndefined();
return true; return true;
} }
#endif // ENABLE_INTL_API
static bool static bool
EvalAndPrint(JSContext* cx, const char* bytes, size_t length, EvalAndPrint(JSContext* cx, const char* bytes, size_t length,
@ -6140,7 +6138,6 @@ static const JSFunctionSpecWithHelp shell_functions[] = {
"Sets the callback to be invoked whenever a Promise rejection is unhandled\n" "Sets the callback to be invoked whenever a Promise rejection is unhandled\n"
"or a previously-unhandled rejection becomes handled."), "or a previously-unhandled rejection becomes handled."),
#ifdef ENABLE_INTL_API
JS_FN_HELP("addIntlExtras", AddIntlExtras, 1, 0, JS_FN_HELP("addIntlExtras", AddIntlExtras, 1, 0,
"addIntlExtras(obj)", "addIntlExtras(obj)",
"Adds various not-yet-standardized Intl functions as properties on the\n" "Adds various not-yet-standardized Intl functions as properties on the\n"
@ -6148,7 +6145,6 @@ static const JSFunctionSpecWithHelp shell_functions[] = {
"functions and their behavior are experimental: don't depend upon them\n" "functions and their behavior are experimental: don't depend upon them\n"
"unless you're willing to update your code if these experimental APIs change\n" "unless you're willing to update your code if these experimental APIs change\n"
"underneath you."), "underneath you."),
#endif // ENABLE_INTL_API
JS_FS_HELP_END JS_FS_HELP_END
}; };

2
js/src/shell/moz.build
View file

@ -36,7 +36,7 @@ LOCAL_INCLUDES += [
OS_LIBS += CONFIG['EDITLINE_LIBS'] OS_LIBS += CONFIG['EDITLINE_LIBS']
OS_LIBS += CONFIG['MOZ_ZLIB_LIBS'] OS_LIBS += CONFIG['MOZ_ZLIB_LIBS']
if CONFIG['ENABLE_INTL_API'] and CONFIG['MOZ_ICU_DATA_ARCHIVE']: if CONFIG['MOZ_ICU_DATA_ARCHIVE']:
# The ICU libraries linked into libmozjs will not include the ICU data, # The ICU libraries linked into libmozjs will not include the ICU data,
# so link it directly. # so link it directly.
USE_LIBS += ['icudata'] USE_LIBS += ['icudata']

6
js/src/vm/DateTime.cpp
View file

@ -13,9 +13,7 @@
#include "jsutil.h" #include "jsutil.h"
#include "js/Date.h" #include "js/Date.h"
#if ENABLE_INTL_API
#include "unicode/timezone.h" #include "unicode/timezone.h"
#endif
using mozilla::Atomic; using mozilla::Atomic;
using mozilla::ReleaseAcquire; using mozilla::ReleaseAcquire;
@ -333,7 +331,7 @@ JS::ResetTimeZone()
{ {
js::DateTimeInfo::updateTimeZoneAdjustment(); js::DateTimeInfo::updateTimeZoneAdjustment();
#if ENABLE_INTL_API && defined(ICU_TZ_HAS_RECREATE_DEFAULT) #if defined(ICU_TZ_HAS_RECREATE_DEFAULT)
TZInfo.acquire(); TZInfo.acquire();
TZInfo.status = IcuTimeZoneInfo::NeedsUpdate; TZInfo.status = IcuTimeZoneInfo::NeedsUpdate;
TZInfo.release(); TZInfo.release();
@ -343,7 +341,7 @@ JS::ResetTimeZone()
void void
js::ResyncICUDefaultTimeZone() js::ResyncICUDefaultTimeZone()
{ {
#if ENABLE_INTL_API && defined(ICU_TZ_HAS_RECREATE_DEFAULT) #if defined(ICU_TZ_HAS_RECREATE_DEFAULT)
TZInfo.acquire(); TZInfo.acquire();
if (TZInfo.status == IcuTimeZoneInfo::NeedsUpdate) { if (TZInfo.status == IcuTimeZoneInfo::NeedsUpdate) {
icu::TimeZone::recreateDefault(); icu::TimeZone::recreateDefault();

2
js/src/vm/Initialization.cpp
View file

@ -20,10 +20,8 @@
#include "jit/ExecutableAllocator.h" #include "jit/ExecutableAllocator.h"
#include "jit/Ion.h" #include "jit/Ion.h"
#include "js/Utility.h" #include "js/Utility.h"
#if ENABLE_INTL_API
#include "unicode/uclean.h" #include "unicode/uclean.h"
#include "unicode/utypes.h" #include "unicode/utypes.h"
#endif // ENABLE_INTL_API
#include "vm/DateTime.h" #include "vm/DateTime.h"
#include "vm/HelperThreads.h" #include "vm/HelperThreads.h"
#include "vm/Runtime.h" #include "vm/Runtime.h"