Hide RegExp and String initialization in a closure.

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.
  */
 (function() {
 
 "use strict";
 
 %CheckIsBootstrapping();
 
 var GlobalDate = global.Date;
+var GlobalRegExp = global.RegExp;
+var GlobalString = global.String;
 
 var undefined = global.undefined;
 
 var Intl = {};
 
 %AddNamedProperty(global, "Intl", Intl, DONT_ENUM);
 
 var AVAILABLE_SERVICES = ['collator',
                           'numberformat',
                           'dateformat',
@@ skipping 19 matching lines @@
  */
 var DEFAULT_ICU_LOCALE = undefined;
 
 /**
  * Unicode extension regular expression.
  */
 var UNICODE_EXTENSION_RE = undefined;
 
 function GetUnicodeExtensionRE() {
   if (UNICODE_EXTENSION_RE === undefined) {
-    UNICODE_EXTENSION_RE = new $RegExp('-u(-[a-z0-9]{2,8})+', 'g');
+    UNICODE_EXTENSION_RE = new GlobalRegExp('-u(-[a-z0-9]{2,8})+', 'g');
   }
   return UNICODE_EXTENSION_RE;
 }
 
 /**
  * Matches any Unicode extension.
  */
 var ANY_EXTENSION_RE = undefined;
 
 function GetAnyExtensionRE() {
   if (ANY_EXTENSION_RE === undefined) {
-    ANY_EXTENSION_RE = new $RegExp('-[a-z0-9]{1}-.*', 'g');
+    ANY_EXTENSION_RE = new GlobalRegExp('-[a-z0-9]{1}-.*', 'g');
   }
   return ANY_EXTENSION_RE;
 }
 
 /**
  * Replace quoted text (single quote, anything but the quote and quote again).
  */
 var QUOTED_STRING_RE = undefined;
 
 function GetQuotedStringRE() {
   if (QUOTED_STRING_RE === undefined) {
-    QUOTED_STRING_RE = new $RegExp("'[^']+'", 'g');
+    QUOTED_STRING_RE = new GlobalRegExp("'[^']+'", 'g');
   }
   return QUOTED_STRING_RE;
 }
 
 /**
  * Matches valid service name.
  */
 var SERVICE_RE = undefined;
 
 function GetServiceRE() {
   if (SERVICE_RE === undefined) {
     SERVICE_RE =
-        new $RegExp('^(collator|numberformat|dateformat|breakiterator)$');
+        new GlobalRegExp('^(collator|numberformat|dateformat|breakiterator)$');
   }
   return SERVICE_RE;
 }
 
 /**
  * Validates a language tag against bcp47 spec.
  * Actual value is assigned on first run.
  */
 var LANGUAGE_TAG_RE = undefined;
 
@@ skipping 29 matching lines @@
 }
 
 /**
  * Matches valid IANA time zone names.
  */
 var TIMEZONE_NAME_CHECK_RE = undefined;
 
 function GetTimezoneNameCheckRE() {
   if (TIMEZONE_NAME_CHECK_RE === undefined) {
     TIMEZONE_NAME_CHECK_RE =
-        new $RegExp('^([A-Za-z]+)/([A-Za-z]+)(?:_([A-Za-z]+))*$');
+        new GlobalRegExp('^([A-Za-z]+)/([A-Za-z]+)(?:_([A-Za-z]+))*$');
   }
   return TIMEZONE_NAME_CHECK_RE;
 }
 
 /**
  * Maps ICU calendar names into LDML type.
  */
 var ICU_CALENDAR_MAP = {
   'gregorian': 'gregory',
   'japanese': 'japanese',
@@ skipping 127 matching lines @@
 
   // Provide defaults if matcher was not specified.
   if (options === undefined) {
     options = {};
   } else {
     options = ToObject(options);
   }
 
   var matcher = options.localeMatcher;
   if (matcher !== undefined) {
-    matcher = $String(matcher);
+    matcher = GlobalString(matcher);
     if (matcher !== 'lookup' && matcher !== 'best fit') {
       throw new $RangeError('Illegal value for localeMatcher:' + matcher);
     }
   } else {
     matcher = 'best fit';
   }
 
   var requestedLocales = initializeLocaleList(locales);
 
   // Cache these, they don't ever change per service.
@@ skipping 65 matching lines @@
   }
 
   var getOption = function getOption(property, type, values, defaultValue) {
     if (options[property] !== undefined) {
       var value = options[property];
       switch (type) {
         case 'boolean':
           value = $Boolean(value);
           break;
         case 'string':
-          value = $String(value);
+          value = GlobalString(value);
           break;
         case 'number':
           value = $Number(value);
           break;
         default:
           throw new $Error('Internal error. Wrong value type.');
       }
       if (values !== undefined && values.indexOf(value) === -1) {
         throw new $RangeError('Value ' + value + ' out of range for ' + caller +
                              ' options property ' + property);
@@ skipping 135 matching lines @@
  * Unicode extensions for passing parameters to ICU).
  * It's used for extension-option pairs only, e.g. kn-normalization, but not
  * for 'sensitivity' since it doesn't have extension equivalent.
  * Extensions like nu and ca don't have options equivalent, so we place
  * undefined in the map.property to denote that.
  */
 function setOptions(inOptions, extensionMap, keyValues, getOption, outOptions) {
   var extension = '';
 
   var updateExtension = function updateExtension(key, value) {
-    return '-' + key + '-' + $String(value);
+    return '-' + key + '-' + GlobalString(value);
   }
 
   var updateProperty = function updateProperty(property, type, value) {
     if (type === 'boolean' && (typeof value === 'string')) {
       value = (value === 'true') ? true : false;
     }
 
     if (property !== undefined) {
       defineWEProperty(outOptions, property, value);
     }
@@ skipping 68 matching lines @@
   if (original === resolved) {
     return original;
   }
 
   var locales = %GetLanguageTagVariants([original, resolved]);
   if (locales[0].maximized !== locales[1].maximized) {
     return resolved;
   }
 
   // Preserve extensions of resolved locale, but swap base tags with original.
-  var resolvedBase = new $RegExp('^' + locales[1].base);
+  var resolvedBase = new GlobalRegExp('^' + locales[1].base);
   return resolved.replace(resolvedBase, locales[0].base);
 }
 
 
 /**
  * Returns an Object that contains all of supported locales for a given
  * service.
  * In addition to the supported locales we add xx-ZZ locale for each xx-Yyyy-ZZ
  * that is supported. This is required by the spec.
  */
@@ skipping 69 matching lines @@
 /**
  * Canonicalizes the language tag, or throws in case the tag is invalid.
  */
 function canonicalizeLanguageTag(localeID) {
   // null is typeof 'object' so we have to do extra check.
   if (typeof localeID !== 'string' && typeof localeID !== 'object' ||
       IS_NULL(localeID)) {
     throw new $TypeError('Language ID should be string or object.');
   }
 
-  var localeString = $String(localeID);
+  var localeString = GlobalString(localeID);
 
   if (isValidLanguageTag(localeString) === false) {
     throw new $RangeError('Invalid language tag: ' + localeString);
   }
 
   // This call will strip -kn but not -kn-true extensions.
   // ICU bug filled - http://bugs.icu-project.org/trac/ticket/9265.
   // TODO(cira): check if -u-kn-true-kc-true-kh-true still throws after
   // upgrade to ICU 4.9.
   var tag = %CanonicalizeLanguageTag(localeString);
@@ skipping 108 matching lines @@
   var alphanum = '(' + alpha + '|' + digit + ')';
   var regular = '(art-lojban|cel-gaulish|no-bok|no-nyn|zh-guoyu|zh-hakka|' +
                 'zh-min|zh-min-nan|zh-xiang)';
   var irregular = '(en-GB-oed|i-ami|i-bnn|i-default|i-enochian|i-hak|' +
                   'i-klingon|i-lux|i-mingo|i-navajo|i-pwn|i-tao|i-tay|' +
                   'i-tsu|sgn-BE-FR|sgn-BE-NL|sgn-CH-DE)';
   var grandfathered = '(' + irregular + '|' + regular + ')';
   var privateUse = '(x(-' + alphanum + '{1,8})+)';
 
   var singleton = '(' + digit + '|[A-WY-Za-wy-z])';
-  LANGUAGE_SINGLETON_RE = new $RegExp('^' + singleton + '$', 'i');
+  LANGUAGE_SINGLETON_RE = new GlobalRegExp('^' + singleton + '$', 'i');
 
   var extension = '(' + singleton + '(-' + alphanum + '{2,8})+)';
 
   var variant = '(' + alphanum + '{5,8}|(' + digit + alphanum + '{3}))';
-  LANGUAGE_VARIANT_RE = new $RegExp('^' + variant + '$', 'i');
+  LANGUAGE_VARIANT_RE = new GlobalRegExp('^' + variant + '$', 'i');
 
   var region = '(' + alpha + '{2}|' + digit + '{3})';
   var script = '(' + alpha + '{4})';
   var extLang = '(' + alpha + '{3}(-' + alpha + '{3}){0,2})';
   var language = '(' + alpha + '{2,3}(-' + extLang + ')?|' + alpha + '{4}|' +
                  alpha + '{5,8})';
   var langTag = language + '(-' + script + ')?(-' + region + ')?(-' +
                 variant + ')*(-' + extension + ')*(-' + privateUse + ')?';
 
   var languageTag =
       '^(' + langTag + '|' + privateUse + '|' + grandfathered + ')$';
-  LANGUAGE_TAG_RE = new $RegExp(languageTag, 'i');
+  LANGUAGE_TAG_RE = new GlobalRegExp(languageTag, 'i');
 }
 
 /**
  * Initializes the given object so it's a valid Collator instance.
  * Useful for subclassing.
  */
 function initializeCollator(collator, locales, options) {
   if (%IsInitializedIntlObject(collator)) {
     throw new $TypeError('Trying to re-initialize Collator object.');
   }
@@ skipping 152 matching lines @@
  * 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(%GetImplFromInitializedIntlObject(collator),
-                          $String(x), $String(y));
+                          GlobalString(x), GlobalString(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 232 matching lines @@
   return %InternalNumberFormat(%GetImplFromInitializedIntlObject(formatter),
                                number);
 }
 
 
 /**
  * Returns a Number that represents string value that was passed in.
  */
 function parseNumber(formatter, value) {
   return %InternalNumberParse(%GetImplFromInitializedIntlObject(formatter),
-                              $String(value));
+                              GlobalString(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 383 matching lines @@
 
 
 /**
  * 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(%GetImplFromInitializedIntlObject(formatter),
-                            $String(value));
+                            GlobalString(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 140 matching lines @@
 %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),
-                          $String(text));
+                          GlobalString(text));
 }
 
 
 /**
  * Returns index of the first break in the string and moves current pointer.
  */
 function first(iterator) {
   return %BreakIteratorFirst(%GetImplFromInitializedIntlObject(iterator));
 }
 
@@ skipping 62 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($String.prototype, 'localeCompare', function(that) {
+OverrideFunction(GlobalString.prototype, 'localeCompare', function(that) {
     if (%_IsConstructCall()) {
       throw new $TypeError(ORDINARY_FUNCTION_CALLED_AS_CONSTRUCTOR);
     }
 
     if (IS_NULL_OR_UNDEFINED(this)) {
       throw new $TypeError('Method invoked on undefined or null value.');
     }
 
     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($String.prototype, 'normalize', function(that) {
+OverrideFunction(GlobalString.prototype, 'normalize', function(that) {
     if (%_IsConstructCall()) {
       throw new $TypeError(ORDINARY_FUNCTION_CALLED_AS_CONSTRUCTOR);
     }
 
     CHECK_OBJECT_COERCIBLE(this, "String.prototype.normalize");
 
-    var form = $String(%_Arguments(0) || 'NFC');
+    var form = GlobalString(%_Arguments(0) || 'NFC');
 
     var normalizationForm = NORMALIZATION_FORMS.indexOf(form);
     if (normalizationForm === -1) {
       throw new $RangeError('The normalization form should be one of '
           + NORMALIZATION_FORMS.join(', ') + '.');
     }
 
     return %StringNormalize(this, normalizationForm);
   }
 );
@@ skipping 88 matching lines @@
     }
 
     var locales = %_Arguments(0);
     var options = %_Arguments(1);
     return toLocaleDateTime(
         this, locales, options, 'time', 'time', 'dateformattime');
   }
 );
 
 })();