Merged r20375 into 3.24 branch.

src/i18n.js

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 214 matching lines @@
  */
 var ORDINARY_FUNCTION_CALLED_AS_CONSTRUCTOR =
   'Function object that\'s not a constructor was created with new';
 
 
 /**
  * Adds bound method to the prototype of the given object.
  */
 function addBoundMethod(obj, methodName, implementation, length) {
   function getter() {
-    if (!this || typeof this !== 'object' ||
-        this.__initializedIntlObject === undefined) {
+    if (!%IsInitializedIntlObject(this)) {
         throw new $TypeError('Method ' + methodName + ' called on a ' +
                             'non-object or on a wrong type of object.');
     }
     var internalName = '__bound' + methodName + '__';
     if (this[internalName] === undefined) {
       var that = this;
       var boundMethod;
       if (length === undefined || length === 2) {
         boundMethod = function(x, y) {
           if (%_IsConstructCall()) {
@@ skipping 642 matching lines @@
   var languageTag =
       '^(' + langTag + '|' + privateUse + '|' + grandfathered + ')$';
   LANGUAGE_TAG_RE = new $RegExp(languageTag, 'i');
 }
 
 /**
  * Initializes the given object so it's a valid Collator instance.
  * Useful for subclassing.
  */
 function initializeCollator(collator, locales, options) {
-  if (collator.hasOwnProperty('__initializedIntlObject')) {
+  if (%IsInitializedIntlObject(collator)) {
     throw new $TypeError('Trying to re-initialize Collator object.');
   }
 
   if (options === undefined) {
     options = {};
   }
 
   var getOption = getGetOption(options, 'collator');
 
   var internalOptions = {};
@@ skipping 50 matching lines @@
     sensitivity: {writable: true},
     strength: {writable: true},
     usage: {value: internalOptions.usage, writable: true}
   });
 
   var internalCollator = %CreateCollator(requestedLocale,
                                          internalOptions,
                                          resolved);
 
   // Writable, configurable and enumerable are set to false by default.
-  $Object.defineProperty(collator, 'collator', {value: internalCollator});
-  $Object.defineProperty(collator, '__initializedIntlObject',
-                         {value: 'collator'});
+  %MarkAsInitializedIntlObjectOfType(collator, 'collator', internalCollator);
   $Object.defineProperty(collator, 'resolved', {value: resolved});
 
   return collator;
 }
 
 
 /**
  * Constructs Intl.Collator object given optional locales and options
  * parameters.
  *
@@ skipping 15 matching lines @@
 
 
 /**
  * Collator resolvedOptions method.
  */
 %SetProperty(Intl.Collator.prototype, 'resolvedOptions', function() {
     if (%_IsConstructCall()) {
       throw new $TypeError(ORDINARY_FUNCTION_CALLED_AS_CONSTRUCTOR);
     }
 
-    if (!this || typeof this !== 'object' ||
-        this.__initializedIntlObject !== 'collator') {
+    if (!%IsInitializedIntlObjectOfType(this, 'collator')) {
       throw new $TypeError('resolvedOptions method called on a non-object ' +
                            'or on a object that is not Intl.Collator.');
     }
 
     var coll = this;
     var locale = getOptimalLanguageTag(coll.resolved.requestedLocale,
                                        coll.resolved.locale);
 
     return {
       locale: locale,
@@ skipping 36 matching lines @@
  * When the compare method is called with two arguments x and y, it returns a
  * Number other than NaN that represents the result of a locale-sensitive
  * String comparison of x with y.
  * The result is intended to order String values in the sort order specified
  * by the effective locale and collation options computed during construction
  * of this Collator object, and will be negative, zero, or positive, depending
  * on whether x comes before y in the sort order, the Strings are equal under
  * the sort order, or x comes after y in the sort order, respectively.
  */
 function compare(collator, x, y) {
-  return %InternalCompare(collator.collator, $String(x), $String(y));
+  return %InternalCompare(%GetImplFromInitializedIntlObject(collator),
+                          $String(x), $String(y));
 };
 
 
 addBoundMethod(Intl.Collator, 'compare', compare, 2);
 
 /**
  * Verifies that the input is a well-formed ISO 4217 currency code.
  * Don't uppercase to test. It could convert invalid code into a valid one.
  * For example \u00DFP (Eszett+P) becomes SSP.
  */
@@ skipping 20 matching lines @@
 
   return fallback;
 }
 
 
 /**
  * Initializes the given object so it's a valid NumberFormat instance.
  * Useful for subclassing.
  */
 function initializeNumberFormat(numberFormat, locales, options) {
-  if (numberFormat.hasOwnProperty('__initializedIntlObject')) {
+  if (%IsInitializedIntlObject(numberFormat)) {
     throw new $TypeError('Trying to re-initialize NumberFormat object.');
   }
 
   if (options === undefined) {
     options = {};
   }
 
   var getOption = getGetOption(options, 'numberformat');
 
   var locale = resolveLocale('numberformat', locales, options);
@@ skipping 71 matching lines @@
                                       internalOptions,
                                       resolved);
 
   // We can't get information about number or currency style from ICU, so we
   // assume user request was fulfilled.
   if (internalOptions.style === 'currency') {
     $Object.defineProperty(resolved, 'currencyDisplay', {value: currencyDisplay,
                                                          writable: true});
   }
 
-  $Object.defineProperty(numberFormat, 'formatter', {value: formatter});
+  %MarkAsInitializedIntlObjectOfType(numberFormat, 'numberformat', formatter);
   $Object.defineProperty(numberFormat, 'resolved', {value: resolved});
-  $Object.defineProperty(numberFormat, '__initializedIntlObject',
-                         {value: 'numberformat'});
 
   return numberFormat;
 }
 
 
 /**
  * Constructs Intl.NumberFormat object given optional locales and options
  * parameters.
  *
  * @constructor
@@ skipping 14 matching lines @@
 
 
 /**
  * NumberFormat resolvedOptions method.
  */
 %SetProperty(Intl.NumberFormat.prototype, 'resolvedOptions', function() {
     if (%_IsConstructCall()) {
       throw new $TypeError(ORDINARY_FUNCTION_CALLED_AS_CONSTRUCTOR);
     }
 
-    if (!this || typeof this !== 'object' ||
-        this.__initializedIntlObject !== 'numberformat') {
+    if (!%IsInitializedIntlObjectOfType(this, 'numberformat')) {
       throw new $TypeError('resolvedOptions method called on a non-object' +
           ' or on a object that is not Intl.NumberFormat.');
     }
 
     var format = this;
     var locale = getOptimalLanguageTag(format.resolved.requestedLocale,
                                        format.resolved.locale);
 
     var result = {
       locale: locale,
@@ skipping 53 matching lines @@
 
 /**
  * Returns a String value representing the result of calling ToNumber(value)
  * according to the effective locale and the formatting options of this
  * NumberFormat.
  */
 function formatNumber(formatter, value) {
   // Spec treats -0 and +0 as 0.
   var number = $Number(value) + 0;
 
-  return %InternalNumberFormat(formatter.formatter, number);
+  return %InternalNumberFormat(%GetImplFromInitializedIntlObject(formatter),
+                               number);
 }
 
 
 /**
  * Returns a Number that represents string value that was passed in.
  */
 function parseNumber(formatter, value) {
-  return %InternalNumberParse(formatter.formatter, $String(value));
+  return %InternalNumberParse(%GetImplFromInitializedIntlObject(formatter),
+                              $String(value));
 }
 
 
 addBoundMethod(Intl.NumberFormat, 'format', formatNumber, 1);
 addBoundMethod(Intl.NumberFormat, 'v8Parse', parseNumber, 1);
 
 /**
  * Returns a string that matches LDML representation of the options object.
  */
 function toLDMLString(options) {
@@ skipping 192 matching lines @@
   return options;
 }
 
 
 /**
  * Initializes the given object so it's a valid DateTimeFormat instance.
  * Useful for subclassing.
  */
 function initializeDateTimeFormat(dateFormat, locales, options) {
 
-  if (dateFormat.hasOwnProperty('__initializedIntlObject')) {
+  if (%IsInitializedIntlObject(dateFormat)) {
     throw new $TypeError('Trying to re-initialize DateTimeFormat object.');
   }
 
   if (options === undefined) {
     options = {};
   }
 
   var locale = resolveLocale('dateformat', locales, options);
 
   options = toDateTimeOptions(options, 'any', 'date');
@@ skipping 41 matching lines @@
     year: {writable: true}
   });
 
   var formatter = %CreateDateTimeFormat(
     requestedLocale, {skeleton: ldmlString, timeZone: tz}, resolved);
 
   if (tz !== undefined && tz !== resolved.timeZone) {
     throw new $RangeError('Unsupported time zone specified ' + tz);
   }
 
-  $Object.defineProperty(dateFormat, 'formatter', {value: formatter});
+  %MarkAsInitializedIntlObjectOfType(dateFormat, 'dateformat', formatter);
   $Object.defineProperty(dateFormat, 'resolved', {value: resolved});
-  $Object.defineProperty(dateFormat, '__initializedIntlObject',
-                         {value: 'dateformat'});
 
   return dateFormat;
 }
 
 
 /**
  * Constructs Intl.DateTimeFormat object given optional locales and options
  * parameters.
  *
  * @constructor
@@ skipping 14 matching lines @@
 
 
 /**
  * DateTimeFormat resolvedOptions method.
  */
 %SetProperty(Intl.DateTimeFormat.prototype, 'resolvedOptions', function() {
     if (%_IsConstructCall()) {
       throw new $TypeError(ORDINARY_FUNCTION_CALLED_AS_CONSTRUCTOR);
     }
 
-    if (!this || typeof this !== 'object' ||
-        this.__initializedIntlObject !== 'dateformat') {
+    if (!%IsInitializedIntlObjectOfType(this, 'dateformat')) {
       throw new $TypeError('resolvedOptions method called on a non-object or ' +
           'on a object that is not Intl.DateTimeFormat.');
     }
 
     var format = this;
     var fromPattern = fromLDMLString(format.resolved.pattern);
     var userCalendar = ICU_CALENDAR_MAP[format.resolved.calendar];
     if (userCalendar === undefined) {
       // Use ICU name if we don't have a match. It shouldn't happen, but
       // it would be too strict to throw for this.
@@ skipping 61 matching lines @@
   if (dateValue === undefined) {
     dateMs = $Date.now();
   } else {
     dateMs = $Number(dateValue);
   }
 
   if (!$isFinite(dateMs)) {
     throw new $RangeError('Provided date is not in valid range.');
   }
 
-  return %InternalDateFormat(formatter.formatter, new $Date(dateMs));
+  return %InternalDateFormat(%GetImplFromInitializedIntlObject(formatter),
+                             new $Date(dateMs));
 }
 
 
 /**
  * Returns a Date object representing the result of calling ToString(value)
  * according to the effective locale and the formatting options of this
  * DateTimeFormat.
  * Returns undefined if date string cannot be parsed.
  */
 function parseDate(formatter, value) {
-  return %InternalDateParse(formatter.formatter, $String(value));
+  return %InternalDateParse(%GetImplFromInitializedIntlObject(formatter),
+                            $String(value));
 }
 
 
 // 0 because date is optional argument.
 addBoundMethod(Intl.DateTimeFormat, 'format', formatDate, 0);
 addBoundMethod(Intl.DateTimeFormat, 'v8Parse', parseDate, 1);
 
 
 /**
  * Returns canonical Area/Location name, or throws an exception if the zone
@@ skipping 27 matching lines @@
   }
 
   return result;
 }
 
 /**
  * Initializes the given object so it's a valid BreakIterator instance.
  * Useful for subclassing.
  */
 function initializeBreakIterator(iterator, locales, options) {
-  if (iterator.hasOwnProperty('__initializedIntlObject')) {
+  if (%IsInitializedIntlObject(iterator)) {
     throw new $TypeError('Trying to re-initialize v8BreakIterator object.');
   }
 
   if (options === undefined) {
     options = {};
   }
 
   var getOption = getGetOption(options, 'breakiterator');
 
   var internalOptions = {};
 
   defineWEProperty(internalOptions, 'type', getOption(
     'type', 'string', ['character', 'word', 'sentence', 'line'], 'word'));
 
   var locale = resolveLocale('breakiterator', locales, options);
   var resolved = $Object.defineProperties({}, {
     requestedLocale: {value: locale.locale, writable: true},
     type: {value: internalOptions.type, writable: true},
     locale: {writable: true}
   });
 
   var internalIterator = %CreateBreakIterator(locale.locale,
                                               internalOptions,
                                               resolved);
 
-  $Object.defineProperty(iterator, 'iterator', {value: internalIterator});
+  %MarkAsInitializedIntlObjectOfType(iterator, 'breakiterator',
+                                     internalIterator);
   $Object.defineProperty(iterator, 'resolved', {value: resolved});
-  $Object.defineProperty(iterator, '__initializedIntlObject',
-                         {value: 'breakiterator'});
 
   return iterator;
 }
 
 
 /**
  * Constructs Intl.v8BreakIterator object given optional locales and options
  * parameters.
  *
  * @constructor
@@ skipping 14 matching lines @@
 
 
 /**
  * BreakIterator resolvedOptions method.
  */
 %SetProperty(Intl.v8BreakIterator.prototype, 'resolvedOptions', function() {
     if (%_IsConstructCall()) {
       throw new $TypeError(ORDINARY_FUNCTION_CALLED_AS_CONSTRUCTOR);
     }
 
-    if (!this || typeof this !== 'object' ||
-        this.__initializedIntlObject !== 'breakiterator') {
+    if (!%IsInitializedIntlObjectOfType(this, 'breakiterator')) {
       throw new $TypeError('resolvedOptions method called on a non-object or ' +
           'on a object that is not Intl.v8BreakIterator.');
     }
 
     var segmenter = this;
     var locale = getOptimalLanguageTag(segmenter.resolved.requestedLocale,
                                        segmenter.resolved.locale);
 
     return {
       locale: locale,
@@ skipping 26 matching lines @@
 %FunctionSetName(Intl.v8BreakIterator.supportedLocalesOf, 'supportedLocalesOf');
 %FunctionRemovePrototype(Intl.v8BreakIterator.supportedLocalesOf);
 %SetNativeFlag(Intl.v8BreakIterator.supportedLocalesOf);
 
 
 /**
  * Adopts text to segment using the iterator. Old text, if present,
  * gets discarded.
  */
 function adoptText(iterator, text) {
-  %BreakIteratorAdoptText(iterator.iterator, $String(text));
+  %BreakIteratorAdoptText(%GetImplFromInitializedIntlObject(iterator),
+                          $String(text));
 }
 
 
 /**
  * Returns index of the first break in the string and moves current pointer.
  */
 function first(iterator) {
-  return %BreakIteratorFirst(iterator.iterator);
+  return %BreakIteratorFirst(%GetImplFromInitializedIntlObject(iterator));
 }
 
 
 /**
  * Returns the index of the next break and moves the pointer.
  */
 function next(iterator) {
-  return %BreakIteratorNext(iterator.iterator);
+  return %BreakIteratorNext(%GetImplFromInitializedIntlObject(iterator));
 }
 
 
 /**
  * Returns index of the current break.
  */
 function current(iterator) {
-  return %BreakIteratorCurrent(iterator.iterator);
+  return %BreakIteratorCurrent(%GetImplFromInitializedIntlObject(iterator));
 }
 
 
 /**
  * Returns type of the current break.
  */
 function breakType(iterator) {
-  return %BreakIteratorBreakType(iterator.iterator);
+  return %BreakIteratorBreakType(%GetImplFromInitializedIntlObject(iterator));
 }
 
 
 addBoundMethod(Intl.v8BreakIterator, 'adoptText', adoptText, 1);
 addBoundMethod(Intl.v8BreakIterator, 'first', first, 0);
 addBoundMethod(Intl.v8BreakIterator, 'next', next, 0);
 addBoundMethod(Intl.v8BreakIterator, 'current', current, 0);
 addBoundMethod(Intl.v8BreakIterator, 'breakType', breakType, 0);
 
 // Save references to Intl objects and methods we use, for added security.
@@ skipping 213 matching lines @@
   writable: true,
   configurable: true,
   enumerable: false
 });
 %FunctionSetName($Date.prototype.toLocaleTimeString, 'toLocaleTimeString');
 %FunctionRemovePrototype($Date.prototype.toLocaleTimeString);
 %SetNativeFlag($Date.prototype.toLocaleTimeString);
 
 return Intl;
 }())});