?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
msvcp90: Change basic_ios<wchar_t>::imbue to match char version.
[wine.git] / dlls / jscript / global.c
blob1c0f72c9794abb3d6a70bdf2eb19c7acc251a3e2
1 /*
2 * Copyright 2008 Jacek Caban for CodeWeavers
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17 */
18
19 #include "config.h"
20 #include "wine/port.h"
21
22 #include <math.h>
23 #include <limits.h>
24
25 #include "jscript.h"
26 #include "engine.h"
27
28 #include "wine/debug.h"
29
30 WINE_DEFAULT_DEBUG_CHANNEL(jscript);
31
32 #define LONGLONG_MAX (((LONGLONG)0x7fffffff<<32)|0xffffffff)
33
34 static const WCHAR NaNW[] = {'N','a','N',0};
35 static const WCHAR InfinityW[] = {'I','n','f','i','n','i','t','y',0};
36 static const WCHAR ArrayW[] = {'A','r','r','a','y',0};
37 static const WCHAR BooleanW[] = {'B','o','o','l','e','a','n',0};
38 static const WCHAR DateW[] = {'D','a','t','e',0};
39 static const WCHAR ErrorW[] = {'E','r','r','o','r',0};
40 static const WCHAR EvalErrorW[] = {'E','v','a','l','E','r','r','o','r',0};
41 static const WCHAR RangeErrorW[] = {'R','a','n','g','e','E','r','r','o','r',0};
42 static const WCHAR ReferenceErrorW[] = {'R','e','f','e','r','e','n','c','e','E','r','r','o','r',0};
43 static const WCHAR SyntaxErrorW[] = {'S','y','n','t','a','x','E','r','r','o','r',0};
44 static const WCHAR TypeErrorW[] = {'T','y','p','e','E','r','r','o','r',0};
45 static const WCHAR URIErrorW[] = {'U','R','I','E','r','r','o','r',0};
46 static const WCHAR FunctionW[] = {'F','u','n','c','t','i','o','n',0};
47 static const WCHAR NumberW[] = {'N','u','m','b','e','r',0};
48 static const WCHAR ObjectW[] = {'O','b','j','e','c','t',0};
49 static const WCHAR StringW[] = {'S','t','r','i','n','g',0};
50 static const WCHAR RegExpW[] = {'R','e','g','E','x','p',0};
51 static const WCHAR RegExpErrorW[] = {'R','e','g','E','x','p','E','r','r','o','r',0};
52 static const WCHAR ActiveXObjectW[] = {'A','c','t','i','v','e','X','O','b','j','e','c','t',0};
53 static const WCHAR VBArrayW[] = {'V','B','A','r','r','a','y',0};
54 static const WCHAR EnumeratorW[] = {'E','n','u','m','e','r','a','t','o','r',0};
55 static const WCHAR escapeW[] = {'e','s','c','a','p','e',0};
56 static const WCHAR evalW[] = {'e','v','a','l',0};
57 static const WCHAR isNaNW[] = {'i','s','N','a','N',0};
58 static const WCHAR isFiniteW[] = {'i','s','F','i','n','i','t','e',0};
59 static const WCHAR parseIntW[] = {'p','a','r','s','e','I','n','t',0};
60 static const WCHAR parseFloatW[] = {'p','a','r','s','e','F','l','o','a','t',0};
61 static const WCHAR unescapeW[] = {'u','n','e','s','c','a','p','e',0};
62 static const WCHAR _GetObjectW[] = {'G','e','t','O','b','j','e','c','t',0};
63 static const WCHAR ScriptEngineW[] = {'S','c','r','i','p','t','E','n','g','i','n','e',0};
64 static const WCHAR ScriptEngineMajorVersionW[] =
65 {'S','c','r','i','p','t','E','n','g','i','n','e','M','a','j','o','r','V','e','r','s','i','o','n',0};
66 static const WCHAR ScriptEngineMinorVersionW[] =
67 {'S','c','r','i','p','t','E','n','g','i','n','e','M','i','n','o','r','V','e','r','s','i','o','n',0};
68 static const WCHAR ScriptEngineBuildVersionW[] =
69 {'S','c','r','i','p','t','E','n','g','i','n','e','B','u','i','l','d','V','e','r','s','i','o','n',0};
70 static const WCHAR CollectGarbageW[] = {'C','o','l','l','e','c','t','G','a','r','b','a','g','e',0};
71 static const WCHAR MathW[] = {'M','a','t','h',0};
72 static const WCHAR encodeURIW[] = {'e','n','c','o','d','e','U','R','I',0};
73 static const WCHAR decodeURIW[] = {'d','e','c','o','d','e','U','R','I',0};
74 static const WCHAR encodeURIComponentW[] = {'e','n','c','o','d','e','U','R','I','C','o','m','p','o','n','e','n','t',0};
75 static const WCHAR decodeURIComponentW[] = {'d','e','c','o','d','e','U','R','I','C','o','m','p','o','n','e','n','t',0};
76
77 static const WCHAR undefinedW[] = {'u','n','d','e','f','i','n','e','d',0};
78
79 static int uri_char_table[] = {
80 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 00-0f */
81 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 10-1f */
82 0,2,0,0,1,0,1,2,2,2,2,1,1,2,2,1, /* 20-2f */
83 2,2,2,2,2,2,2,2,2,2,1,1,0,1,0,1, /* 30-3f */
84 1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, /* 40-4f */
85 2,2,2,2,2,2,2,2,2,2,2,0,0,0,0,2, /* 50-5f */
86 0,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, /* 60-6f */
87 2,2,2,2,2,2,2,2,2,2,2,0,0,0,2,0, /* 70-7f */
88 };
89
90 /* 1 - reserved */
91 /* 2 - unescaped */
92
93 static inline BOOL is_uri_reserved(WCHAR c)
94 {
95 return c < 128 && uri_char_table[c] == 1;
96 }
97
98 static inline BOOL is_uri_unescaped(WCHAR c)
99 {
100 return c < 128 && uri_char_table[c] == 2;
101 }
102
103 /* Check that the character is one of the 69 non-blank characters as defined by ECMA-262 B.2.1 */
104 static inline BOOL is_ecma_nonblank(const WCHAR c)
105 {
106 return ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') ||
107 c == '@' || c == '*' || c == '_' || c == '+' || c == '-' || c == '.' || c == '/');
108 }
109
110 static WCHAR int_to_char(int i)
111 {
112 if(i < 10)
113 return '0'+i;
114 return 'A'+i-10;
115 }
116
117 static HRESULT constructor_call(jsdisp_t *constr, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r)
118 {
119 if(flags != DISPATCH_PROPERTYGET)
120 return jsdisp_call_value(constr, NULL, flags, argc, argv, r);
121
122 *r = jsval_obj(jsdisp_addref(constr));
123 return S_OK;
124 }
125
126 static HRESULT JSGlobal_Array(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
127 jsval_t *r)
128 {
129 TRACE("\n");
130
131 return constructor_call(ctx->array_constr, flags, argc, argv, r);
132 }
133
134 static HRESULT JSGlobal_Boolean(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
135 jsval_t *r)
136 {
137 TRACE("\n");
138
139 return constructor_call(ctx->bool_constr, flags, argc, argv, r);
140 }
141
142 static HRESULT JSGlobal_Date(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
143 jsval_t *r)
144 {
145 TRACE("\n");
146
147 return constructor_call(ctx->date_constr, flags, argc, argv, r);
148 }
149
150 static HRESULT JSGlobal_Error(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
151 jsval_t *r)
152 {
153 TRACE("\n");
154
155 return constructor_call(ctx->error_constr, flags, argc, argv, r);
156 }
157
158 static HRESULT JSGlobal_EvalError(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
159 jsval_t *r)
160 {
161 TRACE("\n");
162
163 return constructor_call(ctx->eval_error_constr, flags, argc, argv, r);
164 }
165
166 static HRESULT JSGlobal_RangeError(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
167 jsval_t *r)
168 {
169 TRACE("\n");
170
171 return constructor_call(ctx->range_error_constr, flags, argc, argv, r);
172 }
173
174 static HRESULT JSGlobal_RegExpError(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
175 jsval_t *r)
176 {
177 TRACE("\n");
178
179 return constructor_call(ctx->regexp_error_constr, flags, argc, argv, r);
180 }
181
182 static HRESULT JSGlobal_ReferenceError(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
183 jsval_t *r)
184 {
185 TRACE("\n");
186
187 return constructor_call(ctx->reference_error_constr, flags, argc, argv, r);
188 }
189
190 static HRESULT JSGlobal_SyntaxError(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
191 jsval_t *r)
192 {
193 TRACE("\n");
194
195 return constructor_call(ctx->syntax_error_constr, flags, argc, argv, r);
196 }
197
198 static HRESULT JSGlobal_TypeError(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
199 jsval_t *r)
200 {
201 TRACE("\n");
202
203 return constructor_call(ctx->type_error_constr, flags, argc, argv, r);
204 }
205
206 static HRESULT JSGlobal_URIError(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
207 jsval_t *r)
208 {
209 TRACE("\n");
210
211 return constructor_call(ctx->uri_error_constr, flags, argc, argv, r);
212 }
213
214 static HRESULT JSGlobal_Function(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
215 jsval_t *r)
216 {
217 TRACE("\n");
218
219 return constructor_call(ctx->function_constr, flags, argc, argv, r);
220 }
221
222 static HRESULT JSGlobal_Number(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
223 jsval_t *r)
224 {
225 TRACE("\n");
226
227 return constructor_call(ctx->number_constr, flags, argc, argv, r);
228 }
229
230 static HRESULT JSGlobal_Object(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
231 jsval_t *r)
232 {
233 TRACE("\n");
234
235 return constructor_call(ctx->object_constr, flags, argc, argv, r);
236 }
237
238 static HRESULT JSGlobal_String(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
239 jsval_t *r)
240 {
241 TRACE("\n");
242
243 return constructor_call(ctx->string_constr, flags, argc, argv, r);
244 }
245
246 static HRESULT JSGlobal_RegExp(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
247 jsval_t *r)
248 {
249 TRACE("\n");
250
251 return constructor_call(ctx->regexp_constr, flags, argc, argv, r);
252 }
253
254 static HRESULT JSGlobal_ActiveXObject(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
255 jsval_t *r)
256 {
257 TRACE("\n");
258
259 return constructor_call(ctx->activex_constr, flags, argc, argv, r);
260 }
261
262 static HRESULT JSGlobal_VBArray(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
263 jsval_t *r)
264 {
265 TRACE("\n");
266
267 return constructor_call(ctx->vbarray_constr, flags, argc, argv, r);
268 }
269
270 static HRESULT JSGlobal_Enumerator(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
271 jsval_t *r)
272 {
273 FIXME("\n");
274 return E_NOTIMPL;
275 }
276
277 static HRESULT JSGlobal_escape(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
278 jsval_t *r)
279 {
280 BSTR ret, str;
281 const WCHAR *ptr;
282 DWORD len = 0;
283 HRESULT hres;
284
285 TRACE("\n");
286
287 if(!argc) {
288 if(r) {
289 ret = SysAllocString(undefinedW);
290 if(!ret)
291 return E_OUTOFMEMORY;
292
293 *r = jsval_string(ret);
294 }
295
296 return S_OK;
297 }
298
299 hres = to_string(ctx, argv[0], &str);
300 if(FAILED(hres))
301 return hres;
302
303 for(ptr=str; *ptr; ptr++) {
304 if(*ptr > 0xff)
305 len += 6;
306 else if(is_ecma_nonblank(*ptr))
307 len++;
308 else
309 len += 3;
310 }
311
312 ret = SysAllocStringLen(NULL, len);
313 if(!ret) {
314 SysFreeString(str);
315 return E_OUTOFMEMORY;
316 }
317
318 len = 0;
319 for(ptr=str; *ptr; ptr++) {
320 if(*ptr > 0xff) {
321 ret[len++] = '%';
322 ret[len++] = 'u';
323 ret[len++] = int_to_char(*ptr >> 12);
324 ret[len++] = int_to_char((*ptr >> 8) & 0xf);
325 ret[len++] = int_to_char((*ptr >> 4) & 0xf);
326 ret[len++] = int_to_char(*ptr & 0xf);
327 }
328 else if(is_ecma_nonblank(*ptr))
329 ret[len++] = *ptr;
330 else {
331 ret[len++] = '%';
332 ret[len++] = int_to_char(*ptr >> 4);
333 ret[len++] = int_to_char(*ptr & 0xf);
334 }
335 }
336
337 SysFreeString(str);
338
339 if(r)
340 *r = jsval_string(ret);
341 else
342 SysFreeString(ret);
343 return S_OK;
344 }
345
346 /* ECMA-262 3rd Edition 15.1.2.1 */
347 static HRESULT JSGlobal_eval(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
348 jsval_t *r)
349 {
350 bytecode_t *code;
351 HRESULT hres;
352
353 TRACE("\n");
354
355 if(!argc) {
356 if(r)
357 *r = jsval_undefined();
358 return S_OK;
359 }
360
361 if(!is_string(argv[0])) {
362 if(r)
363 return jsval_copy(argv[0], r);
364 return S_OK;
365 }
366
367 if(!ctx->exec_ctx) {
368 FIXME("No active exec_ctx\n");
369 return E_UNEXPECTED;
370 }
371
372 TRACE("parsing %s\n", debugstr_jsval(argv[0]));
373 hres = compile_script(ctx, get_string(argv[0]), NULL, NULL, TRUE, FALSE, &code);
374 if(FAILED(hres)) {
375 WARN("parse (%s) failed: %08x\n", debugstr_jsval(argv[0]), hres);
376 return throw_syntax_error(ctx, hres, NULL);
377 }
378
379 hres = exec_source(ctx->exec_ctx, code, &code->global_code, TRUE, r);
380 release_bytecode(code);
381 return hres;
382 }
383
384 static HRESULT JSGlobal_isNaN(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
385 jsval_t *r)
386 {
387 BOOL ret = TRUE;
388 double n;
389 HRESULT hres;
390
391 TRACE("\n");
392
393 if(argc) {
394 hres = to_number(ctx, argv[0], &n);
395 if(FAILED(hres))
396 return hres;
397
398 if(!isnan(n))
399 ret = FALSE;
400 }
401
402 if(r)
403 *r = jsval_bool(ret);
404 return S_OK;
405 }
406
407 static HRESULT JSGlobal_isFinite(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
408 jsval_t *r)
409 {
410 BOOL ret = FALSE;
411 HRESULT hres;
412
413 TRACE("\n");
414
415 if(argc) {
416 double n;
417
418 hres = to_number(ctx, argv[0], &n);
419 if(FAILED(hres))
420 return hres;
421
422 if(!isinf(n) && !isnan(n))
423 ret = TRUE;
424 }
425
426 if(r)
427 *r = jsval_bool(ret);
428 return S_OK;
429 }
430
431 static INT char_to_int(WCHAR c)
432 {
433 if('0' <= c && c <= '9')
434 return c - '0';
435 if('a' <= c && c <= 'z')
436 return c - 'a' + 10;
437 if('A' <= c && c <= 'Z')
438 return c - 'A' + 10;
439 return 100;
440 }
441
442 static HRESULT JSGlobal_parseInt(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
443 jsval_t *r)
444 {
445 BOOL neg = FALSE, empty = TRUE;
446 DOUBLE ret = 0.0;
447 INT radix=0, i;
448 WCHAR *ptr;
449 BSTR str;
450 HRESULT hres;
451
452 if(!argc) {
453 if(r)
454 *r = jsval_number(NAN);
455 return S_OK;
456 }
457
458 if(argc >= 2) {
459 hres = to_int32(ctx, argv[1], &radix);
460 if(FAILED(hres))
461 return hres;
462
463 if(radix && (radix < 2 || radix > 36)) {
464 WARN("radix %d out of range\n", radix);
465 if(r)
466 *r = jsval_number(NAN);
467 return S_OK;
468 }
469 }
470
471 hres = to_string(ctx, argv[0], &str);
472 if(FAILED(hres))
473 return hres;
474
475 for(ptr = str; isspaceW(*ptr); ptr++);
476
477 switch(*ptr) {
478 case '+':
479 ptr++;
480 break;
481 case '-':
482 neg = TRUE;
483 ptr++;
484 break;
485 }
486
487 if(!radix) {
488 if(*ptr == '0') {
489 if(ptr[1] == 'x' || ptr[1] == 'X') {
490 radix = 16;
491 ptr += 2;
492 }else {
493 radix = 8;
494 ptr++;
495 empty = FALSE;
496 }
497 }else {
498 radix = 10;
499 }
500 }
501
502 i = char_to_int(*ptr++);
503 if(i < radix) {
504 do {
505 ret = ret*radix + i;
506 i = char_to_int(*ptr++);
507 }while(i < radix);
508 }else if(empty) {
509 ret = NAN;
510 }
511
512 SysFreeString(str);
513
514 if(neg)
515 ret = -ret;
516
517 if(r)
518 *r = jsval_number(ret);
519 return S_OK;
520 }
521
522 static HRESULT JSGlobal_parseFloat(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
523 jsval_t *r)
524 {
525 LONGLONG d = 0, hlp;
526 int exp = 0;
527 WCHAR *str;
528 BSTR val_str = NULL;
529 BOOL ret_nan = TRUE, positive = TRUE;
530 HRESULT hres;
531
532 if(!argc) {
533 if(r)
534 *r = jsval_number(NAN);
535 return S_OK;
536 }
537
538 hres = to_string(ctx, argv[0], &val_str);
539 if(FAILED(hres))
540 return hres;
541
542 str = val_str;
543
544 while(isspaceW(*str)) str++;
545
546 if(*str == '+')
547 str++;
548 else if(*str == '-') {
549 positive = FALSE;
550 str++;
551 }
552
553 if(isdigitW(*str))
554 ret_nan = FALSE;
555
556 while(isdigitW(*str)) {
557 hlp = d*10 + *(str++) - '0';
558 if(d>LONGLONG_MAX/10 || hlp<0) {
559 exp++;
560 break;
561 }
562 else
563 d = hlp;
564 }
565 while(isdigitW(*str)) {
566 exp++;
567 str++;
568 }
569
570 if(*str == '.') str++;
571
572 if(isdigitW(*str))
573 ret_nan = FALSE;
574
575 while(isdigitW(*str)) {
576 hlp = d*10 + *(str++) - '0';
577 if(d>LONGLONG_MAX/10 || hlp<0)
578 break;
579
580 d = hlp;
581 exp--;
582 }
583 while(isdigitW(*str))
584 str++;
585
586 if(*str && !ret_nan && (*str=='e' || *str=='E')) {
587 int sign = 1, e = 0;
588
589 str++;
590 if(*str == '+')
591 str++;
592 else if(*str == '-') {
593 sign = -1;
594 str++;
595 }
596
597 while(isdigitW(*str)) {
598 if(e>INT_MAX/10 || (e = e*10 + *str++ - '0')<0)
599 e = INT_MAX;
600 }
601 e *= sign;
602
603 if(exp<0 && e<0 && exp+e>0) exp = INT_MIN;
604 else if(exp>0 && e>0 && exp+e<0) exp = INT_MAX;
605 else exp += e;
606 }
607
608 SysFreeString(val_str);
609
610 if(ret_nan) {
611 if(r)
612 *r = jsval_number(NAN);
613 return S_OK;
614 }
615
616 if(!positive)
617 d = -d;
618 if(r)
619 *r = jsval_number(exp>0 ? d*pow(10, exp) : d/pow(10, -exp));
620 return S_OK;
621 }
622
623 static inline int hex_to_int(const WCHAR wch) {
624 if(toupperW(wch)>='A' && toupperW(wch)<='F') return toupperW(wch)-'A'+10;
625 if(isdigitW(wch)) return wch-'0';
626 return -1;
627 }
628
629 static HRESULT JSGlobal_unescape(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
630 jsval_t *r)
631 {
632 BSTR ret, str;
633 const WCHAR *ptr;
634 DWORD len = 0;
635 HRESULT hres;
636
637 TRACE("\n");
638
639 if(!argc) {
640 if(r) {
641 ret = SysAllocString(undefinedW);
642 if(!ret)
643 return E_OUTOFMEMORY;
644 *r = jsval_string(ret);
645 }
646
647 return S_OK;
648 }
649
650 hres = to_string(ctx, argv[0], &str);
651 if(FAILED(hres))
652 return hres;
653
654 for(ptr=str; *ptr; ptr++) {
655 if(*ptr == '%') {
656 if(hex_to_int(*(ptr+1))!=-1 && hex_to_int(*(ptr+2))!=-1)
657 ptr += 2;
658 else if(*(ptr+1)=='u' && hex_to_int(*(ptr+2))!=-1 && hex_to_int(*(ptr+3))!=-1
659 && hex_to_int(*(ptr+4))!=-1 && hex_to_int(*(ptr+5))!=-1)
660 ptr += 5;
661 }
662
663 len++;
664 }
665
666 ret = SysAllocStringLen(NULL, len);
667 if(!ret) {
668 SysFreeString(str);
669 return E_OUTOFMEMORY;
670 }
671
672 len = 0;
673 for(ptr=str; *ptr; ptr++) {
674 if(*ptr == '%') {
675 if(hex_to_int(*(ptr+1))!=-1 && hex_to_int(*(ptr+2))!=-1) {
676 ret[len] = (hex_to_int(*(ptr+1))<<4) + hex_to_int(*(ptr+2));
677 ptr += 2;
678 }
679 else if(*(ptr+1)=='u' && hex_to_int(*(ptr+2))!=-1 && hex_to_int(*(ptr+3))!=-1
680 && hex_to_int(*(ptr+4))!=-1 && hex_to_int(*(ptr+5))!=-1) {
681 ret[len] = (hex_to_int(*(ptr+2))<<12) + (hex_to_int(*(ptr+3))<<8)
682 + (hex_to_int(*(ptr+4))<<4) + hex_to_int(*(ptr+5));
683 ptr += 5;
684 }
685 else
686 ret[len] = *ptr;
687 }
688 else
689 ret[len] = *ptr;
690
691 len++;
692 }
693
694 SysFreeString(str);
695
696 if(r)
697 *r = jsval_string(ret);
698 else
699 SysFreeString(ret);
700 return S_OK;
701 }
702
703 static HRESULT JSGlobal_GetObject(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
704 jsval_t *r)
705 {
706 FIXME("\n");
707 return E_NOTIMPL;
708 }
709
710 static HRESULT JSGlobal_ScriptEngine(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
711 jsval_t *r)
712 {
713 static const WCHAR JScriptW[] = {'J','S','c','r','i','p','t',0};
714
715 TRACE("\n");
716
717 if(r) {
718 BSTR ret;
719
720 ret = SysAllocString(JScriptW);
721 if(!ret)
722 return E_OUTOFMEMORY;
723
724 *r = jsval_string(ret);
725 }
726
727 return S_OK;
728 }
729
730 static HRESULT JSGlobal_ScriptEngineMajorVersion(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
731 jsval_t *r)
732 {
733 TRACE("\n");
734
735 if(r)
736 *r = jsval_number(JSCRIPT_MAJOR_VERSION);
737 return S_OK;
738 }
739
740 static HRESULT JSGlobal_ScriptEngineMinorVersion(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
741 jsval_t *r)
742 {
743 TRACE("\n");
744
745 if(r)
746 *r = jsval_number(JSCRIPT_MINOR_VERSION);
747 return S_OK;
748 }
749
750 static HRESULT JSGlobal_ScriptEngineBuildVersion(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
751 jsval_t *r)
752 {
753 TRACE("\n");
754
755 if(r)
756 *r = jsval_number(JSCRIPT_BUILD_VERSION);
757 return S_OK;
758 }
759
760 static HRESULT JSGlobal_CollectGarbage(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
761 jsval_t *r)
762 {
763 FIXME("\n");
764 return E_NOTIMPL;
765 }
766
767 static HRESULT JSGlobal_encodeURI(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
768 jsval_t *r)
769 {
770 const WCHAR *ptr;
771 DWORD len = 0, i;
772 char buf[4];
773 BSTR str, ret;
774 WCHAR *rptr;
775 HRESULT hres;
776
777 TRACE("\n");
778
779 if(!argc) {
780 if(r) {
781 ret = SysAllocString(undefinedW);
782 if(!ret)
783 return E_OUTOFMEMORY;
784
785 *r = jsval_string(ret);
786 }
787
788 return S_OK;
789 }
790
791 hres = to_string(ctx, argv[0], &str);
792 if(FAILED(hres))
793 return hres;
794
795 for(ptr = str; *ptr; ptr++) {
796 if(is_uri_unescaped(*ptr) || is_uri_reserved(*ptr) || *ptr == '#') {
797 len++;
798 }else {
799 i = WideCharToMultiByte(CP_UTF8, 0, ptr, 1, NULL, 0, NULL, NULL)*3;
800 if(!i) {
801 SysFreeString(str);
802 return throw_uri_error(ctx, JS_E_INVALID_URI_CHAR, NULL);
803 }
804
805 len += i;
806 }
807 }
808
809 rptr = ret = SysAllocStringLen(NULL, len);
810 if(!ret) {
811 SysFreeString(str);
812 return E_OUTOFMEMORY;
813 }
814
815 for(ptr = str; *ptr; ptr++) {
816 if(is_uri_unescaped(*ptr) || is_uri_reserved(*ptr) || *ptr == '#') {
817 *rptr++ = *ptr;
818 }else {
819 len = WideCharToMultiByte(CP_UTF8, 0, ptr, 1, buf, sizeof(buf), NULL, NULL);
820 for(i=0; i<len; i++) {
821 *rptr++ = '%';
822 *rptr++ = int_to_char((BYTE)buf[i] >> 4);
823 *rptr++ = int_to_char(buf[i] & 0x0f);
824 }
825 }
826 }
827
828 TRACE("%s -> %s\n", debugstr_w(str), debugstr_w(ret));
829 SysFreeString(str);
830
831 if(r)
832 *r = jsval_string(ret);
833 else
834 SysFreeString(ret);
835 return S_OK;
836 }
837
838 static HRESULT JSGlobal_decodeURI(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
839 jsval_t *r)
840 {
841 BSTR str, ret;
842 WCHAR *ptr;
843 int i, len = 0, val, res;
844 char buf[4];
845 WCHAR out;
846 HRESULT hres;
847
848 TRACE("\n");
849
850 if(!argc) {
851 if(r) {
852 ret = SysAllocString(undefinedW);
853 if(!ret)
854 return E_OUTOFMEMORY;
855
856 *r = jsval_string(ret);
857 }
858
859 return S_OK;
860 }
861
862 hres = to_string(ctx, argv[0], &str);
863 if(FAILED(hres))
864 return hres;
865
866 for(ptr=str; *ptr; ptr++) {
867 if(*ptr != '%') {
868 len++;
869 }else {
870 res = 0;
871 for(i=0; i<4; i++) {
872 if(ptr[i*3]!='%' || hex_to_int(ptr[i*3+1])==-1 || (val=hex_to_int(ptr[i*3+2]))==-1)
873 break;
874 val += hex_to_int(ptr[i*3+1])<<4;
875 buf[i] = val;
876
877 res = MultiByteToWideChar(CP_UTF8, 0, buf, i+1, &out, 1);
878 if(res)
879 break;
880 }
881
882 if(!res) {
883 SysFreeString(str);
884 return throw_uri_error(ctx, JS_E_INVALID_URI_CODING, NULL);
885 }
886
887 ptr += i*3+2;
888 len++;
889 }
890 }
891
892 ret = SysAllocStringLen(NULL, len);
893 if(!ret) {
894 SysFreeString(str);
895 return E_OUTOFMEMORY;
896 }
897
898 len = 0;
899 for(ptr=str; *ptr; ptr++) {
900 if(*ptr != '%') {
901 ret[len] = *ptr;
902 len++;
903 }else {
904 for(i=0; i<4; i++) {
905 if(ptr[i*3]!='%' || hex_to_int(ptr[i*3+1])==-1 || (val=hex_to_int(ptr[i*3+2]))==-1)
906 break;
907 val += hex_to_int(ptr[i*3+1])<<4;
908 buf[i] = val;
909
910 res = MultiByteToWideChar(CP_UTF8, 0, buf, i+1, ret+len, 1);
911 if(res)
912 break;
913 }
914
915 ptr += i*3+2;
916 len++;
917 }
918 }
919
920 TRACE("%s -> %s\n", debugstr_w(str), debugstr_w(ret));
921 SysFreeString(str);
922
923 if(r)
924 *r = jsval_string(ret);
925 else
926 SysFreeString(ret);
927 return S_OK;
928 }
929
930 static HRESULT JSGlobal_encodeURIComponent(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
931 jsval_t *r)
932 {
933 BSTR str, ret;
934 char buf[4];
935 const WCHAR *ptr;
936 DWORD len = 0, size, i;
937 HRESULT hres;
938
939 TRACE("\n");
940
941 if(!argc) {
942 if(r) {
943 ret = SysAllocString(undefinedW);
944 if(!ret)
945 return E_OUTOFMEMORY;
946
947 *r = jsval_string(ret);
948 }
949
950 return S_OK;
951 }
952
953 hres = to_string(ctx, argv[0], &str);
954 if(FAILED(hres))
955 return hres;
956
957 for(ptr=str; *ptr; ptr++) {
958 if(is_uri_unescaped(*ptr))
959 len++;
960 else {
961 size = WideCharToMultiByte(CP_UTF8, 0, ptr, 1, NULL, 0, NULL, NULL);
962 if(!size) {
963 SysFreeString(str);
964 return throw_uri_error(ctx, JS_E_INVALID_URI_CHAR, NULL);
965 }
966 len += size*3;
967 }
968 }
969
970 ret = SysAllocStringLen(NULL, len);
971 if(!ret) {
972 SysFreeString(str);
973 return E_OUTOFMEMORY;
974 }
975
976 len = 0;
977 for(ptr=str; *ptr; ptr++) {
978 if(is_uri_unescaped(*ptr))
979 ret[len++] = *ptr;
980 else {
981 size = WideCharToMultiByte(CP_UTF8, 0, ptr, 1, buf, sizeof(buf), NULL, NULL);
982 for(i=0; i<size; i++) {
983 ret[len++] = '%';
984 ret[len++] = int_to_char((BYTE)buf[i] >> 4);
985 ret[len++] = int_to_char(buf[i] & 0x0f);
986 }
987 }
988 }
989
990 SysFreeString(str);
991
992 if(r)
993 *r = jsval_string(ret);
994 else
995 SysFreeString(ret);
996 return S_OK;
997 }
998
999 /* ECMA-262 3rd Edition 15.1.3.2 */
1000 static HRESULT JSGlobal_decodeURIComponent(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
1001 jsval_t *r)
1002 {
1003 BSTR str, ret;
1004 const WCHAR *ptr;
1005 WCHAR *out_ptr;
1006 DWORD len = 0;
1007 HRESULT hres;
1008
1009 TRACE("\n");
1010
1011 if(!argc) {
1012 if(r) {
1013 ret = SysAllocString(undefinedW);
1014 if(!ret)
1015 return E_OUTOFMEMORY;
1016
1017 *r = jsval_string(ret);
1018 }
1019
1020 return S_OK;
1021 }
1022
1023 hres = to_string(ctx, argv[0], &str);
1024 if(FAILED(hres))
1025 return hres;
1026
1027 ptr = str;
1028 while(*ptr) {
1029 if(*ptr == '%') {
1030 char octets[4];
1031 unsigned char mask = 0x80;
1032 int i, size, num_bytes = 0;
1033 if(hex_to_int(*(ptr+1)) < 0 || hex_to_int(*(ptr+2)) < 0) {
1034 FIXME("Throw URIError: Invalid hex sequence\n");
1035 SysFreeString(str);
1036 return E_FAIL;
1037 }
1038 octets[0] = (hex_to_int(*(ptr+1)) << 4) + hex_to_int(*(ptr+2));
1039 ptr += 3;
1040 while(octets[0] & mask) {
1041 mask = mask >> 1;
1042 ++num_bytes;
1043 }
1044 if(num_bytes == 1 || num_bytes > 4) {
1045 FIXME("Throw URIError: Invalid initial UTF character\n");
1046 SysFreeString(str);
1047 return E_FAIL;
1048 }
1049 for(i = 1; i < num_bytes; ++i) {
1050 if(*ptr != '%'){
1051 FIXME("Throw URIError: Incomplete UTF sequence\n");
1052 SysFreeString(str);
1053 return E_FAIL;
1054 }
1055 if(hex_to_int(*(ptr+1)) < 0 || hex_to_int(*(ptr+2)) < 0) {
1056 FIXME("Throw URIError: Invalid hex sequence\n");
1057 SysFreeString(str);
1058 return E_FAIL;
1059 }
1060 octets[i] = (hex_to_int(*(ptr+1)) << 4) + hex_to_int(*(ptr+2));
1061 ptr += 3;
1062 }
1063 size = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, octets,
1064 num_bytes ? num_bytes : 1, NULL, 0);
1065 if(size == 0) {
1066 FIXME("Throw URIError: Invalid UTF sequence\n");
1067 SysFreeString(str);
1068 return E_FAIL;
1069 }
1070 len += size;
1071 }else {
1072 ++ptr;
1073 ++len;
1074 }
1075 }
1076
1077 out_ptr = ret = SysAllocStringLen(NULL, len);
1078 if(!ret) {
1079 SysFreeString(str);
1080 return E_OUTOFMEMORY;
1081 }
1082
1083 ptr = str;
1084 while(*ptr) {
1085 if(*ptr == '%') {
1086 char octets[4];
1087 unsigned char mask = 0x80;
1088 int i, size, num_bytes = 0;
1089 octets[0] = (hex_to_int(*(ptr+1)) << 4) + hex_to_int(*(ptr+2));
1090 ptr += 3;
1091 while(octets[0] & mask) {
1092 mask = mask >> 1;
1093 ++num_bytes;
1094 }
1095 for(i = 1; i < num_bytes; ++i) {
1096 octets[i] = (hex_to_int(*(ptr+1)) << 4) + hex_to_int(*(ptr+2));
1097 ptr += 3;
1098 }
1099 size = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, octets,
1100 num_bytes ? num_bytes : 1, out_ptr, len);
1101 len -= size;
1102 out_ptr += size;
1103 }else {
1104 *out_ptr++ = *ptr++;
1105 --len;
1106 }
1107 }
1108
1109 SysFreeString(str);
1110
1111 if(r)
1112 *r = jsval_string(ret);
1113 else
1114 SysFreeString(ret);
1115 return S_OK;
1116 }
1117
1118 static const builtin_prop_t JSGlobal_props[] = {
1119 {ActiveXObjectW, JSGlobal_ActiveXObject, PROPF_CONSTR|1},
1120 {ArrayW, JSGlobal_Array, PROPF_CONSTR|1},
1121 {BooleanW, JSGlobal_Boolean, PROPF_CONSTR|1},
1122 {CollectGarbageW, JSGlobal_CollectGarbage, PROPF_METHOD},
1123 {DateW, JSGlobal_Date, PROPF_CONSTR|7},
1124 {EnumeratorW, JSGlobal_Enumerator, PROPF_METHOD|7},
1125 {ErrorW, JSGlobal_Error, PROPF_CONSTR|1},
1126 {EvalErrorW, JSGlobal_EvalError, PROPF_CONSTR|1},
1127 {FunctionW, JSGlobal_Function, PROPF_CONSTR|1},
1128 {_GetObjectW, JSGlobal_GetObject, PROPF_METHOD|2},
1129 {NumberW, JSGlobal_Number, PROPF_CONSTR|1},
1130 {ObjectW, JSGlobal_Object, PROPF_CONSTR|1},
1131 {RangeErrorW, JSGlobal_RangeError, PROPF_CONSTR|1},
1132 {ReferenceErrorW, JSGlobal_ReferenceError, PROPF_CONSTR|1},
1133 {RegExpW, JSGlobal_RegExp, PROPF_CONSTR|2},
1134 {RegExpErrorW, JSGlobal_RegExpError, PROPF_CONSTR|1},
1135 {ScriptEngineW, JSGlobal_ScriptEngine, PROPF_METHOD},
1136 {ScriptEngineBuildVersionW, JSGlobal_ScriptEngineBuildVersion, PROPF_METHOD},
1137 {ScriptEngineMajorVersionW, JSGlobal_ScriptEngineMajorVersion, PROPF_METHOD},
1138 {ScriptEngineMinorVersionW, JSGlobal_ScriptEngineMinorVersion, PROPF_METHOD},
1139 {StringW, JSGlobal_String, PROPF_CONSTR|1},
1140 {SyntaxErrorW, JSGlobal_SyntaxError, PROPF_CONSTR|1},
1141 {TypeErrorW, JSGlobal_TypeError, PROPF_CONSTR|1},
1142 {URIErrorW, JSGlobal_URIError, PROPF_CONSTR|1},
1143 {VBArrayW, JSGlobal_VBArray, PROPF_CONSTR|1},
1144 {decodeURIW, JSGlobal_decodeURI, PROPF_METHOD|1},
1145 {decodeURIComponentW, JSGlobal_decodeURIComponent, PROPF_METHOD|1},
1146 {encodeURIW, JSGlobal_encodeURI, PROPF_METHOD|1},
1147 {encodeURIComponentW, JSGlobal_encodeURIComponent, PROPF_METHOD|1},
1148 {escapeW, JSGlobal_escape, PROPF_METHOD|1},
1149 {evalW, JSGlobal_eval, PROPF_METHOD|1},
1150 {isFiniteW, JSGlobal_isFinite, PROPF_METHOD|1},
1151 {isNaNW, JSGlobal_isNaN, PROPF_METHOD|1},
1152 {parseFloatW, JSGlobal_parseFloat, PROPF_METHOD|1},
1153 {parseIntW, JSGlobal_parseInt, PROPF_METHOD|2},
1154 {unescapeW, JSGlobal_unescape, PROPF_METHOD|1}
1155 };
1156
1157 static const builtin_info_t JSGlobal_info = {
1158 JSCLASS_GLOBAL,
1159 {NULL, NULL, 0},
1160 sizeof(JSGlobal_props)/sizeof(*JSGlobal_props),
1161 JSGlobal_props,
1162 NULL,
1163 NULL
1164 };
1165
1166 static HRESULT init_constructors(script_ctx_t *ctx, jsdisp_t *object_prototype)
1167 {
1168 HRESULT hres;
1169
1170 hres = init_function_constr(ctx, object_prototype);
1171 if(FAILED(hres))
1172 return hres;
1173
1174 hres = create_object_constr(ctx, object_prototype, &ctx->object_constr);
1175 if(FAILED(hres))
1176 return hres;
1177
1178 hres = create_activex_constr(ctx, &ctx->activex_constr);
1179 if(FAILED(hres))
1180 return hres;
1181
1182 hres = create_array_constr(ctx, object_prototype, &ctx->array_constr);
1183 if(FAILED(hres))
1184 return hres;
1185
1186 hres = create_bool_constr(ctx, object_prototype, &ctx->bool_constr);
1187 if(FAILED(hres))
1188 return hres;
1189
1190 hres = create_date_constr(ctx, object_prototype, &ctx->date_constr);
1191 if(FAILED(hres))
1192 return hres;
1193
1194 hres = init_error_constr(ctx, object_prototype);
1195 if(FAILED(hres))
1196 return hres;
1197
1198 hres = create_number_constr(ctx, object_prototype, &ctx->number_constr);
1199 if(FAILED(hres))
1200 return hres;
1201
1202 hres = create_regexp_constr(ctx, object_prototype, &ctx->regexp_constr);
1203 if(FAILED(hres))
1204 return hres;
1205
1206 hres = create_string_constr(ctx, object_prototype, &ctx->string_constr);
1207 if(FAILED(hres))
1208 return hres;
1209
1210 hres = create_vbarray_constr(ctx, object_prototype, &ctx->vbarray_constr);
1211 if(FAILED(hres))
1212 return hres;
1213
1214 return S_OK;
1215 }
1216
1217 HRESULT init_global(script_ctx_t *ctx)
1218 {
1219 jsdisp_t *math, *object_prototype;
1220 HRESULT hres;
1221
1222 if(ctx->global)
1223 return S_OK;
1224
1225 hres = create_object_prototype(ctx, &object_prototype);
1226 if(FAILED(hres))
1227 return hres;
1228
1229 hres = init_constructors(ctx, object_prototype);
1230 jsdisp_release(object_prototype);
1231 if(FAILED(hres))
1232 return hres;
1233
1234 hres = create_dispex(ctx, &JSGlobal_info, NULL, &ctx->global);
1235 if(FAILED(hres))
1236 return hres;
1237
1238 hres = create_math(ctx, &math);
1239 if(FAILED(hres))
1240 return hres;
1241
1242 hres = jsdisp_propput_name(ctx->global, MathW, jsval_obj(math));
1243 jsdisp_release(math);
1244 if(FAILED(hres))
1245 return hres;
1246
1247 hres = jsdisp_propput_name(ctx->global, undefinedW, jsval_undefined());
1248 if(FAILED(hres))
1249 return hres;
1250
1251 hres = jsdisp_propput_name(ctx->global, NaNW, jsval_number(NAN));
1252 if(FAILED(hres))
1253 return hres;
1254
1255 hres = jsdisp_propput_name(ctx->global, InfinityW, jsval_number(INFINITY));
1256 return hres;
1257 }
Windows API implementation