Migrate error messages, part 8.

src/typedarray.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.
 
 (function() {
 
 "use strict";
 
 %CheckIsBootstrapping();
 
@@ skipping 20 matching lines @@
 endmacro
 
 TYPED_ARRAYS(DECLARE_GLOBALS)
 
 // --------------- Typed Arrays ---------------------
 
 macro TYPED_ARRAY_CONSTRUCTOR(ARRAY_ID, NAME, ELEMENT_SIZE)
 function NAMEConstructByArrayBuffer(obj, buffer, byteOffset, length) {
   if (!IS_UNDEFINED(byteOffset)) {
       byteOffset =
-          ToPositiveInteger(byteOffset,  "invalid_typed_array_length");
+          ToPositiveInteger(byteOffset, kInvalidTypedArrayLength);
   }
   if (!IS_UNDEFINED(length)) {
-      length = ToPositiveInteger(length, "invalid_typed_array_length");
+      length = ToPositiveInteger(length, kInvalidTypedArrayLength);
   }
 
   var bufferByteLength = %_ArrayBufferGetByteLength(buffer);
   var offset;
   if (IS_UNDEFINED(byteOffset)) {
     offset = 0;
   } else {
     offset = byteOffset;
 
     if (offset % ELEMENT_SIZE !== 0) {
-      throw MakeRangeError("invalid_typed_array_alignment",
-          ["start offset", "NAME", ELEMENT_SIZE]);
+      throw MakeRangeError(kInvalidTypedArrayAlignment,
+                           "start offset", "NAME", ELEMENT_SIZE);
     }
     if (offset > bufferByteLength) {
-      throw MakeRangeError("invalid_typed_array_offset");
+      throw MakeRangeError(kInvalidTypedArrayOffset);
     }
   }
 
   var newByteLength;
   var newLength;
   if (IS_UNDEFINED(length)) {
     if (bufferByteLength % ELEMENT_SIZE !== 0) {
-      throw MakeRangeError("invalid_typed_array_alignment",
-        ["byte length", "NAME", ELEMENT_SIZE]);
+      throw MakeRangeError(kInvalidTypedArrayAlignment,
+                           "byte length", "NAME", ELEMENT_SIZE);
     }
     newByteLength = bufferByteLength - offset;
     newLength = newByteLength / ELEMENT_SIZE;
   } else {
     var newLength = length;
     newByteLength = newLength * ELEMENT_SIZE;
   }
   if ((offset + newByteLength > bufferByteLength)
       || (newLength > %_MaxSmi())) {
-    throw MakeRangeError("invalid_typed_array_length");
+    throw MakeRangeError(kInvalidTypedArrayLength);
   }
   %_TypedArrayInitialize(obj, ARRAY_ID, buffer, offset, newByteLength);
 }
 
 function NAMEConstructByLength(obj, length) {
   var l = IS_UNDEFINED(length) ?
-    0 : ToPositiveInteger(length, "invalid_typed_array_length");
+    0 : ToPositiveInteger(length, kInvalidTypedArrayLength);
   if (l > %_MaxSmi()) {
-    throw MakeRangeError("invalid_typed_array_length");
+    throw MakeRangeError(kInvalidTypedArrayLength);
   }
   var byteLength = l * ELEMENT_SIZE;
   if (byteLength > %_TypedArrayMaxSizeInHeap()) {
     var buffer = new GlobalArrayBuffer(byteLength);
     %_TypedArrayInitialize(obj, ARRAY_ID, buffer, 0, byteLength);
   } else {
     %_TypedArrayInitialize(obj, ARRAY_ID, null, 0, byteLength);
   }
 }
 
 function NAMEConstructByArrayLike(obj, arrayLike) {
   var length = arrayLike.length;
-  var l = ToPositiveInteger(length, "invalid_typed_array_length");
+  var l = ToPositiveInteger(length, kInvalidTypedArrayLength);
 
   if (l > %_MaxSmi()) {
-    throw MakeRangeError("invalid_typed_array_length");
+    throw MakeRangeError(kInvalidTypedArrayLength);
   }
   if(!%TypedArrayInitializeFromArrayLike(obj, ARRAY_ID, arrayLike, l)) {
     for (var i = 0; i < l; i++) {
       // It is crucial that we let any execptions from arrayLike[i]
       // propagate outside the function.
       obj[i] = arrayLike[i];
     }
   }
 }
 
@@ skipping 136 matching lines @@
   for (var i = leftIndex; i <= rightIndex; i++) {
     temp[i - leftIndex] = source[i];
   }
   for (i = leftIndex; i <= rightIndex; i++) {
     target[offset + i] = temp[i - leftIndex];
   }
 }
 
 function TypedArraySet(obj, offset) {
   var intOffset = IS_UNDEFINED(offset) ? 0 : TO_INTEGER(offset);
-  if (intOffset < 0) {
-    throw MakeTypeError("typed_array_set_negative_offset");
-  }
+  if (intOffset < 0) throw MakeTypeError(kTypedArraySetNegativeOffset);
 
   if (intOffset > %_MaxSmi()) {
-    throw MakeRangeError("typed_array_set_source_too_large");
+    throw MakeRangeError(kTypedArraySetSourceTooLarge);
   }
   switch (%TypedArraySetFastCases(this, obj, intOffset)) {
     // These numbers should be synchronized with runtime.cc.
     case 0: // TYPED_ARRAY_SET_TYPED_ARRAY_SAME_TYPE
       return;
     case 1: // TYPED_ARRAY_SET_TYPED_ARRAY_OVERLAPPING
       TypedArraySetFromOverlappingTypedArray(this, obj, intOffset);
       return;
     case 2: // TYPED_ARRAY_SET_TYPED_ARRAY_NONOVERLAPPING
       TypedArraySetFromArrayLike(this, obj, obj.length, intOffset);
       return;
     case 3: // TYPED_ARRAY_SET_NON_TYPED_ARRAY
       var l = obj.length;
       if (IS_UNDEFINED(l)) {
         if (IS_NUMBER(obj)) {
             // For number as a first argument, throw TypeError
             // instead of silently ignoring the call, so that
             // the user knows (s)he did something wrong.
             // (Consistent with Firefox and Blink/WebKit)
-            throw MakeTypeError("invalid_argument");
+            throw MakeTypeError(kInvalidArgument);
         }
         return;
       }
       if (intOffset + l > this.length) {
-        throw MakeRangeError("typed_array_set_source_too_large");
+        throw MakeRangeError(kTypedArraySetSourceTooLarge);
       }
       TypedArraySetFromArrayLike(this, obj, l, intOffset);
       return;
   }
 }
 
 function TypedArrayGetToStringTag() {
   if (!%IsTypedArray(this)) return;
   var name = %_ClassOf(this);
   if (IS_UNDEFINED(name)) return;
@@ skipping 27 matching lines @@
     "set", TypedArraySet
   ]);
 endmacro
 
 TYPED_ARRAYS(SETUP_TYPED_ARRAY)
 
 // --------------------------- DataView -----------------------------
 
 function DataViewConstructor(buffer, byteOffset, byteLength) { // length = 3
   if (%_IsConstructCall()) {
-    if (!IS_ARRAYBUFFER(buffer)) {
-      throw MakeTypeError('data_view_not_array_buffer', []);
-    }
+    if (!IS_ARRAYBUFFER(buffer)) throw MakeTypeError(kDataViewNotArrayBuffer);
     if (!IS_UNDEFINED(byteOffset)) {
-        byteOffset = ToPositiveInteger(byteOffset, 'invalid_data_view_offset');
+        byteOffset = ToPositiveInteger(byteOffset, kInvalidDataViewOffset);
     }
     if (!IS_UNDEFINED(byteLength)) {
         byteLength = TO_INTEGER(byteLength);
     }
 
     var bufferByteLength = %_ArrayBufferGetByteLength(buffer);
 
     var offset = IS_UNDEFINED(byteOffset) ?  0 : byteOffset;
-    if (offset > bufferByteLength) {
-      throw MakeRangeError('invalid_data_view_offset');
-    }
+    if (offset > bufferByteLength) throw MakeRangeError(kInvalidDataViewOffset);
 
     var length = IS_UNDEFINED(byteLength)
         ? bufferByteLength - offset
         : byteLength;
     if (length < 0 || offset + length > bufferByteLength) {
-      throw new MakeRangeError('invalid_data_view_length');
+      throw new MakeRangeError(kInvalidDataViewLength);
     }
     %_DataViewInitialize(this, buffer, offset, length);
   } else {
     throw MakeTypeError(kConstructorNotFunction, "DataView");
   }
 }
 
 function DataViewGetBufferJS() {
   if (!IS_DATAVIEW(this)) {
     throw MakeTypeError(kIncompatibleMethodReceiver, 'DataView.buffer', this);
@@ skipping 22 matching lines @@
   FUNCTION(Uint8)
   FUNCTION(Int16)
   FUNCTION(Uint16)
   FUNCTION(Int32)
   FUNCTION(Uint32)
   FUNCTION(Float32)
   FUNCTION(Float64)
 endmacro
 
 function ToPositiveDataViewOffset(offset) {
-  return ToPositiveInteger(offset, 'invalid_data_view_accessor_offset');
+  return ToPositiveInteger(offset, kInvalidDataViewAccessorOffset);
 }
 
 
 macro DATA_VIEW_GETTER_SETTER(TYPENAME)
 function DataViewGetTYPENAMEJS(offset, little_endian) {
   if (!IS_DATAVIEW(this)) {
     throw MakeTypeError(kIncompatibleMethodReceiver,
                         'DataView.getTYPENAME', this);
   }
-  if (%_ArgumentsLength() < 1) {
-    throw MakeTypeError('invalid_argument');
-  }
+  if (%_ArgumentsLength() < 1) throw MakeTypeError(kInvalidArgument);
   return %DataViewGetTYPENAME(this,
                           ToPositiveDataViewOffset(offset),
                           !!little_endian);
 }
 
 function DataViewSetTYPENAMEJS(offset, value, little_endian) {
   if (!IS_DATAVIEW(this)) {
     throw MakeTypeError(kIncompatibleMethodReceiver,
                         'DataView.setTYPENAME', this);
   }
-  if (%_ArgumentsLength() < 2) {
-    throw MakeTypeError('invalid_argument');
-  }
+  if (%_ArgumentsLength() < 2) throw MakeTypeError(kInvalidArgument);
   %DataViewSetTYPENAME(this,
                    ToPositiveDataViewOffset(offset),
                    TO_NUMBER_INLINE(value),
                    !!little_endian);
 }
 endmacro
 
 DATA_VIEW_TYPES(DATA_VIEW_GETTER_SETTER)
 
 // Setup the DataView constructor.
@@ skipping 30 matching lines @@
   "setUint32", DataViewSetUint32JS,
 
   "getFloat32", DataViewGetFloat32JS,
   "setFloat32", DataViewSetFloat32JS,
 
   "getFloat64", DataViewGetFloat64JS,
   "setFloat64", DataViewSetFloat64JS
 ]);
 
 })();