Wrap v8natives.js into a function.

src/i18n.js

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // ECMAScript 402 API implementation.
 
 /**
  * Intl object is a single object that has some named properties,
  * all of which are constructors.
  */
@@ skipping 236 matching lines @@
           // DateTimeFormat.format needs to be 0 arg method, but can stil
           // receive optional dateValue param. If one was provided, pass it
           // along.
           if (%_ArgumentsLength() > 0) {
             return implementation(that, %_Arguments(0));
           } else {
             return implementation(that);
           }
         }
       }
-      SetFunctionName(boundMethod, internalName);
+      $setFunctionName(boundMethod, internalName);
       %FunctionRemovePrototype(boundMethod);
       %SetNativeFlag(boundMethod);
       this[internalName] = boundMethod;
     }
     return this[internalName];
   }
 
-  SetFunctionName(getter, methodName);
+  $setFunctionName(getter, methodName);
   %FunctionRemovePrototype(getter);
   %SetNativeFlag(getter);
 
-  ObjectDefineProperty(obj.prototype, methodName, {
+  $objectDefineProperty(obj.prototype, methodName, {
     get: getter,
     enumerable: false,
     configurable: true
   });
 }
 
 
 /**
  * Returns an intersection of locales and service supported locales.
  * Parameter locales is treated as a priority list.
@@ skipping 298 matching lines @@
   return extension === ''? '' : '-u' + extension;
 }
 
 
 /**
  * Converts all OwnProperties into
  * configurable: false, writable: false, enumerable: true.
  */
 function freezeArray(array) {
   array.forEach(function(element, index) {
-    ObjectDefineProperty(array, index, {value: element,
-                                          configurable: false,
-                                          writable: false,
-                                          enumerable: true});
+    $objectDefineProperty(array, index, {value: element,
+                                         configurable: false,
+                                         writable: false,
+                                         enumerable: true});
   });
 
-  ObjectDefineProperty(array, 'length', {value: array.length,
-                                         writable: false});
+  $objectDefineProperty(array, 'length', {value: array.length,
+                                          writable: false});
   return array;
 }
 
 
 /**
  * It's sometimes desireable to leave user requested locale instead of ICU
  * supported one (zh-TW is equivalent to zh-Hant-TW, so we should keep shorter
  * one, if that was what user requested).
  * This function returns user specified tag if its maximized form matches ICU
  * resolved locale. If not we return ICU result.
@@ skipping 40 matching lines @@
 
   return available;
 }
 
 
 /**
  * Defines a property and sets writable and enumerable to true.
  * Configurable is false by default.
  */
 function defineWEProperty(object, property, value) {
-  ObjectDefineProperty(object, property,
-                       {value: value, writable: true, enumerable: true});
+  $objectDefineProperty(object, property,
+                        {value: value, writable: true, enumerable: true});
 }
 
 
 /**
  * Adds property to an object if the value is not undefined.
  * Sets configurable descriptor to false.
  */
 function addWEPropertyIfDefined(object, property, value) {
   if (value !== undefined) {
     defineWEProperty(object, property, value);
   }
 }
 
 
 /**
  * Defines a property and sets writable, enumerable and configurable to true.
  */
 function defineWECProperty(object, property, value) {
-  ObjectDefineProperty(object, property,
-                       {value: value,
-                        writable: true,
-                        enumerable: true,
-                        configurable: true});
+  $objectDefineProperty(object, property, {value: value,
+                                           writable: true,
+                                           enumerable: true,
+                                           configurable: true});
 }
 
 
 /**
  * Adds property to an object if the value is not undefined.
  * Sets all descriptors to true.
  */
 function addWECPropertyIfDefined(object, property, value) {
   if (value !== undefined) {
     defineWECProperty(object, property, value);
@@ skipping 219 matching lines @@
     extension = '-u-co-search';
   }
   defineWEProperty(internalOptions, 'collation', collation);
 
   var requestedLocale = locale.locale + extension;
 
   // We define all properties C++ code may produce, to prevent security
   // problems. If malicious user decides to redefine Object.prototype.locale
   // we can't just use plain x.locale = 'us' or in C++ Set("locale", "us").
   // ObjectDefineProperties will either succeed defining or throw an error.
-  var resolved = ObjectDefineProperties({}, {
+  var resolved = $objectDefineProperties({}, {
     caseFirst: {writable: true},
     collation: {value: internalOptions.collation, writable: true},
     ignorePunctuation: {writable: true},
     locale: {writable: true},
     numeric: {writable: true},
     requestedLocale: {value: requestedLocale, writable: true},
     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.
   %MarkAsInitializedIntlObjectOfType(collator, 'collator', internalCollator);
-  ObjectDefineProperty(collator, 'resolved', {value: resolved});
+  $objectDefineProperty(collator, 'resolved', {value: resolved});
 
   return collator;
 }
 
 
 /**
  * Constructs Intl.Collator object given optional locales and options
  * parameters.
  *
  * @constructor
@@ skipping 34 matching lines @@
       usage: coll.resolved.usage,
       sensitivity: coll.resolved.sensitivity,
       ignorePunctuation: coll.resolved.ignorePunctuation,
       numeric: coll.resolved.numeric,
       caseFirst: coll.resolved.caseFirst,
       collation: coll.resolved.collation
     };
   },
   DONT_ENUM
 );
-SetFunctionName(Intl.Collator.prototype.resolvedOptions, 'resolvedOptions');
+$setFunctionName(Intl.Collator.prototype.resolvedOptions, 'resolvedOptions');
 %FunctionRemovePrototype(Intl.Collator.prototype.resolvedOptions);
 %SetNativeFlag(Intl.Collator.prototype.resolvedOptions);
 
 
 /**
  * Returns the subset of the given locale list for which this locale list
  * has a matching (possibly fallback) locale. Locales appear in the same
  * order in the returned list as in the input list.
  * Options are optional parameter.
  */
 %AddNamedProperty(Intl.Collator, 'supportedLocalesOf', function(locales) {
     if (%_IsConstructCall()) {
       throw MakeTypeError(kOrdinaryFunctionCalledAsConstructor);
     }
 
     return supportedLocalesOf('collator', locales, %_Arguments(1));
   },
   DONT_ENUM
 );
-SetFunctionName(Intl.Collator.supportedLocalesOf, 'supportedLocalesOf');
+$setFunctionName(Intl.Collator.supportedLocalesOf, 'supportedLocalesOf');
 %FunctionRemovePrototype(Intl.Collator.supportedLocalesOf);
 %SetNativeFlag(Intl.Collator.supportedLocalesOf);
 
 
 /**
  * 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
@@ skipping 100 matching lines @@
   defineWEProperty(internalOptions, 'useGrouping', getOption(
     'useGrouping', 'boolean', undefined, true));
 
   // ICU prefers options to be passed using -u- extension key/values for
   // number format, so we need to build that.
   var extensionMap = parseExtension(locale.extension);
   var extension = setOptions(options, extensionMap, NUMBER_FORMAT_KEY_MAP,
                              getOption, internalOptions);
 
   var requestedLocale = locale.locale + extension;
-  var resolved = ObjectDefineProperties({}, {
+  var resolved = $objectDefineProperties({}, {
     currency: {writable: true},
     currencyDisplay: {writable: true},
     locale: {writable: true},
     maximumFractionDigits: {writable: true},
     minimumFractionDigits: {writable: true},
     minimumIntegerDigits: {writable: true},
     numberingSystem: {writable: true},
     requestedLocale: {value: requestedLocale, writable: true},
     style: {value: internalOptions.style, writable: true},
     useGrouping: {writable: true}
   });
   if (internalOptions.hasOwnProperty('minimumSignificantDigits')) {
     defineWEProperty(resolved, 'minimumSignificantDigits', undefined);
   }
   if (internalOptions.hasOwnProperty('maximumSignificantDigits')) {
     defineWEProperty(resolved, 'maximumSignificantDigits', undefined);
   }
   var formatter = %CreateNumberFormat(requestedLocale,
                                       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') {
-    ObjectDefineProperty(resolved, 'currencyDisplay', {value: currencyDisplay,
-                                                       writable: true});
+    $objectDefineProperty(resolved, 'currencyDisplay', {value: currencyDisplay,
+                                                        writable: true});
   }
 
   %MarkAsInitializedIntlObjectOfType(numberFormat, 'numberformat', formatter);
-  ObjectDefineProperty(numberFormat, 'resolved', {value: resolved});
+  $objectDefineProperty(numberFormat, 'resolved', {value: resolved});
 
   return numberFormat;
 }
 
 
 /**
  * Constructs Intl.NumberFormat object given optional locales and options
  * parameters.
  *
  * @constructor
@@ skipping 52 matching lines @@
 
     if (format.resolved.hasOwnProperty('maximumSignificantDigits')) {
       defineWECProperty(result, 'maximumSignificantDigits',
                         format.resolved.maximumSignificantDigits);
     }
 
     return result;
   },
   DONT_ENUM
 );
-SetFunctionName(Intl.NumberFormat.prototype.resolvedOptions,
+$setFunctionName(Intl.NumberFormat.prototype.resolvedOptions,
                  'resolvedOptions');
 %FunctionRemovePrototype(Intl.NumberFormat.prototype.resolvedOptions);
 %SetNativeFlag(Intl.NumberFormat.prototype.resolvedOptions);
 
 
 /**
  * Returns the subset of the given locale list for which this locale list
  * has a matching (possibly fallback) locale. Locales appear in the same
  * order in the returned list as in the input list.
  * Options are optional parameter.
  */
 %AddNamedProperty(Intl.NumberFormat, 'supportedLocalesOf', function(locales) {
     if (%_IsConstructCall()) {
       throw MakeTypeError(kOrdinaryFunctionCalledAsConstructor);
     }
 
     return supportedLocalesOf('numberformat', locales, %_Arguments(1));
   },
   DONT_ENUM
 );
-SetFunctionName(Intl.NumberFormat.supportedLocalesOf, 'supportedLocalesOf');
+$setFunctionName(Intl.NumberFormat.supportedLocalesOf, 'supportedLocalesOf');
 %FunctionRemovePrototype(Intl.NumberFormat.supportedLocalesOf);
 %SetNativeFlag(Intl.NumberFormat.supportedLocalesOf);
 
 
 /**
  * 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) {
@@ skipping 175 matching lines @@
     needsDefault = false;
   }
 
   if ((required === 'time' || required === 'any') &&
       (options.hour !== undefined || options.minute !== undefined ||
        options.second !== undefined)) {
     needsDefault = false;
   }
 
   if (needsDefault && (defaults === 'date' || defaults === 'all')) {
-    ObjectDefineProperty(options, 'year', {value: 'numeric',
+    $objectDefineProperty(options, 'year', {value: 'numeric',
+                                            writable: true,
+                                            enumerable: true,
+                                            configurable: true});
+    $objectDefineProperty(options, 'month', {value: 'numeric',
+                                             writable: true,
+                                             enumerable: true,
+                                             configurable: true});
+    $objectDefineProperty(options, 'day', {value: 'numeric',
                                            writable: true,
                                            enumerable: true,
                                            configurable: true});
-    ObjectDefineProperty(options, 'month', {value: 'numeric',
+  }
+
+  if (needsDefault && (defaults === 'time' || defaults === 'all')) {
+    $objectDefineProperty(options, 'hour', {value: 'numeric',
                                             writable: true,
                                             enumerable: true,
                                             configurable: true});
-    ObjectDefineProperty(options, 'day', {value: 'numeric',
-                                          writable: true,
-                                          enumerable: true,
-                                          configurable: true});
-  }
-
-  if (needsDefault && (defaults === 'time' || defaults === 'all')) {
-    ObjectDefineProperty(options, 'hour', {value: 'numeric',
-                                             writable: true,
-                                             enumerable: true,
-                                             configurable: true});
-    ObjectDefineProperty(options, 'minute', {value: 'numeric',
-                                               writable: true,
-                                               enumerable: true,
-                                               configurable: true});
-    ObjectDefineProperty(options, 'second', {value: 'numeric',
-                                               writable: true,
-                                               enumerable: true,
-                                               configurable: true});
+    $objectDefineProperty(options, 'minute', {value: 'numeric',
+                                              writable: true,
+                                              enumerable: true,
+                                              configurable: true});
+    $objectDefineProperty(options, 'second', {value: 'numeric',
+                                              writable: true,
+                                              enumerable: true,
+                                              configurable: true});
   }
 
   return options;
 }
 
 
 /**
  * Initializes the given object so it's a valid DateTimeFormat instance.
  * Useful for subclassing.
  */
@@ skipping 27 matching lines @@
   var tz = canonicalizeTimeZoneID(options.timeZone);
 
   // ICU prefers options to be passed using -u- extension key/values, so
   // we need to build that.
   var internalOptions = {};
   var extensionMap = parseExtension(locale.extension);
   var extension = setOptions(options, extensionMap, DATETIME_FORMAT_KEY_MAP,
                              getOption, internalOptions);
 
   var requestedLocale = locale.locale + extension;
-  var resolved = ObjectDefineProperties({}, {
+  var resolved = $objectDefineProperties({}, {
     calendar: {writable: true},
     day: {writable: true},
     era: {writable: true},
     hour12: {writable: true},
     hour: {writable: true},
     locale: {writable: true},
     minute: {writable: true},
     month: {writable: true},
     numberingSystem: {writable: true},
     pattern: {writable: true},
     requestedLocale: {value: requestedLocale, writable: true},
     second: {writable: true},
     timeZone: {writable: true},
     timeZoneName: {writable: true},
     tz: {value: tz, writable: true},
     weekday: {writable: true},
     year: {writable: true}
   });
 
   var formatter = %CreateDateTimeFormat(
     requestedLocale, {skeleton: ldmlString, timeZone: tz}, resolved);
 
   if (tz !== undefined && tz !== resolved.timeZone) {
     throw MakeRangeError(kUnsupportedTimeZone, tz);
   }
 
   %MarkAsInitializedIntlObjectOfType(dateFormat, 'dateformat', formatter);
-  ObjectDefineProperty(dateFormat, 'resolved', {value: resolved});
+  $objectDefineProperty(dateFormat, 'resolved', {value: resolved});
 
   return dateFormat;
 }
 
 
 /**
  * Constructs Intl.DateTimeFormat object given optional locales and options
  * parameters.
  *
  * @constructor
@@ skipping 52 matching lines @@
     addWECPropertyIfDefined(result, 'weekday', fromPattern.weekday);
     addWECPropertyIfDefined(result, 'hour12', fromPattern.hour12);
     addWECPropertyIfDefined(result, 'hour', fromPattern.hour);
     addWECPropertyIfDefined(result, 'minute', fromPattern.minute);
     addWECPropertyIfDefined(result, 'second', fromPattern.second);
 
     return result;
   },
   DONT_ENUM
 );
-SetFunctionName(Intl.DateTimeFormat.prototype.resolvedOptions,
+$setFunctionName(Intl.DateTimeFormat.prototype.resolvedOptions,
                 'resolvedOptions');
 %FunctionRemovePrototype(Intl.DateTimeFormat.prototype.resolvedOptions);
 %SetNativeFlag(Intl.DateTimeFormat.prototype.resolvedOptions);
 
 
 /**
  * Returns the subset of the given locale list for which this locale list
  * has a matching (possibly fallback) locale. Locales appear in the same
  * order in the returned list as in the input list.
  * Options are optional parameter.
  */
 %AddNamedProperty(Intl.DateTimeFormat, 'supportedLocalesOf', function(locales) {
     if (%_IsConstructCall()) {
       throw MakeTypeError(kOrdinaryFunctionCalledAsConstructor);
     }
 
     return supportedLocalesOf('dateformat', locales, %_Arguments(1));
   },
   DONT_ENUM
 );
-SetFunctionName(Intl.DateTimeFormat.supportedLocalesOf, 'supportedLocalesOf');
+$setFunctionName(Intl.DateTimeFormat.supportedLocalesOf, 'supportedLocalesOf');
 %FunctionRemovePrototype(Intl.DateTimeFormat.supportedLocalesOf);
 %SetNativeFlag(Intl.DateTimeFormat.supportedLocalesOf);
 
 
 /**
  * Returns a String value representing the result of calling ToNumber(date)
  * according to the effective locale and the formatting options of this
  * DateTimeFormat.
  */
 function formatDate(formatter, dateValue) {
@@ skipping 74 matching lines @@
   }
 
   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 = ObjectDefineProperties({}, {
+  var resolved = $objectDefineProperties({}, {
     requestedLocale: {value: locale.locale, writable: true},
     type: {value: internalOptions.type, writable: true},
     locale: {writable: true}
   });
 
   var internalIterator = %CreateBreakIterator(locale.locale,
                                               internalOptions,
                                               resolved);
 
   %MarkAsInitializedIntlObjectOfType(iterator, 'breakiterator',
                                      internalIterator);
-  ObjectDefineProperty(iterator, 'resolved', {value: resolved});
+  $objectDefineProperty(iterator, 'resolved', {value: resolved});
 
   return iterator;
 }
 
 
 /**
  * Constructs Intl.v8BreakIterator object given optional locales and options
  * parameters.
  *
  * @constructor
@@ skipping 30 matching lines @@
     var locale = getOptimalLanguageTag(segmenter.resolved.requestedLocale,
                                        segmenter.resolved.locale);
 
     return {
       locale: locale,
       type: segmenter.resolved.type
     };
   },
   DONT_ENUM
 );
-SetFunctionName(Intl.v8BreakIterator.prototype.resolvedOptions,
+$setFunctionName(Intl.v8BreakIterator.prototype.resolvedOptions,
                 'resolvedOptions');
 %FunctionRemovePrototype(Intl.v8BreakIterator.prototype.resolvedOptions);
 %SetNativeFlag(Intl.v8BreakIterator.prototype.resolvedOptions);
 
 
 /**
  * Returns the subset of the given locale list for which this locale list
  * has a matching (possibly fallback) locale. Locales appear in the same
  * order in the returned list as in the input list.
  * Options are optional parameter.
  */
 %AddNamedProperty(Intl.v8BreakIterator, 'supportedLocalesOf',
   function(locales) {
     if (%_IsConstructCall()) {
       throw MakeTypeError(kOrdinaryFunctionCalledAsConstructor);
     }
 
     return supportedLocalesOf('breakiterator', locales, %_Arguments(1));
   },
   DONT_ENUM
 );
-SetFunctionName(Intl.v8BreakIterator.supportedLocalesOf, 'supportedLocalesOf');
+$setFunctionName(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(%GetImplFromInitializedIntlObject(iterator),
@@ skipping 73 matching lines @@
     return defaultObjects[service];
   }
   return new savedObjects[service](locales, useOptions);
 }
 
 
 /**
  * Compares this and that, and returns less than 0, 0 or greater than 0 value.
  * Overrides the built-in method.
  */
-OverrideFunction(GlobalString.prototype, 'localeCompare', function(that) {
+$overrideFunction(GlobalString.prototype, 'localeCompare', function(that) {
     if (%_IsConstructCall()) {
       throw MakeTypeError(kOrdinaryFunctionCalledAsConstructor);
     }
 
     if (IS_NULL_OR_UNDEFINED(this)) {
       throw MakeTypeError(kMethodInvokedOnNullOrUndefined);
     }
 
     var locales = %_Arguments(1);
     var options = %_Arguments(2);
     var collator = cachedOrNewService('collator', locales, options);
     return compare(collator, this, that);
   }
 );
 
 
 /**
  * Unicode normalization. This method is called with one argument that
  * specifies the normalization form.
  * If none is specified, "NFC" is assumed.
  * If the form is not one of "NFC", "NFD", "NFKC", or "NFKD", then throw
  * a RangeError Exception.
  */
-OverrideFunction(GlobalString.prototype, 'normalize', function(that) {
+$overrideFunction(GlobalString.prototype, 'normalize', function(that) {
     if (%_IsConstructCall()) {
       throw MakeTypeError(kOrdinaryFunctionCalledAsConstructor);
     }
 
     CHECK_OBJECT_COERCIBLE(this, "String.prototype.normalize");
 
     var form = GlobalString(%_Arguments(0) || 'NFC');
 
     var normalizationForm = NORMALIZATION_FORMS.indexOf(form);
     if (normalizationForm === -1) {
       throw MakeRangeError(kNormalizationForm, NORMALIZATION_FORMS.join(', '));
     }
 
     return %StringNormalize(this, normalizationForm);
   }
 );
 
 
 /**
  * Formats a Number object (this) using locale and options values.
  * If locale or options are omitted, defaults are used.
  */
-OverrideFunction(GlobalNumber.prototype, 'toLocaleString', function() {
+$overrideFunction(GlobalNumber.prototype, 'toLocaleString', function() {
     if (%_IsConstructCall()) {
       throw MakeTypeError(kOrdinaryFunctionCalledAsConstructor);
     }
 
     if (!(this instanceof GlobalNumber) && typeof(this) !== 'number') {
       throw MakeTypeError(kMethodInvokedOnWrongType, "Number");
     }
 
     var locales = %_Arguments(0);
     var options = %_Arguments(1);
@@ skipping 22 matching lines @@
 
   return formatDate(dateFormat, date);
 }
 
 
 /**
  * Formats a Date object (this) using locale and options values.
  * If locale or options are omitted, defaults are used - both date and time are
  * present in the output.
  */
-OverrideFunction(GlobalDate.prototype, 'toLocaleString', function() {
+$overrideFunction(GlobalDate.prototype, 'toLocaleString', function() {
     if (%_IsConstructCall()) {
       throw MakeTypeError(kOrdinaryFunctionCalledAsConstructor);
     }
 
     var locales = %_Arguments(0);
     var options = %_Arguments(1);
     return toLocaleDateTime(
         this, locales, options, 'any', 'all', 'dateformatall');
   }
 );
 
 
 /**
  * Formats a Date object (this) using locale and options values.
  * If locale or options are omitted, defaults are used - only date is present
  * in the output.
  */
-OverrideFunction(GlobalDate.prototype, 'toLocaleDateString', function() {
+$overrideFunction(GlobalDate.prototype, 'toLocaleDateString', function() {
     if (%_IsConstructCall()) {
       throw MakeTypeError(kOrdinaryFunctionCalledAsConstructor);
     }
 
     var locales = %_Arguments(0);
     var options = %_Arguments(1);
     return toLocaleDateTime(
         this, locales, options, 'date', 'date', 'dateformatdate');
   }
 );
 
 
 /**
  * Formats a Date object (this) using locale and options values.
  * If locale or options are omitted, defaults are used - only time is present
  * in the output.
  */
-OverrideFunction(GlobalDate.prototype, 'toLocaleTimeString', function() {
+$overrideFunction(GlobalDate.prototype, 'toLocaleTimeString', function() {
     if (%_IsConstructCall()) {
       throw MakeTypeError(kOrdinaryFunctionCalledAsConstructor);
     }
 
     var locales = %_Arguments(0);
     var options = %_Arguments(1);
     return toLocaleDateTime(
         this, locales, options, 'time', 'time', 'dateformattime');
   }
 );
 
 })();