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