wuggy/Dactyloidae
wuggy/Dactyloidae
1
0
Fork 0
mirror of https://repo.dactyloidae.xyz/Dactyloidae/UXP.git synced 2026-09-07 00:08:39 +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 "builtin/IntlTimeZoneData.h"
#if ENABLE_INTL_API
#include "unicode/ucal.h"
#include "unicode/ucol.h"
#include "unicode/udat.h"
@ -32,7 +31,6 @@
#include "unicode/unum.h"
#include "unicode/unumsys.h"
#include "unicode/ustring.h"
#endif
#include "vm/DateTime.h"
#include "vm/GlobalObject.h"
#include "vm/Interpreter.h"
@ -60,603 +58,6 @@ using mozilla::PodCopy;
* 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 ********************/
static bool
@ -706,7 +107,6 @@ intl_availableLocales(JSContext* cx, CountAvailable countAvailable,
if (!locales)
return false;
#if ENABLE_INTL_API
uint32_t count = countAvailable();
RootedValue t(cx, BooleanValue(true));
for (uint32_t i = 0; i < count; i++) {
@ -726,7 +126,7 @@ intl_availableLocales(JSContext* cx, CountAvailable countAvailable,
return false;
}
}
#endif
result.setObject(*locales);
return true;
}

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

@ -16,9 +16,7 @@
#include "js/GCAPI.h"
#include "js/GCHashTable.h"
#if ENABLE_INTL_API
#include "unicode/utypes.h"
#endif
/*
* 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
intl_ComputeDisplayNames(JSContext* cx, unsigned argc, Value* vp);
#if ENABLE_INTL_API
/**
* 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);
}
#endif // ENABLE_INTL_API
} // namespace js

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

@ -34,7 +34,7 @@ USE_LIBS += [
'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,
# so link it directly.
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,
# so link it directly.
USE_LIBS += ['icudata']

2
js/src/jsstr.cpp
View file

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

23
js/src/moz.build
View file

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

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

@ -893,7 +893,6 @@ SetPromiseRejectionTrackerCallback(JSContext* cx, unsigned argc, Value* vp)
return true;
}
#ifdef ENABLE_INTL_API
static bool
AddIntlExtras(JSContext* cx, unsigned argc, Value* vp)
{
@ -916,7 +915,6 @@ AddIntlExtras(JSContext* cx, unsigned argc, Value* vp)
args.rval().setUndefined();
return true;
}
#endif // ENABLE_INTL_API
static bool
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"
"or a previously-unhandled rejection becomes handled."),
#ifdef ENABLE_INTL_API
JS_FN_HELP("addIntlExtras", AddIntlExtras, 1, 0,
"addIntlExtras(obj)",
"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"
"unless you're willing to update your code if these experimental APIs change\n"
"underneath you."),
#endif // ENABLE_INTL_API
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['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,
# so link it directly.
USE_LIBS += ['icudata']

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

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

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

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