| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2006-2008 the V8 project authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 // This file contains support for URI manipulations written in | |
| 6 // JavaScript. | |
| 7 | |
| 8 (function(global, utils) { | |
| 9 | |
| 10 "use strict"; | |
| 11 | |
| 12 %CheckIsBootstrapping(); | |
| 13 | |
| 14 //- ------------------------------------------------------------------ | |
| 15 // Imports | |
| 16 | |
| 17 var GlobalObject = global.Object; | |
| 18 var GlobalArray = global.Array; | |
| 19 var InternalArray = utils.InternalArray; | |
| 20 | |
| 21 // ------------------------------------------------------------------- | |
| 22 // Define internal helper functions. | |
| 23 | |
| 24 function HexValueOf(code) { | |
| 25 // 0-9 | |
| 26 if (code >= 48 && code <= 57) return code - 48; | |
| 27 // A-F | |
| 28 if (code >= 65 && code <= 70) return code - 55; | |
| 29 // a-f | |
| 30 if (code >= 97 && code <= 102) return code - 87; | |
| 31 | |
| 32 return -1; | |
| 33 } | |
| 34 | |
| 35 // Does the char code correspond to an alpha-numeric char. | |
| 36 function isAlphaNumeric(cc) { | |
| 37 // a - z | |
| 38 if (97 <= cc && cc <= 122) return true; | |
| 39 // A - Z | |
| 40 if (65 <= cc && cc <= 90) return true; | |
| 41 // 0 - 9 | |
| 42 if (48 <= cc && cc <= 57) return true; | |
| 43 | |
| 44 return false; | |
| 45 } | |
| 46 | |
| 47 // Lazily initialized. | |
| 48 var hexCharCodeArray = 0; | |
| 49 | |
| 50 function URIAddEncodedOctetToBuffer(octet, result, index) { | |
| 51 result[index++] = 37; // Char code of '%'. | |
| 52 result[index++] = hexCharCodeArray[octet >> 4]; | |
| 53 result[index++] = hexCharCodeArray[octet & 0x0F]; | |
| 54 return index; | |
| 55 } | |
| 56 | |
| 57 function URIEncodeOctets(octets, result, index) { | |
| 58 if (hexCharCodeArray === 0) { | |
| 59 hexCharCodeArray = [48, 49, 50, 51, 52, 53, 54, 55, 56, 57, | |
| 60 65, 66, 67, 68, 69, 70]; | |
| 61 } | |
| 62 index = URIAddEncodedOctetToBuffer(octets[0], result, index); | |
| 63 if (octets[1]) index = URIAddEncodedOctetToBuffer(octets[1], result, index); | |
| 64 if (octets[2]) index = URIAddEncodedOctetToBuffer(octets[2], result, index); | |
| 65 if (octets[3]) index = URIAddEncodedOctetToBuffer(octets[3], result, index); | |
| 66 return index; | |
| 67 } | |
| 68 | |
| 69 function URIEncodeSingle(cc, result, index) { | |
| 70 var x = (cc >> 12) & 0xF; | |
| 71 var y = (cc >> 6) & 63; | |
| 72 var z = cc & 63; | |
| 73 var octets = new GlobalArray(3); | |
| 74 if (cc <= 0x007F) { | |
| 75 octets[0] = cc; | |
| 76 } else if (cc <= 0x07FF) { | |
| 77 octets[0] = y + 192; | |
| 78 octets[1] = z + 128; | |
| 79 } else { | |
| 80 octets[0] = x + 224; | |
| 81 octets[1] = y + 128; | |
| 82 octets[2] = z + 128; | |
| 83 } | |
| 84 return URIEncodeOctets(octets, result, index); | |
| 85 } | |
| 86 | |
| 87 function URIEncodePair(cc1 , cc2, result, index) { | |
| 88 var u = ((cc1 >> 6) & 0xF) + 1; | |
| 89 var w = (cc1 >> 2) & 0xF; | |
| 90 var x = cc1 & 3; | |
| 91 var y = (cc2 >> 6) & 0xF; | |
| 92 var z = cc2 & 63; | |
| 93 var octets = new GlobalArray(4); | |
| 94 octets[0] = (u >> 2) + 240; | |
| 95 octets[1] = (((u & 3) << 4) | w) + 128; | |
| 96 octets[2] = ((x << 4) | y) + 128; | |
| 97 octets[3] = z + 128; | |
| 98 return URIEncodeOctets(octets, result, index); | |
| 99 } | |
| 100 | |
| 101 function URIHexCharsToCharCode(highChar, lowChar) { | |
| 102 var highCode = HexValueOf(highChar); | |
| 103 var lowCode = HexValueOf(lowChar); | |
| 104 if (highCode == -1 || lowCode == -1) throw MakeURIError(); | |
| 105 return (highCode << 4) | lowCode; | |
| 106 } | |
| 107 | |
| 108 // Callers must ensure that |result| is a sufficiently long sequential | |
| 109 // two-byte string! | |
| 110 function URIDecodeOctets(octets, result, index) { | |
| 111 var value; | |
| 112 var o0 = octets[0]; | |
| 113 if (o0 < 0x80) { | |
| 114 value = o0; | |
| 115 } else if (o0 < 0xc2) { | |
| 116 throw MakeURIError(); | |
| 117 } else { | |
| 118 var o1 = octets[1]; | |
| 119 if (o0 < 0xe0) { | |
| 120 var a = o0 & 0x1f; | |
| 121 if ((o1 < 0x80) || (o1 > 0xbf)) throw MakeURIError(); | |
| 122 var b = o1 & 0x3f; | |
| 123 value = (a << 6) + b; | |
| 124 if (value < 0x80 || value > 0x7ff) throw MakeURIError(); | |
| 125 } else { | |
| 126 var o2 = octets[2]; | |
| 127 if (o0 < 0xf0) { | |
| 128 var a = o0 & 0x0f; | |
| 129 if ((o1 < 0x80) || (o1 > 0xbf)) throw MakeURIError(); | |
| 130 var b = o1 & 0x3f; | |
| 131 if ((o2 < 0x80) || (o2 > 0xbf)) throw MakeURIError(); | |
| 132 var c = o2 & 0x3f; | |
| 133 value = (a << 12) + (b << 6) + c; | |
| 134 if ((value < 0x800) || (value > 0xffff)) throw MakeURIError(); | |
| 135 } else { | |
| 136 var o3 = octets[3]; | |
| 137 if (o0 < 0xf8) { | |
| 138 var a = (o0 & 0x07); | |
| 139 if ((o1 < 0x80) || (o1 > 0xbf)) throw MakeURIError(); | |
| 140 var b = (o1 & 0x3f); | |
| 141 if ((o2 < 0x80) || (o2 > 0xbf)) { | |
| 142 throw MakeURIError(); | |
| 143 } | |
| 144 var c = (o2 & 0x3f); | |
| 145 if ((o3 < 0x80) || (o3 > 0xbf)) throw MakeURIError(); | |
| 146 var d = (o3 & 0x3f); | |
| 147 value = (a << 18) + (b << 12) + (c << 6) + d; | |
| 148 if ((value < 0x10000) || (value > 0x10ffff)) throw MakeURIError(); | |
| 149 } else { | |
| 150 throw MakeURIError(); | |
| 151 } | |
| 152 } | |
| 153 } | |
| 154 } | |
| 155 if (0xD800 <= value && value <= 0xDFFF) throw MakeURIError(); | |
| 156 if (value < 0x10000) { | |
| 157 %_TwoByteSeqStringSetChar(index++, value, result); | |
| 158 } else { | |
| 159 %_TwoByteSeqStringSetChar(index++, (value >> 10) + 0xd7c0, result); | |
| 160 %_TwoByteSeqStringSetChar(index++, (value & 0x3ff) + 0xdc00, result); | |
| 161 } | |
| 162 return index; | |
| 163 } | |
| 164 | |
| 165 // ECMA-262, section 15.1.3 | |
| 166 function Encode(uri, unescape) { | |
| 167 uri = TO_STRING(uri); | |
| 168 var uriLength = uri.length; | |
| 169 var array = new InternalArray(uriLength); | |
| 170 var index = 0; | |
| 171 for (var k = 0; k < uriLength; k++) { | |
| 172 var cc1 = %_StringCharCodeAt(uri, k); | |
| 173 if (unescape(cc1)) { | |
| 174 array[index++] = cc1; | |
| 175 } else { | |
| 176 if (cc1 >= 0xDC00 && cc1 <= 0xDFFF) throw MakeURIError(); | |
| 177 if (cc1 < 0xD800 || cc1 > 0xDBFF) { | |
| 178 index = URIEncodeSingle(cc1, array, index); | |
| 179 } else { | |
| 180 k++; | |
| 181 if (k == uriLength) throw MakeURIError(); | |
| 182 var cc2 = %_StringCharCodeAt(uri, k); | |
| 183 if (cc2 < 0xDC00 || cc2 > 0xDFFF) throw MakeURIError(); | |
| 184 index = URIEncodePair(cc1, cc2, array, index); | |
| 185 } | |
| 186 } | |
| 187 } | |
| 188 | |
| 189 var result = %NewString(array.length, NEW_ONE_BYTE_STRING); | |
| 190 for (var i = 0; i < array.length; i++) { | |
| 191 %_OneByteSeqStringSetChar(i, array[i], result); | |
| 192 } | |
| 193 return result; | |
| 194 } | |
| 195 | |
| 196 // ECMA-262, section 15.1.3 | |
| 197 function Decode(uri, reserved) { | |
| 198 uri = TO_STRING(uri); | |
| 199 var uriLength = uri.length; | |
| 200 var one_byte = %NewString(uriLength, NEW_ONE_BYTE_STRING); | |
| 201 var index = 0; | |
| 202 var k = 0; | |
| 203 | |
| 204 // Optimistically assume one-byte string. | |
| 205 for ( ; k < uriLength; k++) { | |
| 206 var code = %_StringCharCodeAt(uri, k); | |
| 207 if (code == 37) { // '%' | |
| 208 if (k + 2 >= uriLength) throw MakeURIError(); | |
| 209 var cc = URIHexCharsToCharCode(%_StringCharCodeAt(uri, k+1), | |
| 210 %_StringCharCodeAt(uri, k+2)); | |
| 211 if (cc >> 7) break; // Assumption wrong, two-byte string. | |
| 212 if (reserved(cc)) { | |
| 213 %_OneByteSeqStringSetChar(index++, 37, one_byte); // '%'. | |
| 214 %_OneByteSeqStringSetChar(index++, %_StringCharCodeAt(uri, k+1), | |
| 215 one_byte); | |
| 216 %_OneByteSeqStringSetChar(index++, %_StringCharCodeAt(uri, k+2), | |
| 217 one_byte); | |
| 218 } else { | |
| 219 %_OneByteSeqStringSetChar(index++, cc, one_byte); | |
| 220 } | |
| 221 k += 2; | |
| 222 } else { | |
| 223 if (code > 0x7f) break; // Assumption wrong, two-byte string. | |
| 224 %_OneByteSeqStringSetChar(index++, code, one_byte); | |
| 225 } | |
| 226 } | |
| 227 | |
| 228 one_byte = %TruncateString(one_byte, index); | |
| 229 if (k == uriLength) return one_byte; | |
| 230 | |
| 231 // Write into two byte string. | |
| 232 var two_byte = %NewString(uriLength - k, NEW_TWO_BYTE_STRING); | |
| 233 index = 0; | |
| 234 | |
| 235 for ( ; k < uriLength; k++) { | |
| 236 var code = %_StringCharCodeAt(uri, k); | |
| 237 if (code == 37) { // '%' | |
| 238 if (k + 2 >= uriLength) throw MakeURIError(); | |
| 239 var cc = URIHexCharsToCharCode(%_StringCharCodeAt(uri, ++k), | |
| 240 %_StringCharCodeAt(uri, ++k)); | |
| 241 if (cc >> 7) { | |
| 242 var n = 0; | |
| 243 while (((cc << ++n) & 0x80) != 0) { } | |
| 244 if (n == 1 || n > 4) throw MakeURIError(); | |
| 245 var octets = new GlobalArray(n); | |
| 246 octets[0] = cc; | |
| 247 if (k + 3 * (n - 1) >= uriLength) throw MakeURIError(); | |
| 248 for (var i = 1; i < n; i++) { | |
| 249 if (uri[++k] != '%') throw MakeURIError(); | |
| 250 octets[i] = URIHexCharsToCharCode(%_StringCharCodeAt(uri, ++k), | |
| 251 %_StringCharCodeAt(uri, ++k)); | |
| 252 } | |
| 253 index = URIDecodeOctets(octets, two_byte, index); | |
| 254 } else if (reserved(cc)) { | |
| 255 %_TwoByteSeqStringSetChar(index++, 37, two_byte); // '%'. | |
| 256 %_TwoByteSeqStringSetChar(index++, %_StringCharCodeAt(uri, k - 1), | |
| 257 two_byte); | |
| 258 %_TwoByteSeqStringSetChar(index++, %_StringCharCodeAt(uri, k), | |
| 259 two_byte); | |
| 260 } else { | |
| 261 %_TwoByteSeqStringSetChar(index++, cc, two_byte); | |
| 262 } | |
| 263 } else { | |
| 264 %_TwoByteSeqStringSetChar(index++, code, two_byte); | |
| 265 } | |
| 266 } | |
| 267 | |
| 268 two_byte = %TruncateString(two_byte, index); | |
| 269 return one_byte + two_byte; | |
| 270 } | |
| 271 | |
| 272 // ------------------------------------------------------------------- | |
| 273 // Define exported functions. | |
| 274 | |
| 275 // ECMA-262 - B.2.1. | |
| 276 function URIEscapeJS(s) { | |
| 277 return %URIEscape(s); | |
| 278 } | |
| 279 | |
| 280 // ECMA-262 - B.2.2. | |
| 281 function URIUnescapeJS(s) { | |
| 282 return %URIUnescape(s); | |
| 283 } | |
| 284 | |
| 285 // ECMA-262 - 15.1.3.1. | |
| 286 function URIDecode(uri) { | |
| 287 var reservedPredicate = function(cc) { | |
| 288 // #$ | |
| 289 if (35 <= cc && cc <= 36) return true; | |
| 290 // & | |
| 291 if (cc == 38) return true; | |
| 292 // +, | |
| 293 if (43 <= cc && cc <= 44) return true; | |
| 294 // / | |
| 295 if (cc == 47) return true; | |
| 296 // :; | |
| 297 if (58 <= cc && cc <= 59) return true; | |
| 298 // = | |
| 299 if (cc == 61) return true; | |
| 300 // ?@ | |
| 301 if (63 <= cc && cc <= 64) return true; | |
| 302 | |
| 303 return false; | |
| 304 }; | |
| 305 return Decode(uri, reservedPredicate); | |
| 306 } | |
| 307 | |
| 308 // ECMA-262 - 15.1.3.2. | |
| 309 function URIDecodeComponent(component) { | |
| 310 var reservedPredicate = function(cc) { return false; }; | |
| 311 return Decode(component, reservedPredicate); | |
| 312 } | |
| 313 | |
| 314 // ECMA-262 - 15.1.3.3. | |
| 315 function URIEncode(uri) { | |
| 316 var unescapePredicate = function(cc) { | |
| 317 if (isAlphaNumeric(cc)) return true; | |
| 318 // ! | |
| 319 if (cc == 33) return true; | |
| 320 // #$ | |
| 321 if (35 <= cc && cc <= 36) return true; | |
| 322 // &'()*+,-./ | |
| 323 if (38 <= cc && cc <= 47) return true; | |
| 324 // :; | |
| 325 if (58 <= cc && cc <= 59) return true; | |
| 326 // = | |
| 327 if (cc == 61) return true; | |
| 328 // ?@ | |
| 329 if (63 <= cc && cc <= 64) return true; | |
| 330 // _ | |
| 331 if (cc == 95) return true; | |
| 332 // ~ | |
| 333 if (cc == 126) return true; | |
| 334 | |
| 335 return false; | |
| 336 }; | |
| 337 return Encode(uri, unescapePredicate); | |
| 338 } | |
| 339 | |
| 340 // ECMA-262 - 15.1.3.4 | |
| 341 function URIEncodeComponent(component) { | |
| 342 var unescapePredicate = function(cc) { | |
| 343 if (isAlphaNumeric(cc)) return true; | |
| 344 // ! | |
| 345 if (cc == 33) return true; | |
| 346 // '()* | |
| 347 if (39 <= cc && cc <= 42) return true; | |
| 348 // -. | |
| 349 if (45 <= cc && cc <= 46) return true; | |
| 350 // _ | |
| 351 if (cc == 95) return true; | |
| 352 // ~ | |
| 353 if (cc == 126) return true; | |
| 354 | |
| 355 return false; | |
| 356 }; | |
| 357 return Encode(component, unescapePredicate); | |
| 358 } | |
| 359 | |
| 360 // ------------------------------------------------------------------- | |
| 361 // Install exported functions. | |
| 362 | |
| 363 // Set up non-enumerable URI functions on the global object and set | |
| 364 // their names. | |
| 365 utils.InstallFunctions(global, DONT_ENUM, [ | |
| 366 "escape", URIEscapeJS, | |
| 367 "unescape", URIUnescapeJS, | |
| 368 "decodeURI", URIDecode, | |
| 369 "decodeURIComponent", URIDecodeComponent, | |
| 370 "encodeURI", URIEncode, | |
| 371 "encodeURIComponent", URIEncodeComponent | |
| 372 ]); | |
| 373 | |
| 374 }) | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1398733002:
Move builtin JavaScript sources into own directory. (Closed)
Base URL: https://chromium.googlesource.com/v8/v8.git@master