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