v8/src/uri.js

// Copyright 2006-2008 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.

"use strict";

// This file relies on the fact that the following declaration has been made
// in runtime.js:
// var $Array = global.Array;

// -------------------------------------------------------------------

// This file contains support for URI manipulations written in
// JavaScript.


(function() {

  // -------------------------------------------------------------------
  // Define internal helper functions.

  function HexValueOf(code) {
    // 0-9
    if (code >= 48 && code <= 57) return code - 48;
    // A-F
    if (code >= 65 && code <= 70) return code - 55;
    // a-f
    if (code >= 97 && code <= 102) return code - 87;

    return -1;
  }

  // Does the char code correspond to an alpha-numeric char.
  function isAlphaNumeric(cc) {
    // a - z
    if (97 <= cc && cc <= 122) return true;
    // A - Z
    if (65 <= cc && cc <= 90) return true;
    // 0 - 9
    if (48 <= cc && cc <= 57) return true;

    return false;
  }

  //Lazily initialized.
  var hexCharCodeArray = 0;

  function URIAddEncodedOctetToBuffer(octet, result, index) {
    result[index++] = 37; // Char code of '%'.
    result[index++] = hexCharCodeArray[octet >> 4];
    result[index++] = hexCharCodeArray[octet & 0x0F];
    return index;
  }

  function URIEncodeOctets(octets, result, index) {
    if (hexCharCodeArray === 0) {
      hexCharCodeArray = [48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
                          65, 66, 67, 68, 69, 70];
    }
    index = URIAddEncodedOctetToBuffer(octets[0], result, index);
    if (octets[1]) index = URIAddEncodedOctetToBuffer(octets[1], result, index);
    if (octets[2]) index = URIAddEncodedOctetToBuffer(octets[2], result, index);
    if (octets[3]) index = URIAddEncodedOctetToBuffer(octets[3], result, index);
    return index;
  }

  function URIEncodeSingle(cc, result, index) {
    var x = (cc >> 12) & 0xF;
    var y = (cc >> 6) & 63;
    var z = cc & 63;
    var octets = new $Array(3);
    if (cc <= 0x007F) {
      octets[0] = cc;
    } else if (cc <= 0x07FF) {
      octets[0] = y + 192;
      octets[1] = z + 128;
    } else {
      octets[0] = x + 224;
      octets[1] = y + 128;
      octets[2] = z + 128;
    }
    return URIEncodeOctets(octets, result, index);
  }

  function URIEncodePair(cc1 , cc2, result, index) {
    var u = ((cc1 >> 6) & 0xF) + 1;
    var w = (cc1 >> 2) & 0xF;
    var x = cc1 & 3;
    var y = (cc2 >> 6) & 0xF;
    var z = cc2 & 63;
    var octets = new $Array(4);
    octets[0] = (u >> 2) + 240;
    octets[1] = (((u & 3) << 4) | w) + 128;
    octets[2] = ((x << 4) | y) + 128;
    octets[3] = z + 128;
    return URIEncodeOctets(octets, result, index);
  }

  function URIHexCharsToCharCode(highChar, lowChar) {
    var highCode = HexValueOf(highChar);
    var lowCode = HexValueOf(lowChar);
    if (highCode == -1 || lowCode == -1) {
      throw new $URIError("URI malformed");
    }
    return (highCode << 4) | lowCode;
  }

  // Callers must ensure that |result| is a sufficiently long sequential
  // two-byte string!
  function URIDecodeOctets(octets, result, index) {
    var value;
    var o0 = octets[0];
    if (o0 < 0x80) {
      value = o0;
    } else if (o0 < 0xc2) {
      throw new $URIError("URI malformed");
    } else {
      var o1 = octets[1];
      if (o0 < 0xe0) {
        var a = o0 & 0x1f;
        if ((o1 < 0x80) || (o1 > 0xbf)) {
          throw new $URIError("URI malformed");
        }
        var b = o1 & 0x3f;
        value = (a << 6) + b;
        if (value < 0x80 || value > 0x7ff) {
          throw new $URIError("URI malformed");
        }
      } else {
        var o2 = octets[2];
        if (o0 < 0xf0) {
          var a = o0 & 0x0f;
          if ((o1 < 0x80) || (o1 > 0xbf)) {
            throw new $URIError("URI malformed");
          }
          var b = o1 & 0x3f;
          if ((o2 < 0x80) || (o2 > 0xbf)) {
            throw new $URIError("URI malformed");
          }
          var c = o2 & 0x3f;
          value = (a << 12) + (b << 6) + c;
          if ((value < 0x800) || (value > 0xffff)) {
            throw new $URIError("URI malformed");
          }
        } else {
          var o3 = octets[3];
          if (o0 < 0xf8) {
            var a = (o0 & 0x07);
            if ((o1 < 0x80) || (o1 > 0xbf)) {
              throw new $URIError("URI malformed");
            }
            var b = (o1 & 0x3f);
            if ((o2 < 0x80) || (o2 > 0xbf)) {
              throw new $URIError("URI malformed");
            }
            var c = (o2 & 0x3f);
            if ((o3 < 0x80) || (o3 > 0xbf)) {
              throw new $URIError("URI malformed");
            }
            var d = (o3 & 0x3f);
            value = (a << 18) + (b << 12) + (c << 6) + d;
            if ((value < 0x10000) || (value > 0x10ffff)) {
              throw new $URIError("URI malformed");
            }
          } else {
            throw new $URIError("URI malformed");
          }
        }
      }
    }
    if (0xD800 <= value && value <= 0xDFFF) {
      throw new $URIError("URI malformed");
    }
    if (value < 0x10000) {
      %_TwoByteSeqStringSetChar(index++, value, result);
    } else {
      %_TwoByteSeqStringSetChar(index++, (value >> 10) + 0xd7c0, result);
      %_TwoByteSeqStringSetChar(index++, (value & 0x3ff) + 0xdc00, result);
    }
    return index;
  }

  // ECMA-262, section 15.1.3
  function Encode(uri, unescape) {
    var uriLength = uri.length;
    var array = new InternalArray(uriLength);
    var index = 0;
    for (var k = 0; k < uriLength; k++) {
      var cc1 = uri.charCodeAt(k);
      if (unescape(cc1)) {
        array[index++] = cc1;
      } else {
        if (cc1 >= 0xDC00 && cc1 <= 0xDFFF) throw new $URIError("URI malformed");
        if (cc1 < 0xD800 || cc1 > 0xDBFF) {
          index = URIEncodeSingle(cc1, array, index);
        } else {
          k++;
          if (k == uriLength) throw new $URIError("URI malformed");
          var cc2 = uri.charCodeAt(k);
          if (cc2 < 0xDC00 || cc2 > 0xDFFF) throw new $URIError("URI malformed");
          index = URIEncodePair(cc1, cc2, array, index);
        }
      }
    }

    var result = %NewString(array.length, NEW_ONE_BYTE_STRING);
    for (var i = 0; i < array.length; i++) {
      %_OneByteSeqStringSetChar(i, array[i], result);
    }
    return result;
  }

  // ECMA-262, section 15.1.3
  function Decode(uri, reserved) {
    var uriLength = uri.length;
    var one_byte = %NewString(uriLength, NEW_ONE_BYTE_STRING);
    var index = 0;
    var k = 0;

    // Optimistically assume one-byte string.
    for ( ; k < uriLength; k++) {
      var code = uri.charCodeAt(k);
      if (code == 37) {  // '%'
        if (k + 2 >= uriLength) throw new $URIError("URI malformed");
        var cc = URIHexCharsToCharCode(uri.charCodeAt(k+1), uri.charCodeAt(k+2));
        if (cc >> 7) break;  // Assumption wrong, two-byte string.
        if (reserved(cc)) {
          %_OneByteSeqStringSetChar(index++, 37, one_byte);  // '%'.
          %_OneByteSeqStringSetChar(index++, uri.charCodeAt(k+1), one_byte);
          %_OneByteSeqStringSetChar(index++, uri.charCodeAt(k+2), one_byte);
        } else {
          %_OneByteSeqStringSetChar(index++, cc, one_byte);
        }
        k += 2;
      } else {
        if (code > 0x7f) break;  // Assumption wrong, two-byte string.
        %_OneByteSeqStringSetChar(index++, code, one_byte);
      }
    }

    one_byte = %TruncateString(one_byte, index);
    if (k == uriLength) return one_byte;

    // Write into two byte string.
    var two_byte = %NewString(uriLength - k, NEW_TWO_BYTE_STRING);
    index = 0;

    for ( ; k < uriLength; k++) {
      var code = uri.charCodeAt(k);
      if (code == 37) {  // '%'
        if (k + 2 >= uriLength) throw new $URIError("URI malformed");
        var cc = URIHexCharsToCharCode(uri.charCodeAt(++k), uri.charCodeAt(++k));
        if (cc >> 7) {
          var n = 0;
          while (((cc << ++n) & 0x80) != 0) { }
          if (n == 1 || n > 4) throw new $URIError("URI malformed");
          var octets = new $Array(n);
          octets[0] = cc;
          if (k + 3 * (n - 1) >= uriLength) throw new $URIError("URI malformed");
          for (var i = 1; i < n; i++) {
            if (uri.charAt(++k) != '%') throw new $URIError("URI malformed");
            octets[i] = URIHexCharsToCharCode(uri.charCodeAt(++k),
                                              uri.charCodeAt(++k));
          }
          index = URIDecodeOctets(octets, two_byte, index);
        } else  if (reserved(cc)) {
          %_TwoByteSeqStringSetChar(index++, 37, two_byte);  // '%'.
          %_TwoByteSeqStringSetChar(index++, uri.charCodeAt(k - 1), two_byte);
          %_TwoByteSeqStringSetChar(index++, uri.charCodeAt(k), two_byte);
        } else {
          %_TwoByteSeqStringSetChar(index++, cc, two_byte);
        }
      } else {
        %_TwoByteSeqStringSetChar(index++, code, two_byte);
      }
    }

    two_byte = %TruncateString(two_byte, index);
    return one_byte + two_byte;
  }

  // -------------------------------------------------------------------
  // Define exported functions.

  // ECMA-262 - B.2.1.
  function URIEscapeJS(str) {
    var s = ToString(str);
    return %URIEscape(s);
  }

  // ECMA-262 - B.2.2.
  function URIUnescapeJS(str) {
    var s = ToString(str);
    return %URIUnescape(s);
  }

  // ECMA-262 - 15.1.3.1.
  function URIDecode(uri) {
    var reservedPredicate = function(cc) {
      // #$
      if (35 <= cc && cc <= 36) return true;
      // &
      if (cc == 38) return true;
      // +,
      if (43 <= cc && cc <= 44) return true;
      // /
      if (cc == 47) return true;
      // :;
      if (58 <= cc && cc <= 59) return true;
      // =
      if (cc == 61) return true;
      // ?@
      if (63 <= cc && cc <= 64) return true;

      return false;
    };
    var string = ToString(uri);
    return Decode(string, reservedPredicate);
  }

  // ECMA-262 - 15.1.3.2.
  function URIDecodeComponent(component) {
    var reservedPredicate = function(cc) { return false; };
    var string = ToString(component);
    return Decode(string, reservedPredicate);
  }

  // ECMA-262 - 15.1.3.3.
  function URIEncode(uri) {
    var unescapePredicate = function(cc) {
      if (isAlphaNumeric(cc)) return true;
      // !
      if (cc == 33) return true;
      // #$
      if (35 <= cc && cc <= 36) return true;
      // &'()*+,-./
      if (38 <= cc && cc <= 47) return true;
      // :;
      if (58 <= cc && cc <= 59) return true;
      // =
      if (cc == 61) return true;
      // ?@
      if (63 <= cc && cc <= 64) return true;
      // _
      if (cc == 95) return true;
      // ~
      if (cc == 126) return true;

      return false;
    };
    var string = ToString(uri);
    return Encode(string, unescapePredicate);
  }

  // ECMA-262 - 15.1.3.4
  function URIEncodeComponent(component) {
    var unescapePredicate = function(cc) {
      if (isAlphaNumeric(cc)) return true;
      // !
      if (cc == 33) return true;
      // '()*
      if (39 <= cc && cc <= 42) return true;
      // -.
      if (45 <= cc && cc <= 46) return true;
      // _
      if (cc == 95) return true;
      // ~
      if (cc == 126) return true;

      return false;
    };
    var string = ToString(component);
    return Encode(string, unescapePredicate);
  }

  // -------------------------------------------------------------------
  // Install exported functions.

  %CheckIsBootstrapping();

  // Set up non-enumerable URI functions on the global object and set
  // their names.
  InstallFunctions(global, DONT_ENUM, $Array(
      "escape", URIEscapeJS,
      "unescape", URIUnescapeJS,
      "decodeURI", URIDecode,
      "decodeURIComponent", URIDecodeComponent,
      "encodeURI", URIEncode,
      "encodeURIComponent", URIEncodeComponent
  ));

})();