ReactOS  0.4.12-dev-685-gf36cbf7
engine.c
Go to the documentation of this file.
1 /*
2  * Copyright 2008,2011 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 <assert.h>
24 
25 #include "jscript.h"
26 #include "engine.h"
27 
28 #include "wine/debug.h"
29 
31 
32 static const WCHAR booleanW[] = {'b','o','o','l','e','a','n',0};
33 static const WCHAR functionW[] = {'f','u','n','c','t','i','o','n',0};
34 static const WCHAR numberW[] = {'n','u','m','b','e','r',0};
35 static const WCHAR objectW[] = {'o','b','j','e','c','t',0};
36 static const WCHAR stringW[] = {'s','t','r','i','n','g',0};
37 static const WCHAR undefinedW[] = {'u','n','d','e','f','i','n','e','d',0};
38 static const WCHAR unknownW[] = {'u','n','k','n','o','w','n',0};
39 
41  unsigned stack_top;
43  unsigned catch_off;
44  unsigned finally_off;
45 
47 };
48 
49 typedef struct {
50  enum {
54  EXPRVAL_INVALID
55  } type;
56  union {
58  struct {
61  } idref;
62  unsigned off;
64  } u;
65 } exprval_t;
66 
68 {
69  if(!ctx->stack_size) {
70  ctx->stack = heap_alloc(16*sizeof(*ctx->stack));
71  if(!ctx->stack)
72  return E_OUTOFMEMORY;
73  ctx->stack_size = 16;
74  }else if(ctx->stack_size == ctx->stack_top) {
75  jsval_t *new_stack;
76 
77  new_stack = heap_realloc(ctx->stack, ctx->stack_size*2*sizeof(*new_stack));
78  if(!new_stack) {
80  return E_OUTOFMEMORY;
81  }
82 
83  ctx->stack = new_stack;
84  ctx->stack_size *= 2;
85  }
86 
87  ctx->stack[ctx->stack_top++] = v;
88  return S_OK;
89 }
90 
91 static inline HRESULT stack_push_string(script_ctx_t *ctx, const WCHAR *str)
92 {
93  jsstr_t *v;
94 
95  v = jsstr_alloc(str);
96  if(!v)
97  return E_OUTOFMEMORY;
98 
99  return stack_push(ctx, jsval_string(v));
100 }
101 
102 static inline jsval_t stack_top(script_ctx_t *ctx)
103 {
104  assert(ctx->stack_top > ctx->call_ctx->stack_base);
105  return ctx->stack[ctx->stack_top-1];
106 }
107 
108 static inline jsval_t *stack_top_ref(script_ctx_t *ctx, unsigned n)
109 {
110  assert(ctx->stack_top > ctx->call_ctx->stack_base+n);
111  return ctx->stack+ctx->stack_top-1-n;
112 }
113 
114 static inline jsval_t stack_topn(script_ctx_t *ctx, unsigned n)
115 {
116  return *stack_top_ref(ctx, n);
117 }
118 
119 static inline jsval_t *stack_args(script_ctx_t *ctx, unsigned n)
120 {
121  if(!n)
122  return NULL;
123  assert(ctx->stack_top > ctx->call_ctx->stack_base+n-1);
124  return ctx->stack + ctx->stack_top-n;
125 }
126 
127 static inline jsval_t stack_pop(script_ctx_t *ctx)
128 {
129  assert(ctx->stack_top > ctx->call_ctx->stack_base);
130  return ctx->stack[--ctx->stack_top];
131 }
132 
133 static void stack_popn(script_ctx_t *ctx, unsigned n)
134 {
135  while(n--)
136  jsval_release(stack_pop(ctx));
137 }
138 
139 static HRESULT stack_pop_number(script_ctx_t *ctx, double *r)
140 {
141  jsval_t v;
142  HRESULT hres;
143 
144  v = stack_pop(ctx);
145  hres = to_number(ctx, v, r);
146  jsval_release(v);
147  return hres;
148 }
149 
151 {
152  jsval_t v;
153  HRESULT hres;
154 
155  v = stack_pop(ctx);
156  if(is_object_instance(v)) {
157  if(!get_object(v))
159  *r = get_object(v);
160  return S_OK;
161  }
162 
163  hres = to_object(ctx, v, r);
164  jsval_release(v);
165  return hres;
166 }
167 
168 static inline HRESULT stack_pop_int(script_ctx_t *ctx, INT *r)
169 {
170  return to_int32(ctx, stack_pop(ctx), r);
171 }
172 
174 {
175  return to_uint32(ctx, stack_pop(ctx), r);
176 }
177 
178 static inline unsigned local_off(call_frame_t *frame, int ref)
179 {
180  return ref < 0
181  ? frame->arguments_off - ref-1
182  : frame->variables_off + ref;
183 }
184 
185 static inline BSTR local_name(call_frame_t *frame, int ref)
186 {
187  return ref < 0 ? frame->function->params[-ref-1] : frame->function->variables[ref].name;
188 }
189 
190 /* Steals input reference even on failure. */
192 {
193  HRESULT hres;
194 
195  switch(val->type) {
196  case EXPRVAL_JSVAL:
197  assert(0);
198  case EXPRVAL_IDREF:
199  hres = stack_push(ctx, jsval_disp(val->u.idref.disp));
200  if(SUCCEEDED(hres))
201  hres = stack_push(ctx, jsval_number(val->u.idref.id));
202  else
203  IDispatch_Release(val->u.idref.disp);
204  return hres;
205  case EXPRVAL_STACK_REF:
206  hres = stack_push(ctx, jsval_number(val->u.off));
207  if(SUCCEEDED(hres))
208  hres = stack_push(ctx, jsval_undefined());
209  return hres;
210  case EXPRVAL_INVALID:
211  hres = stack_push(ctx, jsval_undefined());
212  if(SUCCEEDED(hres))
213  hres = stack_push(ctx, jsval_number(val->u.hres));
214  return hres;
215  }
216 
217  assert(0);
218  return E_FAIL;
219 }
220 
222 {
223  jsval_t v = stack_topn(ctx, n+1);
224 
225  switch(jsval_type(v)) {
226  case JSV_NUMBER: {
227  call_frame_t *frame = ctx->call_ctx;
228  unsigned off = get_number(v);
229 
230  if(!frame->base_scope->frame && off >= frame->arguments_off) {
231  DISPID id;
232  BSTR name;
233  HRESULT hres;
234 
235  /* Got stack reference in deoptimized code. Need to convert it back to variable object reference. */
236 
237  assert(off < frame->variables_off + frame->function->var_cnt);
238  name = off >= frame->variables_off
239  ? frame->function->variables[off - frame->variables_off].name
240  : frame->function->params[off - frame->arguments_off];
241  hres = jsdisp_get_id(ctx->call_ctx->base_scope->jsobj, name, 0, &id);
242  if(FAILED(hres)) {
243  r->type = EXPRVAL_INVALID;
244  r->u.hres = hres;
245  return FALSE;
246  }
247 
248  *stack_top_ref(ctx, n+1) = jsval_obj(jsdisp_addref(frame->base_scope->jsobj));
249  *stack_top_ref(ctx, n) = jsval_number(id);
250  r->type = EXPRVAL_IDREF;
251  r->u.idref.disp = frame->base_scope->obj;
252  r->u.idref.id = id;
253  return TRUE;
254  }
255 
256  r->type = EXPRVAL_STACK_REF;
257  r->u.off = off;
258  return TRUE;
259  }
260  case JSV_OBJECT:
261  r->type = EXPRVAL_IDREF;
262  r->u.idref.disp = get_object(v);
263  assert(is_number(stack_topn(ctx, n)));
264  r->u.idref.id = get_number(stack_topn(ctx, n));
265  return TRUE;
266  case JSV_UNDEFINED:
267  r->type = EXPRVAL_INVALID;
268  assert(is_number(stack_topn(ctx, n)));
269  r->u.hres = get_number(stack_topn(ctx, n));
270  return FALSE;
271  default:
272  assert(0);
273  return FALSE;
274  }
275 }
276 
278 {
279  BOOL ret = stack_topn_exprval(ctx, 0, r);
280  ctx->stack_top -= 2;
281  return ret;
282 }
283 
285 {
286  switch(ref->type) {
287  case EXPRVAL_STACK_REF: {
288  jsval_t *r = ctx->stack + ref->u.off;
289  jsval_release(*r);
290  return jsval_copy(v, r);
291  }
292  case EXPRVAL_IDREF:
293  return disp_propput(ctx, ref->u.idref.disp, ref->u.idref.id, v);
294  default:
295  assert(0);
296  return E_FAIL;
297  }
298 }
299 
301 {
302  switch(ref->type) {
303  case EXPRVAL_STACK_REF:
304  return jsval_copy(ctx->stack[ref->u.off], r);
305  case EXPRVAL_IDREF:
306  return disp_propget(ctx, ref->u.idref.disp, ref->u.idref.id, r);
307  default:
308  assert(0);
309  return E_FAIL;
310  }
311 }
312 
314 {
315  switch(ref->type) {
316  case EXPRVAL_STACK_REF: {
317  jsval_t v = ctx->stack[ref->u.off];
318 
319  if(!is_object_instance(v)) {
320  FIXME("invoke %s\n", debugstr_jsval(v));
321  return E_FAIL;
322  }
323 
324  return disp_call_value(ctx, get_object(v), NULL, flags, argc, argv, r);
325  }
326  case EXPRVAL_IDREF:
327  return disp_call(ctx, ref->u.idref.disp, ref->u.idref.id, flags, argc, argv, r);
328  default:
329  assert(0);
330  return E_FAIL;
331  }
332 }
333 
334 /* ECMA-262 3rd Edition 8.7.1 */
335 /* Steals input reference. */
337 {
338  HRESULT hres;
339 
340  if(ref->type == EXPRVAL_JSVAL) {
341  *r = ref->u.val;
342  return S_OK;
343  }
344 
345  hres = exprval_propget(ctx, ref, r);
346 
347  if(ref->type == EXPRVAL_IDREF)
348  IDispatch_Release(ref->u.idref.disp);
349  return hres;
350 }
351 
353 {
354  switch(val->type) {
355  case EXPRVAL_JSVAL:
356  jsval_release(val->u.val);
357  return;
358  case EXPRVAL_IDREF:
359  if(val->u.idref.disp)
360  IDispatch_Release(val->u.idref.disp);
361  return;
362  case EXPRVAL_STACK_REF:
363  case EXPRVAL_INVALID:
364  return;
365  }
366 }
367 
369 {
370  val->type = EXPRVAL_INVALID;
371  val->u.hres = hres;
372 }
373 
375 {
376  ref->type = EXPRVAL_IDREF;
377 #ifdef __REACTOS__ /* FIXME: Inspect */
378  IDispatch_AddRef(obj);
379  ref->u.idref.disp = obj;
380 #else
381  IDispatch_AddRef(ref->u.idref.disp = obj);
382 #endif
383  ref->u.idref.id = id;
384 }
385 
386 static inline jsval_t steal_ret(call_frame_t *frame)
387 {
388  jsval_t r = frame->ret;
389  frame->ret = jsval_undefined();
390  return r;
391 }
392 
393 static inline void clear_acc(script_ctx_t *ctx)
394 {
395  jsval_release(ctx->acc);
396  ctx->acc = jsval_undefined();
397 }
398 
400 {
401  scope_chain_t *new_scope;
402 
403  new_scope = heap_alloc(sizeof(scope_chain_t));
404  if(!new_scope)
405  return E_OUTOFMEMORY;
406 
407  new_scope->ref = 1;
408 
409  IDispatch_AddRef(obj);
410  new_scope->jsobj = jsobj;
411  new_scope->obj = obj;
412  new_scope->frame = NULL;
413  new_scope->next = scope ? scope_addref(scope) : NULL;
414 
415  *ret = new_scope;
416  return S_OK;
417 }
418 
419 static void scope_pop(scope_chain_t **scope)
420 {
421  scope_chain_t *tmp;
422 
423  tmp = *scope;
424  *scope = tmp->next;
425  scope_release(tmp);
426 }
427 
429 {
430  memset(&ctx->ei.ei, 0, sizeof(ctx->ei.ei));
431  jsval_release(ctx->ei.val);
432  ctx->ei.val = jsval_undefined();
433 }
434 
436 {
437  if(--scope->ref)
438  return;
439 
440  if(scope->next)
441  scope_release(scope->next);
442 
443  IDispatch_Release(scope->obj);
444  heap_free(scope);
445 }
446 
447 static HRESULT disp_get_id(script_ctx_t *ctx, IDispatch *disp, const WCHAR *name, BSTR name_bstr, DWORD flags, DISPID *id)
448 {
449  IDispatchEx *dispex;
450  jsdisp_t *jsdisp;
451  BSTR bstr;
452  HRESULT hres;
453 
454  jsdisp = iface_to_jsdisp(disp);
455  if(jsdisp) {
456  hres = jsdisp_get_id(jsdisp, name, flags, id);
457  jsdisp_release(jsdisp);
458  return hres;
459  }
460 
461  if(name_bstr) {
462  bstr = name_bstr;
463  }else {
464  bstr = SysAllocString(name);
465  if(!bstr)
466  return E_OUTOFMEMORY;
467  }
468 
469  *id = 0;
470  hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
471  if(SUCCEEDED(hres)) {
472  hres = IDispatchEx_GetDispID(dispex, bstr, make_grfdex(ctx, flags|fdexNameCaseSensitive), id);
473  IDispatchEx_Release(dispex);
474  }else {
475  TRACE("using IDispatch\n");
476  hres = IDispatch_GetIDsOfNames(disp, &IID_NULL, &bstr, 1, 0, id);
477  }
478 
479  if(name_bstr != bstr)
480  SysFreeString(bstr);
481  return hres;
482 }
483 
484 static HRESULT disp_cmp(IDispatch *disp1, IDispatch *disp2, BOOL *ret)
485 {
486  IObjectIdentity *identity;
487  IUnknown *unk1, *unk2;
488  HRESULT hres;
489 
490  if(disp1 == disp2) {
491  *ret = TRUE;
492  return S_OK;
493  }
494 
495  if(!disp1 || !disp2) {
496  *ret = FALSE;
497  return S_OK;
498  }
499 
500  hres = IDispatch_QueryInterface(disp1, &IID_IUnknown, (void**)&unk1);
501  if(FAILED(hres))
502  return hres;
503 
504  hres = IDispatch_QueryInterface(disp2, &IID_IUnknown, (void**)&unk2);
505  if(FAILED(hres)) {
506  IUnknown_Release(unk1);
507  return hres;
508  }
509 
510  if(unk1 == unk2) {
511  *ret = TRUE;
512  }else {
513  hres = IUnknown_QueryInterface(unk1, &IID_IObjectIdentity, (void**)&identity);
514  if(SUCCEEDED(hres)) {
515  hres = IObjectIdentity_IsEqualObject(identity, unk2);
516  IObjectIdentity_Release(identity);
517  *ret = hres == S_OK;
518  }else {
519  *ret = FALSE;
520  }
521  }
522 
523  IUnknown_Release(unk1);
524  IUnknown_Release(unk2);
525  return S_OK;
526 }
527 
528 /* ECMA-262 3rd Edition 11.9.6 */
530 {
531  jsval_type_t type = jsval_type(lval);
532 
533  TRACE("\n");
534 
535  if(type != jsval_type(rval)) {
536  if(is_null_instance(lval))
538  else
539  *ret = FALSE;
540  return S_OK;
541  }
542 
543  switch(type) {
544  case JSV_UNDEFINED:
545  case JSV_NULL:
546  *ret = TRUE;
547  break;
548  case JSV_OBJECT:
549  return disp_cmp(get_object(lval), get_object(rval), ret);
550  case JSV_STRING:
551  *ret = jsstr_eq(get_string(lval), get_string(rval));
552  break;
553  case JSV_NUMBER:
554  *ret = get_number(lval) == get_number(rval);
555  break;
556  case JSV_BOOL:
557  *ret = !get_bool(lval) == !get_bool(rval);
558  break;
559  case JSV_VARIANT:
560  FIXME("VARIANT not implemented\n");
561  return E_NOTIMPL;
562  }
563 
564  return S_OK;
565 }
566 
567 /*
568  * Transfers local variables from stack to variable object.
569  * It's slow, so we want to avoid it as much as possible.
570  */
571 static HRESULT detach_variable_object(script_ctx_t *ctx, call_frame_t *frame, BOOL from_release)
572 {
573  unsigned i;
574  HRESULT hres;
575 
576  if(!frame->base_scope || !frame->base_scope->frame)
577  return S_OK;
578 
579  TRACE("detaching %p\n", frame);
580 
581  assert(frame == frame->base_scope->frame);
582  assert(frame->variable_obj == frame->base_scope->jsobj);
583 
584  if(!from_release && !frame->arguments_obj) {
585  hres = setup_arguments_object(ctx, frame);
586  if(FAILED(hres))
587  return hres;
588  }
589 
590  frame->base_scope->frame = NULL;
591 
592  for(i = 0; i < frame->function->locals_cnt; i++) {
594  ctx->stack[local_off(frame, frame->function->locals[i].ref)]);
595  if(FAILED(hres))
596  return hres;
597  }
598 
599  return S_OK;
600 }
601 
603 {
605  DISPID id;
606  HRESULT hres;
607 
608  for(item = ctx->named_items; item; item = item->next) {
609  if(item->flags & SCRIPTITEM_GLOBALMEMBERS) {
610  hres = disp_get_id(ctx, item->disp, identifier, identifier, 0, &id);
611  if(SUCCEEDED(hres)) {
612  if(ret)
613  exprval_set_disp_ref(ret, item->disp, id);
614  return TRUE;
615  }
616  }
617  }
618 
619  return FALSE;
620 }
621 
622 static int local_ref_cmp(const void *key, const void *ref)
623 {
624  return strcmpW((const WCHAR*)key, ((const local_ref_t*)ref)->name);
625 }
626 
627 local_ref_t *lookup_local(const function_code_t *function, const WCHAR *identifier)
628 {
629  return bsearch(identifier, function->locals, function->locals_cnt, sizeof(*function->locals), local_ref_cmp);
630 }
631 
632 /* ECMA-262 3rd Edition 10.1.4 */
634 {
635  scope_chain_t *scope;
637  DISPID id = 0;
638  HRESULT hres;
639 
640  TRACE("%s\n", debugstr_w(identifier));
641 
642  if(ctx->call_ctx) {
643  for(scope = ctx->call_ctx->scope; scope; scope = scope->next) {
644  if(scope->frame) {
645  function_code_t *func = scope->frame->function;
646  local_ref_t *ref = lookup_local(func, identifier);
647  static const WCHAR argumentsW[] = {'a','r','g','u','m','e','n','t','s',0};
648 
649  if(ref) {
650  ret->type = EXPRVAL_STACK_REF;
651  ret->u.off = local_off(scope->frame, ref->ref);
652  TRACE("returning ref %d for %d\n", ret->u.off, ref->ref);
653  return S_OK;
654  }
655 
656  if(!strcmpW(identifier, argumentsW)) {
657  hres = detach_variable_object(ctx, scope->frame, FALSE);
658  if(FAILED(hres))
659  return hres;
660  }
661  }
662  if(scope->jsobj)
663  hres = jsdisp_get_id(scope->jsobj, identifier, fdexNameImplicit, &id);
664  else
665  hres = disp_get_id(ctx, scope->obj, identifier, identifier, fdexNameImplicit, &id);
666  if(SUCCEEDED(hres)) {
667  exprval_set_disp_ref(ret, scope->obj, id);
668  return S_OK;
669  }
670  }
671  }
672 
673  hres = jsdisp_get_id(ctx->global, identifier, 0, &id);
674  if(SUCCEEDED(hres)) {
676  return S_OK;
677  }
678 
679  for(item = ctx->named_items; item; item = item->next) {
680  if((item->flags & SCRIPTITEM_ISVISIBLE) && !strcmpW(item->name, identifier)) {
681  if(!item->disp) {
682  IUnknown *unk;
683 
684  if(!ctx->site)
685  break;
686 
687  hres = IActiveScriptSite_GetItemInfo(ctx->site, identifier,
688  SCRIPTINFO_IUNKNOWN, &unk, NULL);
689  if(FAILED(hres)) {
690  WARN("GetItemInfo failed: %08x\n", hres);
691  break;
692  }
693 
694  hres = IUnknown_QueryInterface(unk, &IID_IDispatch, (void**)&item->disp);
695  IUnknown_Release(unk);
696  if(FAILED(hres)) {
697  WARN("object does not implement IDispatch\n");
698  break;
699  }
700  }
701 
702  IDispatch_AddRef(item->disp);
703  ret->type = EXPRVAL_JSVAL;
704  ret->u.val = jsval_disp(item->disp);
705  return S_OK;
706  }
707  }
708 
709  if(lookup_global_members(ctx, identifier, ret))
710  return S_OK;
711 
713  return S_OK;
714 }
715 
716 static inline BSTR get_op_bstr(script_ctx_t *ctx, int i)
717 {
718  call_frame_t *frame = ctx->call_ctx;
719  return frame->bytecode->instrs[frame->ip].u.arg[i].bstr;
720 }
721 
722 static inline unsigned get_op_uint(script_ctx_t *ctx, int i)
723 {
724  call_frame_t *frame = ctx->call_ctx;
725  return frame->bytecode->instrs[frame->ip].u.arg[i].uint;
726 }
727 
728 static inline unsigned get_op_int(script_ctx_t *ctx, int i)
729 {
730  call_frame_t *frame = ctx->call_ctx;
731  return frame->bytecode->instrs[frame->ip].u.arg[i].lng;
732 }
733 
734 static inline jsstr_t *get_op_str(script_ctx_t *ctx, int i)
735 {
736  call_frame_t *frame = ctx->call_ctx;
737  return frame->bytecode->instrs[frame->ip].u.arg[i].str;
738 }
739 
740 static inline double get_op_double(script_ctx_t *ctx)
741 {
742  call_frame_t *frame = ctx->call_ctx;
743  return frame->bytecode->instrs[frame->ip].u.dbl;
744 }
745 
746 static inline void jmp_next(script_ctx_t *ctx)
747 {
748  ctx->call_ctx->ip++;
749 }
750 
751 static inline void jmp_abs(script_ctx_t *ctx, unsigned dst)
752 {
753  ctx->call_ctx->ip = dst;
754 }
755 
756 /* ECMA-262 3rd Edition 12.6.4 */
758 {
759  const HRESULT arg = get_op_uint(ctx, 0);
760  IDispatch *obj = NULL;
761  IDispatchEx *dispex;
762  exprval_t prop_ref;
763  DISPID id;
764  BSTR name = NULL;
765  HRESULT hres;
766 
767  TRACE("\n");
768 
769  assert(is_number(stack_top(ctx)));
770  id = get_number(stack_top(ctx));
771 
772  if(!stack_topn_exprval(ctx, 1, &prop_ref)) {
773  FIXME("invalid ref: %08x\n", prop_ref.u.hres);
774  return E_FAIL;
775  }
776 
777  if(is_object_instance(stack_topn(ctx, 3)))
778  obj = get_object(stack_topn(ctx, 3));
779 
780  if(obj) {
781  hres = IDispatch_QueryInterface(obj, &IID_IDispatchEx, (void**)&dispex);
782  if(SUCCEEDED(hres)) {
783  hres = IDispatchEx_GetNextDispID(dispex, fdexEnumDefault, id, &id);
784  if(hres == S_OK)
785  hres = IDispatchEx_GetMemberName(dispex, id, &name);
786  IDispatchEx_Release(dispex);
787  if(FAILED(hres))
788  return hres;
789  }else {
790  TRACE("No IDispatchEx\n");
791  }
792  }
793 
794  if(name) {
795  jsstr_t *str;
796 
799  if(!str)
800  return E_OUTOFMEMORY;
801 
802  stack_pop(ctx);
803  stack_push(ctx, jsval_number(id)); /* safe, just after pop() */
804 
805  hres = exprval_propput(ctx, &prop_ref, jsval_string(str));
807  if(FAILED(hres))
808  return hres;
809 
810  jmp_next(ctx);
811  }else {
812  stack_popn(ctx, 4);
813  jmp_abs(ctx, arg);
814  }
815  return S_OK;
816 }
817 
818 /* ECMA-262 3rd Edition 12.10 */
820 {
821  IDispatch *disp;
822  jsval_t v;
823  HRESULT hres;
824 
825  TRACE("\n");
826 
827  v = stack_pop(ctx);
828  hres = to_object(ctx, v, &disp);
829  jsval_release(v);
830  if(FAILED(hres))
831  return hres;
832 
833  hres = scope_push(ctx->call_ctx->scope, to_jsdisp(disp), disp, &ctx->call_ctx->scope);
834  IDispatch_Release(disp);
835  return hres;
836 }
837 
838 /* ECMA-262 3rd Edition 12.10 */
840 {
841  TRACE("\n");
842 
843  scope_pop(&ctx->call_ctx->scope);
844  return S_OK;
845 }
846 
847 /* ECMA-262 3rd Edition 12.13 */
849 {
850  const unsigned arg = get_op_uint(ctx, 0);
851  jsval_t v;
852  BOOL b;
853  HRESULT hres;
854 
855  TRACE("\n");
856 
857  v = stack_pop(ctx);
858  hres = jsval_strict_equal(stack_top(ctx), v, &b);
859  jsval_release(v);
860  if(FAILED(hres))
861  return hres;
862 
863  if(b) {
864  stack_popn(ctx, 1);
865  jmp_abs(ctx, arg);
866  }else {
867  jmp_next(ctx);
868  }
869  return S_OK;
870 }
871 
872 /* ECMA-262 3rd Edition 12.13 */
874 {
875  TRACE("\n");
876 
877  jsval_release(ctx->ei.val);
878  ctx->ei.val = stack_pop(ctx);
879  return DISP_E_EXCEPTION;
880 }
881 
883 {
884  const HRESULT arg = get_op_uint(ctx, 0);
885 
886  TRACE("%08x\n", arg);
887 
888  return throw_reference_error(ctx, arg, NULL);
889 }
890 
892 {
893  const HRESULT hres = get_op_uint(ctx, 0);
894  jsstr_t *str = get_op_str(ctx, 1);
895  const WCHAR *ptr;
896 
897  TRACE("%08x %s\n", hres, debugstr_jsstr(str));
898 
899  ptr = jsstr_flatten(str);
900  return ptr ? throw_type_error(ctx, hres, ptr) : E_OUTOFMEMORY;
901 }
902 
903 /* ECMA-262 3rd Edition 12.14 */
905 {
906  const unsigned catch_off = get_op_uint(ctx, 0);
907  const unsigned finally_off = get_op_uint(ctx, 1);
908  call_frame_t *frame = ctx->call_ctx;
910 
911  TRACE("\n");
912 
913  except = heap_alloc(sizeof(*except));
914  if(!except)
915  return E_OUTOFMEMORY;
916 
917  except->stack_top = ctx->stack_top;
918  except->scope = frame->scope;
919  except->catch_off = catch_off;
920  except->finally_off = finally_off;
921  except->next = frame->except_frame;
922  frame->except_frame = except;
923  return S_OK;
924 }
925 
926 /* ECMA-262 3rd Edition 12.14 */
928 {
929  const unsigned ret_off = get_op_uint(ctx, 0);
930  call_frame_t *frame = ctx->call_ctx;
932  unsigned finally_off;
933 
934  TRACE("%u\n", ret_off);
935 
936  except = frame->except_frame;
937  assert(except != NULL);
938 
939  finally_off = except->finally_off;
940  frame->except_frame = except->next;
941  heap_free(except);
942 
943  if(finally_off) {
944  HRESULT hres;
945 
946  hres = stack_push(ctx, jsval_number(ret_off));
947  if(FAILED(hres))
948  return hres;
949  hres = stack_push(ctx, jsval_bool(TRUE));
950  if(FAILED(hres))
951  return hres;
952  frame->ip = finally_off;
953  }else {
954  frame->ip = ret_off;
955  }
956 
957  return S_OK;
958 }
959 
960 /* ECMA-262 3rd Edition 12.14 */
962 {
963  call_frame_t *frame = ctx->call_ctx;
964  jsval_t v;
965 
966  TRACE("\n");
967 
968  v = stack_pop(ctx);
969  assert(is_bool(v));
970 
971  if(!get_bool(v)) {
972  TRACE("passing exception\n");
973 
974  ctx->ei.val = stack_pop(ctx);
975  return DISP_E_EXCEPTION;
976  }
977 
978  v = stack_pop(ctx);
979  assert(is_number(v));
980  frame->ip = get_number(v);
981  return S_OK;
982 }
983 
985 {
986  const BSTR ident = get_op_bstr(ctx, 0);
987  jsdisp_t *scope_obj;
988  jsval_t v;
989  HRESULT hres;
990 
991  hres = create_dispex(ctx, NULL, NULL, &scope_obj);
992  if(FAILED(hres))
993  return hres;
994 
995  v = stack_pop(ctx);
996  hres = jsdisp_propput_name(scope_obj, ident, v);
997  jsval_release(v);
998  if(SUCCEEDED(hres))
999  hres = scope_push(ctx->call_ctx->scope, scope_obj, to_disp(scope_obj), &ctx->call_ctx->scope);
1000  jsdisp_release(scope_obj);
1001  return hres;
1002 }
1003 
1004 /* ECMA-262 3rd Edition 13 */
1006 {
1007  unsigned func_idx = get_op_uint(ctx, 0);
1008  call_frame_t *frame = ctx->call_ctx;
1009  jsdisp_t *dispex;
1010  HRESULT hres;
1011 
1012  TRACE("%d\n", func_idx);
1013 
1014  hres = create_source_function(ctx, frame->bytecode, frame->function->funcs+func_idx,
1015  frame->scope, &dispex);
1016  if(FAILED(hres))
1017  return hres;
1018 
1019  return stack_push(ctx, jsval_obj(dispex));
1020 }
1021 
1022 /* ECMA-262 3rd Edition 11.2.1 */
1024 {
1025  jsstr_t *name_str;
1026  const WCHAR *name;
1027  jsval_t v, namev;
1028  IDispatch *obj;
1029  DISPID id;
1030  HRESULT hres;
1031 
1032  TRACE("\n");
1033 
1034  namev = stack_pop(ctx);
1035 
1036  hres = stack_pop_object(ctx, &obj);
1037  if(FAILED(hres)) {
1038  jsval_release(namev);
1039  return hres;
1040  }
1041 
1042  hres = to_flat_string(ctx, namev, &name_str, &name);
1043  jsval_release(namev);
1044  if(FAILED(hres)) {
1045  IDispatch_Release(obj);
1046  return hres;
1047  }
1048 
1049  hres = disp_get_id(ctx, obj, name, NULL, 0, &id);
1050  jsstr_release(name_str);
1051  if(SUCCEEDED(hres)) {
1052  hres = disp_propget(ctx, obj, id, &v);
1053  }else if(hres == DISP_E_UNKNOWNNAME) {
1054  v = jsval_undefined();
1055  hres = S_OK;
1056  }
1057  IDispatch_Release(obj);
1058  if(FAILED(hres))
1059  return hres;
1060 
1061  return stack_push(ctx, v);
1062 }
1063 
1064 /* ECMA-262 3rd Edition 11.2.1 */
1066 {
1067  const BSTR arg = get_op_bstr(ctx, 0);
1068  IDispatch *obj;
1069  jsval_t v;
1070  DISPID id;
1071  HRESULT hres;
1072 
1073  TRACE("\n");
1074 
1075  hres = stack_pop_object(ctx, &obj);
1076  if(FAILED(hres))
1077  return hres;
1078 
1079  hres = disp_get_id(ctx, obj, arg, arg, 0, &id);
1080  if(SUCCEEDED(hres)) {
1081  hres = disp_propget(ctx, obj, id, &v);
1082  }else if(hres == DISP_E_UNKNOWNNAME) {
1083  v = jsval_undefined();
1084  hres = S_OK;
1085  }
1086  IDispatch_Release(obj);
1087  if(FAILED(hres))
1088  return hres;
1089 
1090  return stack_push(ctx, v);
1091 }
1092 
1093 /* ECMA-262 3rd Edition 11.2.1 */
1095 {
1096  const unsigned arg = get_op_uint(ctx, 0);
1097  jsval_t objv, namev;
1098  const WCHAR *name;
1099  jsstr_t *name_str;
1100  IDispatch *obj;
1101  exprval_t ref;
1102  DISPID id;
1103  HRESULT hres;
1104 
1105  TRACE("%x\n", arg);
1106 
1107  namev = stack_pop(ctx);
1108  objv = stack_pop(ctx);
1109 
1110  hres = to_object(ctx, objv, &obj);
1111  jsval_release(objv);
1112  if(SUCCEEDED(hres)) {
1113  hres = to_flat_string(ctx, namev, &name_str, &name);
1114  if(FAILED(hres))
1115  IDispatch_Release(obj);
1116  }
1117  jsval_release(namev);
1118  if(FAILED(hres))
1119  return hres;
1120 
1121  hres = disp_get_id(ctx, obj, name, NULL, arg, &id);
1122  jsstr_release(name_str);
1123  if(SUCCEEDED(hres)) {
1124  ref.type = EXPRVAL_IDREF;
1125  ref.u.idref.disp = obj;
1126  ref.u.idref.id = id;
1127  }else {
1128  IDispatch_Release(obj);
1129  if(hres == DISP_E_UNKNOWNNAME && !(arg & fdexNameEnsure)) {
1131  hres = S_OK;
1132  }else {
1133  ERR("failed %08x\n", hres);
1134  return hres;
1135  }
1136  }
1137 
1138  return stack_push_exprval(ctx, &ref);
1139 }
1140 
1141 /* ECMA-262 3rd Edition 11.2.1 */
1143 {
1144  exprval_t ref;
1145  jsval_t v;
1146  HRESULT hres;
1147 
1148  TRACE("\n");
1149 
1150  if(!stack_topn_exprval(ctx, 0, &ref))
1152 
1153  hres = exprval_propget(ctx, &ref, &v);
1154  if(FAILED(hres))
1155  return hres;
1156 
1157  return stack_push(ctx, v);
1158 }
1159 
1160 /* ECMA-262 3rd Edition 11.2.2 */
1162 {
1163  const unsigned argc = get_op_uint(ctx, 0);
1164  jsval_t constr;
1165 
1166  TRACE("%d\n", argc);
1167 
1168  constr = stack_topn(ctx, argc);
1169 
1170  /* NOTE: Should use to_object here */
1171 
1172  if(is_null(constr))
1174  else if(!is_object_instance(constr))
1176  else if(!get_object(constr))
1178 
1179  clear_acc(ctx);
1180  return disp_call_value(ctx, get_object(constr), NULL, DISPATCH_CONSTRUCT | DISPATCH_JSCRIPT_CALLEREXECSSOURCE,
1181  argc, stack_args(ctx, argc), &ctx->acc);
1182 }
1183 
1184 /* ECMA-262 3rd Edition 11.2.3 */
1186 {
1187  const unsigned argn = get_op_uint(ctx, 0);
1188  const int do_ret = get_op_int(ctx, 1);
1189  jsval_t obj;
1190 
1191  TRACE("%d %d\n", argn, do_ret);
1192 
1193  obj = stack_topn(ctx, argn);
1194  if(!is_object_instance(obj))
1196 
1197  clear_acc(ctx);
1199  argn, stack_args(ctx, argn), do_ret ? &ctx->acc : NULL);
1200 }
1201 
1202 /* ECMA-262 3rd Edition 11.2.3 */
1204 {
1205  const unsigned argn = get_op_uint(ctx, 0);
1206  const int do_ret = get_op_int(ctx, 1);
1207  exprval_t ref;
1208 
1209  TRACE("%d %d\n", argn, do_ret);
1210 
1211  if(!stack_topn_exprval(ctx, argn, &ref))
1212  return throw_type_error(ctx, ref.u.hres, NULL);
1213 
1214  clear_acc(ctx);
1216  argn, stack_args(ctx, argn), do_ret ? &ctx->acc : NULL);
1217 }
1218 
1219 /* ECMA-262 3rd Edition 11.1.1 */
1221 {
1222  call_frame_t *frame = ctx->call_ctx;
1223 
1224  TRACE("\n");
1225 
1226  IDispatch_AddRef(frame->this_obj);
1227  return stack_push(ctx, jsval_disp(frame->this_obj));
1228 }
1229 
1230 static HRESULT interp_identifier_ref(script_ctx_t *ctx, BSTR identifier, unsigned flags)
1231 {
1232  exprval_t exprval;
1233  HRESULT hres;
1234 
1235  hres = identifier_eval(ctx, identifier, &exprval);
1236  if(FAILED(hres))
1237  return hres;
1238 
1239  if(exprval.type == EXPRVAL_INVALID && (flags & fdexNameEnsure)) {
1240  DISPID id;
1241 
1242  hres = jsdisp_get_id(ctx->global, identifier, fdexNameEnsure, &id);
1243  if(FAILED(hres))
1244  return hres;
1245 
1246  exprval_set_disp_ref(&exprval, to_disp(ctx->global), id);
1247  }
1248 
1249  if(exprval.type == EXPRVAL_JSVAL || exprval.type == EXPRVAL_INVALID) {
1250  WARN("invalid ref\n");
1251  exprval_release(&exprval);
1253  }
1254 
1255  return stack_push_exprval(ctx, &exprval);
1256 }
1257 
1258 static HRESULT identifier_value(script_ctx_t *ctx, BSTR identifier)
1259 {
1260  exprval_t exprval;
1261  jsval_t v;
1262  HRESULT hres;
1263 
1264  hres = identifier_eval(ctx, identifier, &exprval);
1265  if(FAILED(hres))
1266  return hres;
1267 
1268  if(exprval.type == EXPRVAL_INVALID)
1269  return throw_type_error(ctx, exprval.u.hres, identifier);
1270 
1271  hres = exprval_to_value(ctx, &exprval, &v);
1272  if(FAILED(hres))
1273  return hres;
1274 
1275  return stack_push(ctx, v);
1276 }
1277 
1279 {
1280  const int arg = get_op_int(ctx, 0);
1281  const unsigned flags = get_op_uint(ctx, 1);
1282  call_frame_t *frame = ctx->call_ctx;
1283  exprval_t ref;
1284 
1285  TRACE("%d\n", arg);
1286 
1287  if(!frame->base_scope || !frame->base_scope->frame)
1288  return interp_identifier_ref(ctx, local_name(frame, arg), flags);
1289 
1290  ref.type = EXPRVAL_STACK_REF;
1291  ref.u.off = local_off(frame, arg);
1292  return stack_push_exprval(ctx, &ref);
1293 }
1294 
1296 {
1297  const int arg = get_op_int(ctx, 0);
1298  call_frame_t *frame = ctx->call_ctx;
1299  jsval_t copy;
1300  HRESULT hres;
1301 
1302  TRACE("%d: %s\n", arg, debugstr_w(local_name(frame, arg)));
1303 
1304  if(!frame->base_scope || !frame->base_scope->frame)
1305  return identifier_value(ctx, local_name(frame, arg));
1306 
1307  hres = jsval_copy(ctx->stack[local_off(frame, arg)], &copy);
1308  if(FAILED(hres))
1309  return hres;
1310 
1311  return stack_push(ctx, copy);
1312 }
1313 
1314 /* ECMA-262 3rd Edition 10.1.4 */
1316 {
1317  const BSTR arg = get_op_bstr(ctx, 0);
1318 
1319  TRACE("%s\n", debugstr_w(arg));
1320 
1321  return identifier_value(ctx, arg);
1322 }
1323 
1324 /* ECMA-262 3rd Edition 10.1.4 */
1326 {
1327  const BSTR arg = get_op_bstr(ctx, 0);
1328  const unsigned flags = get_op_uint(ctx, 1);
1329 
1330  TRACE("%s %x\n", debugstr_w(arg), flags);
1331 
1332  return interp_identifier_ref(ctx, arg, flags);
1333 }
1334 
1335 /* ECMA-262 3rd Edition 7.8.1 */
1337 {
1338  TRACE("\n");
1339 
1340  return stack_push(ctx, jsval_null());
1341 }
1342 
1343 /* ECMA-262 3rd Edition 7.8.2 */
1345 {
1346  const int arg = get_op_int(ctx, 0);
1347 
1348  TRACE("%s\n", arg ? "true" : "false");
1349 
1350  return stack_push(ctx, jsval_bool(arg));
1351 }
1352 
1353 /* ECMA-262 3rd Edition 7.8.3 */
1355 {
1356  const int arg = get_op_int(ctx, 0);
1357 
1358  TRACE("%d\n", arg);
1359 
1360  return stack_push(ctx, jsval_number(arg));
1361 }
1362 
1363 /* ECMA-262 3rd Edition 7.8.3 */
1365 {
1366  const double arg = get_op_double(ctx);
1367 
1368  TRACE("%lf\n", arg);
1369 
1370  return stack_push(ctx, jsval_number(arg));
1371 }
1372 
1373 /* ECMA-262 3rd Edition 7.8.4 */
1375 {
1376  jsstr_t *str = get_op_str(ctx, 0);
1377 
1378  TRACE("%s\n", debugstr_jsstr(str));
1379 
1380  return stack_push(ctx, jsval_string(jsstr_addref(str)));
1381 }
1382 
1383 /* ECMA-262 3rd Edition 7.8 */
1385 {
1386  jsstr_t *source = get_op_str(ctx, 0);
1387  const unsigned flags = get_op_uint(ctx, 1);
1388  jsdisp_t *regexp;
1389  HRESULT hres;
1390 
1391  TRACE("%s %x\n", debugstr_jsstr(source), flags);
1392 
1393  hres = create_regexp(ctx, source, flags, &regexp);
1394  if(FAILED(hres))
1395  return hres;
1396 
1397  return stack_push(ctx, jsval_obj(regexp));
1398 }
1399 
1400 /* ECMA-262 3rd Edition 11.1.4 */
1402 {
1403  const unsigned arg = get_op_uint(ctx, 0);
1404  jsdisp_t *array;
1405  HRESULT hres;
1406 
1407  TRACE("%u\n", arg);
1408 
1409  hres = create_array(ctx, arg, &array);
1410  if(FAILED(hres))
1411  return hres;
1412 
1413  return stack_push(ctx, jsval_obj(array));
1414 }
1415 
1417 {
1418  const unsigned index = get_op_uint(ctx, 0);
1419  jsval_t value, array;
1420  HRESULT hres;
1421 
1422  value = stack_pop(ctx);
1423 
1424  TRACE("[%u] = %s\n", index, debugstr_jsval(value));
1425 
1426  array = stack_top(ctx);
1428 
1431  return hres;
1432 }
1433 
1434 /* ECMA-262 3rd Edition 11.1.5 */
1436 {
1437  jsdisp_t *obj;
1438  HRESULT hres;
1439 
1440  TRACE("\n");
1441 
1442  hres = create_object(ctx, NULL, &obj);
1443  if(FAILED(hres))
1444  return hres;
1445 
1446  return stack_push(ctx, jsval_obj(obj));
1447 }
1448 
1449 /* ECMA-262 3rd Edition 11.1.5 */
1451 {
1452  const BSTR name = get_op_bstr(ctx, 0);
1453  unsigned type = get_op_uint(ctx, 1);
1454  jsdisp_t *obj;
1455  jsval_t val;
1456  HRESULT hres;
1457 
1458  TRACE("%s\n", debugstr_w(name));
1459 
1460  val = stack_pop(ctx);
1461 
1463  obj = as_jsdisp(get_object(stack_top(ctx)));
1464 
1467  }else {
1469  jsdisp_t *func;
1470 
1473 
1474  desc.mask = desc.flags;
1476  desc.explicit_getter = TRUE;
1477  desc.getter = func;
1478  }else {
1479  desc.explicit_setter = TRUE;
1480  desc.setter = func;
1481  }
1482 
1485  }
1486 
1487  jsval_release(val);
1488  return hres;
1489 }
1490 
1491 /* ECMA-262 3rd Edition 11.11 */
1493 {
1494  const unsigned arg = get_op_uint(ctx, 0);
1495  BOOL b;
1496  HRESULT hres;
1497 
1498  TRACE("\n");
1499 
1500  hres = to_boolean(stack_top(ctx), &b);
1501  if(FAILED(hres))
1502  return hres;
1503 
1504  if(b) {
1505  jmp_abs(ctx, arg);
1506  }else {
1507  stack_popn(ctx, 1);
1508  jmp_next(ctx);
1509  }
1510  return S_OK;
1511 }
1512 
1513 /* ECMA-262 3rd Edition 11.11 */
1515 {
1516  const unsigned arg = get_op_uint(ctx, 0);
1517  BOOL b;
1518  HRESULT hres;
1519 
1520  TRACE("\n");
1521 
1522  hres = to_boolean(stack_top(ctx), &b);
1523  if(FAILED(hres))
1524  return hres;
1525 
1526  if(b) {
1527  stack_popn(ctx, 1);
1528  jmp_next(ctx);
1529  }else {
1530  jmp_abs(ctx, arg);
1531  }
1532  return S_OK;
1533 }
1534 
1535 /* ECMA-262 3rd Edition 11.10 */
1537 {
1538  INT l, r;
1539  HRESULT hres;
1540 
1541  TRACE("\n");
1542 
1543  hres = stack_pop_int(ctx, &r);
1544  if(FAILED(hres))
1545  return hres;
1546 
1547  hres = stack_pop_int(ctx, &l);
1548  if(FAILED(hres))
1549  return hres;
1550 
1551  return stack_push(ctx, jsval_number(l|r));
1552 }
1553 
1554 /* ECMA-262 3rd Edition 11.10 */
1556 {
1557  INT l, r;
1558  HRESULT hres;
1559 
1560  TRACE("\n");
1561 
1562  hres = stack_pop_int(ctx, &r);
1563  if(FAILED(hres))
1564  return hres;
1565 
1566  hres = stack_pop_int(ctx, &l);
1567  if(FAILED(hres))
1568  return hres;
1569 
1570  return stack_push(ctx, jsval_number(l^r));
1571 }
1572 
1573 /* ECMA-262 3rd Edition 11.10 */
1575 {
1576  INT l, r;
1577  HRESULT hres;
1578 
1579  TRACE("\n");
1580 
1581  hres = stack_pop_int(ctx, &r);
1582  if(FAILED(hres))
1583  return hres;
1584 
1585  hres = stack_pop_int(ctx, &l);
1586  if(FAILED(hres))
1587  return hres;
1588 
1589  return stack_push(ctx, jsval_number(l&r));
1590 }
1591 
1592 /* ECMA-262 3rd Edition 11.8.6 */
1594 {
1595  jsdisp_t *obj, *iter, *tmp = NULL;
1596  jsval_t prot, v;
1597  BOOL ret = FALSE;
1598  HRESULT hres;
1599 
1600  static const WCHAR prototypeW[] = {'p','r','o','t','o','t', 'y', 'p','e',0};
1601 
1602  v = stack_pop(ctx);
1603  if(!is_object_instance(v) || !get_object(v)) {
1604  jsval_release(v);
1606  }
1607 
1609  IDispatch_Release(get_object(v));
1610  if(!obj) {
1611  FIXME("non-jsdisp objects not supported\n");
1612  return E_FAIL;
1613  }
1614 
1615  if(is_class(obj, JSCLASS_FUNCTION)) {
1617  }else {
1619  }
1621  if(FAILED(hres))
1622  return hres;
1623 
1624  v = stack_pop(ctx);
1625 
1626  if(is_object_instance(prot)) {
1627  if(is_object_instance(v))
1628  tmp = iface_to_jsdisp(get_object(v));
1629  for(iter = tmp; !ret && iter; iter = iter->prototype) {
1630  hres = disp_cmp(get_object(prot), to_disp(iter), &ret);
1631  if(FAILED(hres))
1632  break;
1633  }
1634 
1635  if(tmp)
1636  jsdisp_release(tmp);
1637  }else {
1638  FIXME("prototype is not an object\n");
1639  hres = E_FAIL;
1640  }
1641 
1642  jsval_release(prot);
1643  jsval_release(v);
1644  if(FAILED(hres))
1645  return hres;
1646 
1647  return stack_push(ctx, jsval_bool(ret));
1648 }
1649 
1650 /* ECMA-262 3rd Edition 11.8.7 */
1652 {
1653  const WCHAR *str;
1654  jsstr_t *jsstr;
1655  jsval_t obj, v;
1656  DISPID id = 0;
1657  BOOL ret;
1658  HRESULT hres;
1659 
1660  TRACE("\n");
1661 
1662  obj = stack_pop(ctx);
1663  if(!is_object_instance(obj) || !get_object(obj)) {
1664  jsval_release(obj);
1666  }
1667 
1668  v = stack_pop(ctx);
1669  hres = to_flat_string(ctx, v, &jsstr, &str);
1670  jsval_release(v);
1671  if(FAILED(hres)) {
1672  IDispatch_Release(get_object(obj));
1673  return hres;
1674  }
1675 
1676  hres = disp_get_id(ctx, get_object(obj), str, NULL, 0, &id);
1677  IDispatch_Release(get_object(obj));
1678  jsstr_release(jsstr);
1679  if(SUCCEEDED(hres))
1680  ret = TRUE;
1681  else if(hres == DISP_E_UNKNOWNNAME)
1682  ret = FALSE;
1683  else
1684  return hres;
1685 
1686  return stack_push(ctx, jsval_bool(ret));
1687 }
1688 
1689 /* ECMA-262 3rd Edition 11.6.1 */
1691 {
1692  jsval_t r, l;
1693  HRESULT hres;
1694 
1695  hres = to_primitive(ctx, lval, &l, NO_HINT);
1696  if(FAILED(hres))
1697  return hres;
1698 
1699  hres = to_primitive(ctx, rval, &r, NO_HINT);
1700  if(FAILED(hres)) {
1701  jsval_release(l);
1702  return hres;
1703  }
1704 
1705  if(is_string(l) || is_string(r)) {
1706  jsstr_t *lstr, *rstr = NULL;
1707 
1708  hres = to_string(ctx, l, &lstr);
1709  if(SUCCEEDED(hres))
1710  hres = to_string(ctx, r, &rstr);
1711 
1712  if(SUCCEEDED(hres)) {
1713  jsstr_t *ret_str;
1714 
1715  ret_str = jsstr_concat(lstr, rstr);
1716  if(ret_str)
1717  *ret = jsval_string(ret_str);
1718  else
1719  hres = E_OUTOFMEMORY;
1720  }
1721 
1722  jsstr_release(lstr);
1723  if(rstr)
1725  }else {
1726  double nl, nr;
1727 
1728  hres = to_number(ctx, l, &nl);
1729  if(SUCCEEDED(hres)) {
1730  hres = to_number(ctx, r, &nr);
1731  if(SUCCEEDED(hres))
1732  *ret = jsval_number(nl+nr);
1733  }
1734  }
1735 
1736  jsval_release(r);
1737  jsval_release(l);
1738  return hres;
1739 }
1740 
1741 /* ECMA-262 3rd Edition 11.6.1 */
1743 {
1744  jsval_t l, r, ret;
1745  HRESULT hres;
1746 
1747  r = stack_pop(ctx);
1748  l = stack_pop(ctx);
1749 
1750  TRACE("%s + %s\n", debugstr_jsval(l), debugstr_jsval(r));
1751 
1752  hres = add_eval(ctx, l, r, &ret);
1753  jsval_release(l);
1754  jsval_release(r);
1755  if(FAILED(hres))
1756  return hres;
1757 
1758  return stack_push(ctx, ret);
1759 }
1760 
1761 /* ECMA-262 3rd Edition 11.6.2 */
1763 {
1764  double l, r;
1765  HRESULT hres;
1766 
1767  TRACE("\n");
1768 
1769  hres = stack_pop_number(ctx, &r);
1770  if(FAILED(hres))
1771  return hres;
1772 
1773  hres = stack_pop_number(ctx, &l);
1774  if(FAILED(hres))
1775  return hres;
1776 
1777  return stack_push(ctx, jsval_number(l-r));
1778 }
1779 
1780 /* ECMA-262 3rd Edition 11.5.1 */
1782 {
1783  double l, r;
1784  HRESULT hres;
1785 
1786  TRACE("\n");
1787 
1788  hres = stack_pop_number(ctx, &r);
1789  if(FAILED(hres))
1790  return hres;
1791 
1792  hres = stack_pop_number(ctx, &l);
1793  if(FAILED(hres))
1794  return hres;
1795 
1796  return stack_push(ctx, jsval_number(l*r));
1797 }
1798 
1799 /* ECMA-262 3rd Edition 11.5.2 */
1801 {
1802  double l, r;
1803  HRESULT hres;
1804 
1805  TRACE("\n");
1806 
1807  hres = stack_pop_number(ctx, &r);
1808  if(FAILED(hres))
1809  return hres;
1810 
1811  hres = stack_pop_number(ctx, &l);
1812  if(FAILED(hres))
1813  return hres;
1814 
1815  return stack_push(ctx, jsval_number(l/r));
1816 }
1817 
1818 /* ECMA-262 3rd Edition 11.5.3 */
1820 {
1821  double l, r;
1822  HRESULT hres;
1823 
1824  TRACE("\n");
1825 
1826  hres = stack_pop_number(ctx, &r);
1827  if(FAILED(hres))
1828  return hres;
1829 
1830  hres = stack_pop_number(ctx, &l);
1831  if(FAILED(hres))
1832  return hres;
1833 
1834  return stack_push(ctx, jsval_number(fmod(l, r)));
1835 }
1836 
1837 /* ECMA-262 3rd Edition 11.4.2 */
1839 {
1840  jsval_t objv, namev;
1841  IDispatch *obj;
1842  jsstr_t *name;
1843  BOOL ret;
1844  HRESULT hres;
1845 
1846  TRACE("\n");
1847 
1848  namev = stack_pop(ctx);
1849  objv = stack_pop(ctx);
1850 
1851  hres = to_object(ctx, objv, &obj);
1852  jsval_release(objv);
1853  if(FAILED(hres)) {
1854  jsval_release(namev);
1855  return hres;
1856  }
1857 
1858  hres = to_string(ctx, namev, &name);
1859  jsval_release(namev);
1860  if(FAILED(hres)) {
1861  IDispatch_Release(obj);
1862  return hres;
1863  }
1864 
1865  hres = disp_delete_name(ctx, obj, name, &ret);
1866  IDispatch_Release(obj);
1868  if(FAILED(hres))
1869  return hres;
1870 
1871  return stack_push(ctx, jsval_bool(ret));
1872 }
1873 
1874 /* ECMA-262 3rd Edition 11.4.2 */
1876 {
1877  const BSTR arg = get_op_bstr(ctx, 0);
1878  exprval_t exprval;
1879  BOOL ret;
1880  HRESULT hres;
1881 
1882  TRACE("%s\n", debugstr_w(arg));
1883 
1884  hres = identifier_eval(ctx, arg, &exprval);
1885  if(FAILED(hres))
1886  return hres;
1887 
1888  switch(exprval.type) {
1889  case EXPRVAL_STACK_REF:
1890  ret = FALSE;
1891  break;
1892  case EXPRVAL_IDREF:
1893  hres = disp_delete(exprval.u.idref.disp, exprval.u.idref.id, &ret);
1894  IDispatch_Release(exprval.u.idref.disp);
1895  if(FAILED(hres))
1896  return hres;
1897  break;
1898  case EXPRVAL_INVALID:
1899  ret = TRUE;
1900  break;
1901  default:
1902  FIXME("Unsupported exprval\n");
1903  exprval_release(&exprval);
1904  return E_NOTIMPL;
1905  }
1906 
1907 
1908  return stack_push(ctx, jsval_bool(ret));
1909 }
1910 
1911 /* ECMA-262 3rd Edition 11.4.2 */
1913 {
1914  TRACE("\n");
1915 
1916  stack_popn(ctx, 1);
1917  return stack_push(ctx, jsval_undefined());
1918 }
1919 
1920 /* ECMA-262 3rd Edition 11.4.3 */
1922 {
1923  switch(jsval_type(v)) {
1924  case JSV_UNDEFINED:
1925  *ret = undefinedW;
1926  break;
1927  case JSV_NULL:
1928  *ret = objectW;
1929  break;
1930  case JSV_OBJECT: {
1931  jsdisp_t *dispex;
1932 
1933  if(get_object(v) && (dispex = iface_to_jsdisp(get_object(v)))) {
1934  *ret = is_class(dispex, JSCLASS_FUNCTION) ? functionW : objectW;
1935  jsdisp_release(dispex);
1936  }else {
1937  *ret = objectW;
1938  }
1939  break;
1940  }
1941  case JSV_STRING:
1942  *ret = stringW;
1943  break;
1944  case JSV_NUMBER:
1945  *ret = numberW;
1946  break;
1947  case JSV_BOOL:
1948  *ret = booleanW;
1949  break;
1950  case JSV_VARIANT:
1951  FIXME("unhandled variant %s\n", debugstr_variant(get_variant(v)));
1952  return E_NOTIMPL;
1953  }
1954 
1955  return S_OK;
1956 }
1957 
1958 /* ECMA-262 3rd Edition 11.4.3 */
1960 {
1961  const WCHAR *ret;
1962  exprval_t ref;
1963  jsval_t v;
1964  HRESULT hres;
1965 
1966  TRACE("\n");
1967 
1968  if(!stack_pop_exprval(ctx, &ref))
1969  return stack_push(ctx, jsval_string(jsstr_undefined()));
1970 
1971  hres = exprval_propget(ctx, &ref, &v);
1972  exprval_release(&ref);
1973  if(FAILED(hres))
1974  return stack_push_string(ctx, unknownW);
1975 
1976  hres = typeof_string(v, &ret);
1977  jsval_release(v);
1978  if(FAILED(hres))
1979  return hres;
1980 
1981  return stack_push_string(ctx, ret);
1982 }
1983 
1984 /* ECMA-262 3rd Edition 11.4.3 */
1986 {
1987  const BSTR arg = get_op_bstr(ctx, 0);
1988  exprval_t exprval;
1989  const WCHAR *ret;
1990  jsval_t v;
1991  HRESULT hres;
1992 
1993  TRACE("%s\n", debugstr_w(arg));
1994 
1995  hres = identifier_eval(ctx, arg, &exprval);
1996  if(FAILED(hres))
1997  return hres;
1998 
1999  if(exprval.type == EXPRVAL_INVALID)
2000  return stack_push(ctx, jsval_string(jsstr_undefined()));
2001 
2002  hres = exprval_to_value(ctx, &exprval, &v);
2003  if(FAILED(hres))
2004  return hres;
2005 
2006  hres = typeof_string(v, &ret);
2007  jsval_release(v);
2008  if(FAILED(hres))
2009  return hres;
2010 
2011  return stack_push_string(ctx, ret);
2012 }
2013 
2014 /* ECMA-262 3rd Edition 11.4.3 */
2016 {
2017  const WCHAR *ret;
2018  jsval_t v;
2019  HRESULT hres;
2020 
2021  TRACE("\n");
2022 
2023  v = stack_pop(ctx);
2024  hres = typeof_string(v, &ret);
2025  jsval_release(v);
2026  if(FAILED(hres))
2027  return hres;
2028 
2029  return stack_push_string(ctx, ret);
2030 }
2031 
2032 /* ECMA-262 3rd Edition 11.4.7 */
2034 {
2035  double n;
2036  HRESULT hres;
2037 
2038  TRACE("\n");
2039 
2040  hres = stack_pop_number(ctx, &n);
2041  if(FAILED(hres))
2042  return hres;
2043 
2044  return stack_push(ctx, jsval_number(-n));
2045 }
2046 
2047 /* ECMA-262 3rd Edition 11.4.6 */
2049 {
2050  jsval_t v;
2051  double n;
2052  HRESULT hres;
2053 
2054  TRACE("\n");
2055 
2056  v = stack_pop(ctx);
2057  hres = to_number(ctx, v, &n);
2058  jsval_release(v);
2059  if(FAILED(hres))
2060  return hres;
2061 
2062  return stack_push(ctx, jsval_number(n));
2063 }
2064 
2065 /* ECMA-262 3rd Edition 11.3.1 */
2067 {
2068  const int arg = get_op_int(ctx, 0);
2069  exprval_t ref;
2070  jsval_t v;
2071  HRESULT hres;
2072 
2073  TRACE("%d\n", arg);
2074 
2075  if(!stack_pop_exprval(ctx, &ref))
2077 
2078  hres = exprval_propget(ctx, &ref, &v);
2079  if(SUCCEEDED(hres)) {
2080  double n;
2081 
2082  hres = to_number(ctx, v, &n);
2083  if(SUCCEEDED(hres))
2084  hres = exprval_propput(ctx, &ref, jsval_number(n+(double)arg));
2085  if(FAILED(hres))
2086  jsval_release(v);
2087  }
2088  exprval_release(&ref);
2089  if(FAILED(hres))
2090  return hres;
2091 
2092  return stack_push(ctx, v);
2093 }
2094 
2095 /* ECMA-262 3rd Edition 11.4.4, 11.4.5 */
2097 {
2098  const int arg = get_op_int(ctx, 0);
2099  exprval_t ref;
2100  double ret;
2101  jsval_t v;
2102  HRESULT hres;
2103 
2104  TRACE("%d\n", arg);
2105 
2106  if(!stack_pop_exprval(ctx, &ref))
2108 
2109  hres = exprval_propget(ctx, &ref, &v);
2110  if(SUCCEEDED(hres)) {
2111  double n;
2112 
2113  hres = to_number(ctx, v, &n);
2114  jsval_release(v);
2115  if(SUCCEEDED(hres)) {
2116  ret = n+(double)arg;
2118  }
2119  }
2120  exprval_release(&ref);
2121  if(FAILED(hres))
2122  return hres;
2123 
2124  return stack_push(ctx, jsval_number(ret));
2125 }
2126 
2127 /* ECMA-262 3rd Edition 11.9.3 */
2129 {
2130  if(jsval_type(lval) == jsval_type(rval) || (is_number(lval) && is_number(rval)))
2131  return jsval_strict_equal(lval, rval, ret);
2132 
2133  /* FIXME: NULL disps should be handled in more general way */
2134  if(is_object_instance(lval) && !get_object(lval))
2135  return equal_values(ctx, jsval_null(), rval, ret);
2137  return equal_values(ctx, lval, jsval_null(), ret);
2138 
2139  if((is_null(lval) && is_undefined(rval)) || (is_undefined(lval) && is_null(rval))) {
2140  *ret = TRUE;
2141  return S_OK;
2142  }
2143 
2144  if(is_string(lval) && is_number(rval)) {
2145  double n;
2146  HRESULT hres;
2147 
2148  hres = to_number(ctx, lval, &n);
2149  if(FAILED(hres))
2150  return hres;
2151 
2152  /* FIXME: optimize */
2153  return equal_values(ctx, jsval_number(n), rval, ret);
2154  }
2155 
2156  if(is_string(rval) && is_number(lval)) {
2157  double n;
2158  HRESULT hres;
2159 
2160  hres = to_number(ctx, rval, &n);
2161  if(FAILED(hres))
2162  return hres;
2163 
2164  /* FIXME: optimize */
2165  return equal_values(ctx, lval, jsval_number(n), ret);
2166  }
2167 
2168  if(is_bool(rval))
2169  return equal_values(ctx, lval, jsval_number(get_bool(rval) ? 1 : 0), ret);
2170 
2171  if(is_bool(lval))
2172  return equal_values(ctx, jsval_number(get_bool(lval) ? 1 : 0), rval, ret);
2173 
2174 
2175  if(is_object_instance(rval) && (is_string(lval) || is_number(lval))) {
2176  jsval_t prim;
2177  HRESULT hres;
2178 
2179  hres = to_primitive(ctx, rval, &prim, NO_HINT);
2180  if(FAILED(hres))
2181  return hres;
2182 
2183  hres = equal_values(ctx, lval, prim, ret);
2185  return hres;
2186  }
2187 
2188 
2189  if(is_object_instance(lval) && (is_string(rval) || is_number(rval))) {
2190  jsval_t prim;
2191  HRESULT hres;
2192 
2193  hres = to_primitive(ctx, lval, &prim, NO_HINT);
2194  if(FAILED(hres))
2195  return hres;
2196 
2197  hres = equal_values(ctx, prim, rval, ret);
2199  return hres;
2200  }
2201 
2202 
2203  *ret = FALSE;
2204  return S_OK;
2205 }
2206 
2207 /* ECMA-262 3rd Edition 11.9.1 */
2209 {
2210  jsval_t l, r;
2211  BOOL b;
2212  HRESULT hres;
2213 
2214  r = stack_pop(ctx);
2215  l = stack_pop(ctx);
2216 
2217  TRACE("%s == %s\n", debugstr_jsval(l), debugstr_jsval(r));
2218 
2219  hres = equal_values(ctx, l, r, &b);
2220  jsval_release(l);
2221  jsval_release(r);
2222  if(FAILED(hres))
2223  return hres;
2224 
2225  return stack_push(ctx, jsval_bool(b));
2226 }
2227 
2228 /* ECMA-262 3rd Edition 11.9.2 */
2230 {
2231  jsval_t l, r;
2232  BOOL b;
2233  HRESULT hres;
2234 
2235  r = stack_pop(ctx);
2236  l = stack_pop(ctx);
2237 
2238  TRACE("%s != %s\n", debugstr_jsval(l), debugstr_jsval(r));
2239 
2240  hres = equal_values(ctx, l, r, &b);
2241  jsval_release(l);
2242  jsval_release(r);
2243  if(FAILED(hres))
2244  return hres;
2245 
2246  return stack_push(ctx, jsval_bool(!b));
2247 }
2248 
2249 /* ECMA-262 3rd Edition 11.9.4 */
2251 {
2252  jsval_t l, r;
2253  BOOL b;
2254  HRESULT hres;
2255 
2256  r = stack_pop(ctx);
2257  l = stack_pop(ctx);
2258 
2259  TRACE("%s === %s\n", debugstr_jsval(l), debugstr_jsval(r));
2260 
2261  hres = jsval_strict_equal(r, l, &b);
2262  jsval_release(l);
2263  jsval_release(r);
2264  if(FAILED(hres))
2265  return hres;
2266 
2267  return stack_push(ctx, jsval_bool(b));
2268 }
2269 
2270 /* ECMA-262 3rd Edition 11.9.5 */
2272 {
2273  jsval_t l, r;
2274  BOOL b;
2275  HRESULT hres;
2276 
2277  TRACE("\n");
2278 
2279  r = stack_pop(ctx);
2280  l = stack_pop(ctx);
2281 
2282  hres = jsval_strict_equal(r, l, &b);
2283  jsval_release(l);
2284  jsval_release(r);
2285  if(FAILED(hres))
2286  return hres;
2287 
2288  return stack_push(ctx, jsval_bool(!b));
2289 }
2290 
2291 /* ECMA-262 3rd Edition 11.8.5 */
2293 {
2294  double ln, rn;
2295  jsval_t l, r;
2296  HRESULT hres;
2297 
2298  hres = to_primitive(ctx, lval, &l, NO_HINT);
2299  if(FAILED(hres))
2300  return hres;
2301 
2302  hres = to_primitive(ctx, rval, &r, NO_HINT);
2303  if(FAILED(hres)) {
2304  jsval_release(l);
2305  return hres;
2306  }
2307 
2308  if(is_string(l) && is_string(r)) {
2309  *ret = (jsstr_cmp(get_string(l), get_string(r)) < 0) ^ greater;
2312  return S_OK;
2313  }
2314 
2315  hres = to_number(ctx, l, &ln);
2316  jsval_release(l);
2317  if(SUCCEEDED(hres))
2318  hres = to_number(ctx, r, &rn);
2319  jsval_release(r);
2320  if(FAILED(hres))
2321  return hres;
2322 
2323  *ret = !isnan(ln) && !isnan(rn) && ((ln < rn) ^ greater);
2324  return S_OK;
2325 }
2326 
2327 /* ECMA-262 3rd Edition 11.8.1 */
2329 {
2330  jsval_t l, r;
2331  BOOL b;
2332  HRESULT hres;
2333 
2334  r = stack_pop(ctx);
2335  l = stack_pop(ctx);
2336 
2337  TRACE("%s < %s\n", debugstr_jsval(l), debugstr_jsval(r));
2338 
2339  hres = less_eval(ctx, l, r, FALSE, &b);
2340  jsval_release(l);
2341  jsval_release(r);
2342  if(FAILED(hres))
2343  return hres;
2344 
2345  return stack_push(ctx, jsval_bool(b));
2346 }
2347 
2348 /* ECMA-262 3rd Edition 11.8.1 */
2350 {
2351  jsval_t l, r;
2352  BOOL b;
2353  HRESULT hres;
2354 
2355  r = stack_pop(ctx);
2356  l = stack_pop(ctx);
2357 
2358  TRACE("%s <= %s\n", debugstr_jsval(l), debugstr_jsval(r));
2359 
2360  hres = less_eval(ctx, r, l, TRUE, &b);
2361  jsval_release(l);
2362  jsval_release(r);
2363  if(FAILED(hres))
2364  return hres;
2365 
2366  return stack_push(ctx, jsval_bool(b));
2367 }
2368 
2369 /* ECMA-262 3rd Edition 11.8.2 */
2371 {
2372  jsval_t l, r;
2373  BOOL b;
2374  HRESULT hres;
2375 
2376  r = stack_pop(ctx);
2377  l = stack_pop(ctx);
2378 
2379  TRACE("%s > %s\n", debugstr_jsval(l), debugstr_jsval(r));
2380 
2381  hres = less_eval(ctx, r, l, FALSE, &b);
2382  jsval_release(l);
2383  jsval_release(r);
2384  if(FAILED(hres))
2385  return hres;
2386 
2387  return stack_push(ctx, jsval_bool(b));
2388 }
2389 
2390 /* ECMA-262 3rd Edition 11.8.4 */
2392 {
2393  jsval_t l, r;
2394  BOOL b;
2395  HRESULT hres;
2396 
2397  r = stack_pop(ctx);
2398  l = stack_pop(ctx);
2399 
2400  TRACE("%s >= %s\n", debugstr_jsval(l), debugstr_jsval(r));
2401 
2402  hres = less_eval(ctx, l, r, TRUE, &b);
2403  jsval_release(l);
2404  jsval_release(r);
2405  if(FAILED(hres))
2406  return hres;
2407 
2408  return stack_push(ctx, jsval_bool(b));
2409 }
2410 
2411 /* ECMA-262 3rd Edition 11.4.8 */
2413 {
2414  jsval_t v;
2415  INT i;
2416  HRESULT hres;
2417 
2418  TRACE("\n");
2419 
2420  v = stack_pop(ctx);
2421  hres = to_int32(ctx, v, &i);
2422  jsval_release(v);
2423  if(FAILED(hres))
2424  return hres;
2425 
2426  return stack_push(ctx, jsval_number(~i));
2427 }
2428 
2429 /* ECMA-262 3rd Edition 11.4.9 */
2431 {
2432  jsval_t v;
2433  BOOL b;
2434  HRESULT hres;
2435 
2436  TRACE("\n");
2437 
2438  v = stack_pop(ctx);
2439  hres = to_boolean(v, &b);
2440  jsval_release(v);
2441  if(FAILED(hres))
2442  return hres;
2443 
2444  return stack_push(ctx, jsval_bool(!b));
2445 }
2446 
2447 /* ECMA-262 3rd Edition 11.7.1 */
2449 {
2450  DWORD r;
2451  INT l;
2452  HRESULT hres;
2453 
2454  hres = stack_pop_uint(ctx, &r);
2455  if(FAILED(hres))
2456  return hres;
2457 
2458  hres = stack_pop_int(ctx, &l);
2459  if(FAILED(hres))
2460  return hres;
2461 
2462  return stack_push(ctx, jsval_number(l << (r&0x1f)));
2463 }
2464 
2465 /* ECMA-262 3rd Edition 11.7.2 */
2467 {
2468  DWORD r;
2469  INT l;
2470  HRESULT hres;
2471 
2472  hres = stack_pop_uint(ctx, &r);
2473  if(FAILED(hres))
2474  return hres;
2475 
2476  hres = stack_pop_int(ctx, &l);
2477  if(FAILED(hres))
2478  return hres;
2479 
2480  return stack_push(ctx, jsval_number(l >> (r&0x1f)));
2481 }
2482 
2483 /* ECMA-262 3rd Edition 11.7.3 */
2485 {
2486  DWORD r, l;
2487  HRESULT hres;
2488 
2489  hres = stack_pop_uint(ctx, &r);
2490  if(FAILED(hres))
2491  return hres;
2492 
2493  hres = stack_pop_uint(ctx, &l);
2494  if(FAILED(hres))
2495  return hres;
2496 
2497  return stack_push(ctx, jsval_number(l >> (r&0x1f)));
2498 }
2499 
2500 /* ECMA-262 3rd Edition 11.13.1 */
2502 {
2503  exprval_t ref;
2504  jsval_t v;
2505  HRESULT hres;
2506 
2507  TRACE("\n");
2508 
2509  v = stack_pop(ctx);
2510 
2511  if(!stack_pop_exprval(ctx, &ref)) {
2512  jsval_release(v);
2514  }
2515 
2516  hres = exprval_propput(ctx, &ref, v);
2517  exprval_release(&ref);
2518  if(FAILED(hres)) {
2519  jsval_release(v);
2520  return hres;
2521  }
2522 
2523  return stack_push(ctx, v);
2524 }
2525 
2526 /* JScript extension */
2528 {
2529  const unsigned argc = get_op_uint(ctx, 0);
2530  exprval_t ref;
2531  jsval_t v;
2532  HRESULT hres;
2533 
2534  TRACE("%u\n", argc);
2535 
2536  if(!stack_topn_exprval(ctx, argc+1, &ref))
2538 
2540  if(FAILED(hres))
2541  return hres;
2542 
2543  v = stack_pop(ctx);
2544  stack_popn(ctx, argc+2);
2545  return stack_push(ctx, v);
2546 }
2547 
2549 {
2550  TRACE("\n");
2551 
2552  return stack_push(ctx, jsval_undefined());
2553 }
2554 
2556 {
2557  const unsigned arg = get_op_uint(ctx, 0);
2558 
2559  TRACE("%u\n", arg);
2560 
2561  jmp_abs(ctx, arg);
2562  return S_OK;
2563 }
2564 
2566 {
2567  const unsigned arg = get_op_uint(ctx, 0);
2568  BOOL b;
2569  jsval_t v;
2570  HRESULT hres;
2571 
2572  TRACE("\n");
2573 
2574  v = stack_pop(ctx);
2575  hres = to_boolean(v, &b);
2576  jsval_release(v);
2577  if(FAILED(hres))
2578  return hres;
2579 
2580  if(b)
2581  jmp_next(ctx);
2582  else
2583  jmp_abs(ctx, arg);
2584  return S_OK;
2585 }
2586 
2588 {
2589  const unsigned arg = get_op_uint(ctx, 0);
2590 
2591  TRACE("%u\n", arg);
2592 
2593  stack_popn(ctx, arg);
2594  return S_OK;
2595 }
2596 
2598 {
2599  const unsigned clear_ret = get_op_uint(ctx, 0);
2600  call_frame_t *frame = ctx->call_ctx;
2601 
2602  TRACE("\n");
2603 
2604  if(clear_ret)
2605  jsval_release(steal_ret(frame));
2606 
2607  if((frame->flags & EXEC_CONSTRUCTOR) && !is_object_instance(frame->ret)) {
2608  jsval_release(frame->ret);
2609  IDispatch_AddRef(frame->this_obj);
2610  frame->ret = jsval_disp(frame->this_obj);
2611  }
2612 
2613  jmp_abs(ctx, -1);
2614  return S_OK;
2615 }
2616 
2618 {
2619  call_frame_t *frame = ctx->call_ctx;
2620 
2621  TRACE("\n");
2622 
2623  jsval_release(frame->ret);
2624  frame->ret = stack_pop(ctx);
2625  return S_OK;
2626 }
2627 
2629 {
2630  HRESULT hres;
2631 
2632  TRACE("\n");
2633 
2634  hres = stack_push(ctx, ctx->acc);
2635  if(SUCCEEDED(hres))
2636  ctx->acc = jsval_undefined();
2637  return hres;
2638 }
2639 
2641 
2642 static const op_func_t op_funcs[] = {
2643 #define X(x,a,b,c) interp_##x,
2644 OP_LIST
2645 #undef X
2646 };
2647 
2648 static const unsigned op_move[] = {
2649 #define X(a,x,b,c) x,
2650 OP_LIST
2651 #undef X
2652 };
2653 
2654 static void pop_call_frame(script_ctx_t *ctx)
2655 {
2656  call_frame_t *frame = ctx->call_ctx;
2657 
2658  frame->stack_base -= frame->pop_locals + frame->pop_variables;
2659 
2660  assert(frame->scope == frame->base_scope);
2661 
2662  /* If current scope will be kept alive, we need to transfer local variables to its variable object. */
2663  if(frame->scope && frame->scope->ref > 1) {
2664  HRESULT hres = detach_variable_object(ctx, frame, TRUE);
2665  if(FAILED(hres))
2666  ERR("Failed to detach variable object: %08x\n", hres);
2667  }
2668 
2669  if(frame->arguments_obj)
2671  if(frame->scope)
2672  scope_release(frame->scope);
2673 
2674  if(frame->pop_variables)
2675  stack_popn(ctx, frame->pop_variables);
2676  stack_popn(ctx, frame->pop_locals);
2677 
2678  ctx->call_ctx = frame->prev_frame;
2679 
2680  if(frame->function_instance)
2682  if(frame->variable_obj)
2683  jsdisp_release(frame->variable_obj);
2684  if(frame->this_obj)
2685  IDispatch_Release(frame->this_obj);
2686  jsval_release(frame->ret);
2687  release_bytecode(frame->bytecode);
2688  heap_free(frame);
2689 }
2690 
2692 {
2693  unsigned depth = 0, i;
2694  call_frame_t *frame;
2695 
2696  for(frame = ctx->call_ctx; frame; frame = frame->prev_frame) {
2697  WARN("%u\t", depth);
2698  depth++;
2699 
2700  if(frame->this_obj && frame->this_obj != to_disp(ctx->global) && frame->this_obj != ctx->host_global)
2701  WARN("%p->", frame->this_obj);
2702  WARN("%s(", frame->function->name ? debugstr_w(frame->function->name) : "[unnamed]");
2703  if(frame->base_scope && frame->base_scope->frame) {
2704  for(i=0; i < frame->argc; i++) {
2705  if(i < frame->function->param_cnt)
2706  WARN("%s%s=%s", i ? ", " : "", debugstr_w(frame->function->params[i]),
2707  debugstr_jsval(ctx->stack[local_off(frame, -i-1)]));
2708  else
2709  WARN("%s%s", i ? ", " : "", debugstr_jsval(ctx->stack[local_off(frame, -i-1)]));
2710  }
2711  }else {
2712  WARN("[detached frame]");
2713  }
2714  WARN(")\n");
2715 
2716  if(!(frame->flags & EXEC_RETURN_TO_INTERP)) {
2717  WARN("%u\t[native code]\n", depth);
2718  depth++;
2719  }
2720  }
2721 }
2722 
2723 static HRESULT unwind_exception(script_ctx_t *ctx, HRESULT exception_hres)
2724 {
2725  except_frame_t *except_frame;
2726  call_frame_t *frame;
2727  jsval_t except_val;
2728  unsigned catch_off;
2729  HRESULT hres;
2730 
2731  if(WARN_ON(jscript)) {
2732  jsdisp_t *error_obj;
2733  jsval_t msg;
2734 
2735  static const WCHAR messageW[] = {'m','e','s','s','a','g','e',0};
2736 
2737  WARN("Exception %08x %s", exception_hres, debugstr_jsval(ctx->ei.val));
2738  if(jsval_type(ctx->ei.val) == JSV_OBJECT) {
2739  error_obj = to_jsdisp(get_object(ctx->ei.val));
2740  if(error_obj) {
2741  hres = jsdisp_propget_name(error_obj, messageW, &msg);
2742  if(SUCCEEDED(hres)) {
2743  WARN(" (message %s)", debugstr_jsval(msg));
2744  jsval_release(msg);
2745  }
2746  }
2747  }
2748  WARN(" in:\n");
2749 
2750  print_backtrace(ctx);
2751  }
2752 
2753  for(frame = ctx->call_ctx; !frame->except_frame; frame = ctx->call_ctx) {
2754  DWORD flags;
2755 
2756  while(frame->scope != frame->base_scope)
2757  scope_pop(&frame->scope);
2758 
2759  stack_popn(ctx, ctx->stack_top-frame->stack_base);
2760 
2761  flags = frame->flags;
2762  pop_call_frame(ctx);
2763  if(!(flags & EXEC_RETURN_TO_INTERP))
2764  return exception_hres;
2765  }
2766 
2767  except_frame = frame->except_frame;
2768  catch_off = except_frame->catch_off;
2769 
2770  assert(except_frame->stack_top <= ctx->stack_top);
2771  stack_popn(ctx, ctx->stack_top - except_frame->stack_top);
2772 
2773  while(except_frame->scope != frame->scope)
2774  scope_pop(&frame->scope);
2775 
2776  frame->ip = catch_off ? catch_off : except_frame->finally_off;
2777  if(catch_off) assert(frame->bytecode->instrs[frame->ip].op == OP_enter_catch);
2778 
2779  except_val = ctx->ei.val;
2780  ctx->ei.val = jsval_undefined();
2781  clear_ei(ctx);
2782 
2783  /* keep current except_frame if we're entering catch block with finally block associated */
2784  if(catch_off && except_frame->finally_off) {
2785  except_frame->catch_off = 0;
2786  }else {
2787  frame->except_frame = except_frame->next;
2788  heap_free(except_frame);
2789  }
2790 
2791  hres = stack_push(ctx, except_val);
2792  if(FAILED(hres))
2793  return hres;
2794 
2795  if(!catch_off)
2796  hres = stack_push(ctx, jsval_bool(FALSE));
2797  return hres;
2798 }
2799 
2801 {
2802  call_frame_t *frame;
2803  jsop_t op;
2804  HRESULT hres = S_OK;
2805 
2806  TRACE("\n");
2807 
2808  while(1) {
2809  frame = ctx->call_ctx;
2810  op = frame->bytecode->instrs[frame->ip].op;
2811  hres = op_funcs[op](ctx);
2812  if(FAILED(hres)) {
2813  hres = unwind_exception(ctx, hres);
2814  if(FAILED(hres))
2815  return hres;
2816  }else if(frame->ip == -1) {
2817  const DWORD return_to_interp = frame->flags & EXEC_RETURN_TO_INTERP;
2818 
2819  assert(ctx->stack_top == frame->stack_base);
2820  assert(frame->scope == frame->base_scope);
2821 
2822  if(return_to_interp) {
2823  jsval_release(ctx->acc);
2824  ctx->acc = steal_ret(frame);
2825  }else if(r) {
2826  *r = steal_ret(frame);
2827  }
2828  pop_call_frame(ctx);
2829  if(!return_to_interp)
2830  break;
2831  }else {
2832  frame->ip += op_move[op];
2833  }
2834  }
2835 
2836  return S_OK;
2837 }
2838 
2840 {
2842  exprval_t exprval;
2843  IDispatch *disp;
2844  jsval_t v;
2845  HRESULT hres;
2846 
2847  hres = identifier_eval(ctx, func->event_target, &exprval);
2848  if(FAILED(hres))
2849  return hres;
2850 
2851  hres = exprval_to_value(ctx, &exprval, &v);
2852  if(FAILED(hres))
2853  return hres;
2854 
2855  if(!is_object_instance(v)) {
2856  FIXME("Can't bind to %s\n", debugstr_jsval(v));
2857  jsval_release(v);
2858  }
2859 
2860  disp = get_object(v);
2861  hres = IDispatch_QueryInterface(disp, &IID_IBindEventHandler, (void**)&target);
2862  if(SUCCEEDED(hres)) {
2863  hres = IBindEventHandler_BindHandler(target, func->name, (IDispatch*)&func_obj->IDispatchEx_iface);
2864  IBindEventHandler_Release(target);
2865  if(FAILED(hres))
2866  WARN("BindEvent failed: %08x\n", hres);
2867  }else {
2868  FIXME("No IBindEventHandler, not yet supported binding\n");
2869  }
2870 
2871  IDispatch_Release(disp);
2872  return hres;
2873 }
2874 
2875 static HRESULT setup_scope(script_ctx_t *ctx, call_frame_t *frame, scope_chain_t *scope_chain, jsdisp_t *variable_object, unsigned argc, jsval_t *argv)
2876 {
2877  const unsigned orig_stack = ctx->stack_top;
2878  scope_chain_t *scope;
2879  unsigned i;
2880  jsval_t v;
2881  HRESULT hres;
2882 
2883  /* If arguments are already on the stack, we may use them. */
2884  if(argv + argc == ctx->stack + ctx->stack_top) {
2885  frame->arguments_off = argv - ctx->stack;
2886  i = argc;
2887  }else {
2888  frame->arguments_off = ctx->stack_top;
2889  for(i = 0; i < argc; i++) {
2890  hres = jsval_copy(argv[i], &v);
2891  if(SUCCEEDED(hres))
2892  hres = stack_push(ctx, v);
2893  if(FAILED(hres)) {
2894  stack_popn(ctx, i);
2895  return hres;
2896  }
2897  }
2898  }
2899 
2900  /* If fewer than declared arguments were passed, fill remaining with undefined value. */
2901  for(; i < frame->function->param_cnt; i++) {
2902  hres = stack_push(ctx, jsval_undefined());
2903  if(FAILED(hres)) {
2904  stack_popn(ctx, ctx->stack_top - orig_stack);
2905  return hres;
2906  }
2907  }
2908 
2909  frame->pop_locals = ctx->stack_top - orig_stack;
2910 
2911  frame->variables_off = ctx->stack_top;
2912 
2913  for(i = 0; i < frame->function->var_cnt; i++) {
2914  hres = stack_push(ctx, jsval_undefined());
2915  if(FAILED(hres)) {
2916  stack_popn(ctx, ctx->stack_top - orig_stack);
2917  return hres;
2918  }
2919  }
2920 
2921  frame->pop_variables = i;
2922 
2923  hres = scope_push(scope_chain, variable_object, to_disp(variable_object), &scope);
2924  if(FAILED(hres)) {
2925  stack_popn(ctx, ctx->stack_top - orig_stack);
2926  return hres;
2927  }
2928 
2929  for(i = 0; i < frame->function->func_cnt; i++) {
2930  if(frame->function->funcs[i].name && !frame->function->funcs[i].event_target) {
2931  jsdisp_t *func_obj;
2932  unsigned off;
2933 
2934  hres = create_source_function(ctx, frame->bytecode, frame->function->funcs+i, scope, &func_obj);
2935  if(FAILED(hres)) {
2936  stack_popn(ctx, ctx->stack_top - orig_stack);
2937  scope_release(scope);
2938  return hres;
2939  }
2940 
2941  off = local_off(frame, frame->function->funcs[i].local_ref);
2942  jsval_release(ctx->stack[off]);
2943  ctx->stack[off] = jsval_obj(func_obj);
2944  }
2945  }
2946 
2947  scope->frame = frame;
2948  frame->base_scope = frame->scope = scope;
2949  return S_OK;
2950 }
2951 
2953  IDispatch *this_obj, jsdisp_t *function_instance, jsdisp_t *variable_obj, unsigned argc, jsval_t *argv, jsval_t *r)
2954 {
2955  call_frame_t *frame;
2956  unsigned i;
2957  HRESULT hres;
2958 
2959  for(i = 0; i < function->func_cnt; i++) {
2960  jsdisp_t *func_obj;
2961 
2962  if(!function->funcs[i].event_target)
2963  continue;
2964 
2965  hres = create_source_function(ctx, bytecode, function->funcs+i, scope, &func_obj);
2966  if(FAILED(hres))
2967  return hres;
2968 
2969  hres = bind_event_target(ctx, function->funcs+i, func_obj);
2970  jsdisp_release(func_obj);
2971  if(FAILED(hres))
2972  return hres;
2973  }
2974 
2975  if(flags & (EXEC_GLOBAL | EXEC_EVAL)) {
2976  for(i=0; i < function->var_cnt; i++) {
2977  TRACE("[%d] %s %d\n", i, debugstr_w(function->variables[i].name), function->variables[i].func_id);
2978  if(function->variables[i].func_id != -1) {
2979  jsdisp_t *func_obj;
2980 
2981  hres = create_source_function(ctx, bytecode, function->funcs+function->variables[i].func_id, scope, &func_obj);
2982  if(FAILED(hres))
2983  return hres;
2984 
2985  hres = jsdisp_propput_name(variable_obj, function->variables[i].name, jsval_obj(func_obj));
2986  jsdisp_release(func_obj);
2987  }else if(!(flags & EXEC_GLOBAL) || !lookup_global_members(ctx, function->variables[i].name, NULL)) {
2988  DISPID id = 0;
2989 
2990  hres = jsdisp_get_id(variable_obj, function->variables[i].name, fdexNameEnsure, &id);
2991  if(FAILED(hres))
2992  return hres;
2993  }
2994  }
2995  }
2996 
2997  /* ECMA-262 3rd Edition 11.2.3.7 */
2998  if(this_obj) {
2999  jsdisp_t *jsthis;
3000 
3001  jsthis = iface_to_jsdisp(this_obj);
3002  if(jsthis) {
3003  if(jsthis->builtin_info->class == JSCLASS_GLOBAL || jsthis->builtin_info->class == JSCLASS_NONE)
3004  this_obj = NULL;
3005  jsdisp_release(jsthis);
3006  }
3007  }
3008 
3009  if(ctx->call_ctx && (flags & EXEC_EVAL)) {
3010  hres = detach_variable_object(ctx, ctx->call_ctx, FALSE);
3011  if(FAILED(hres))
3012  return hres;
3013  }
3014 
3015  frame = heap_alloc_zero(sizeof(*frame));
3016  if(!frame)
3017  return E_OUTOFMEMORY;
3018 
3019  frame->function = function;
3020  frame->ret = jsval_undefined();
3021  frame->argc = argc;
3022  frame->bytecode = bytecode_addref(bytecode);
3023 
3024  if(!(flags & (EXEC_GLOBAL|EXEC_EVAL))) {
3025  hres = setup_scope(ctx, frame, scope, variable_obj, argc, argv);
3026  if(FAILED(hres)) {
3027  release_bytecode(frame->bytecode);
3028  heap_free(frame);
3029  return hres;
3030  }
3031  }else if(scope) {
3032  frame->base_scope = frame->scope = scope_addref(scope);
3033  }
3034 
3035  frame->ip = function->instr_off;
3036  frame->stack_base = ctx->stack_top;
3037  if(this_obj)
3038  frame->this_obj = this_obj;
3039  else if(ctx->host_global)
3040  frame->this_obj = ctx->host_global;
3041  else
3042  frame->this_obj = to_disp(ctx->global);
3043  IDispatch_AddRef(frame->this_obj);
3044 
3045  if(function_instance)
3046  frame->function_instance = jsdisp_addref(function_instance);
3047 
3048  frame->flags = flags;
3049  frame->variable_obj = jsdisp_addref(variable_obj);
3050 
3051  frame->prev_frame = ctx->call_ctx;
3052  ctx->call_ctx = frame;
3053 
3055  /*
3056  * We're called directly from interpreter, so we may just setup call frame and return.
3057  * Already running interpreter will take care of execution.
3058  */
3059  if(r)
3060  *r = jsval_undefined();
3061  return S_OK;
3062  }
3063 
3064  return enter_bytecode(ctx, r);
3065 }
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble * u
Definition: glfuncs.h:240
HRESULT to_uint32(script_ctx_t *, jsval_t, UINT32 *) DECLSPEC_HIDDEN
Definition: jsutils.c:678
jsstr_t * jsstr_alloc_len(const WCHAR *buf, unsigned len)
Definition: jsstr.c:86
jsval_t ret
Definition: engine.h:228
#define DISP_E_EXCEPTION
Definition: winerror.h:2518
Definition: jsval.h:54
jsdisp_t * arguments_obj
Definition: engine.h:233
unsigned arguments_off
Definition: engine.h:238
GLenum func
Definition: glext.h:6028
#define DISP_E_UNKNOWNNAME
Definition: winerror.h:2515
static jsstr_t * jsstr_alloc(const WCHAR *str)
Definition: jsstr.h:103
static HRESULT setup_scope(script_ctx_t *ctx, call_frame_t *frame, scope_chain_t *scope_chain, jsdisp_t *variable_object, unsigned argc, jsval_t *argv)
Definition: engine.c:2875
static const WCHAR * jsstr_flatten(jsstr_t *str)
Definition: jsstr.h:139
union instr_t::@414 u
disp
Definition: i386-dis.c:3181
static HRESULT interp_carray(script_ctx_t *ctx)
Definition: engine.c:1401
except_frame_t * except_frame
Definition: engine.h:223
static int argc
Definition: ServiceArgs.c:12
void jsval_release(jsval_t val)
Definition: jsutils.c:189
static HRESULT exprval_call(script_ctx_t *ctx, exprval_t *ref, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r)
Definition: engine.c:313
static HRESULT interp_tonum(script_ctx_t *ctx)
Definition: engine.c:2048
static const WCHAR numberW[]
Definition: engine.c:34
static HRESULT interp_push_except(script_ctx_t *ctx)
Definition: engine.c:904
static HRESULT interp_obj_prop(script_ctx_t *ctx)
Definition: engine.c:1450
static void stack_popn(script_ctx_t *ctx, unsigned n)
Definition: engine.c:133
#define TRUE
Definition: types.h:120
struct _function_code_t * funcs
Definition: engine.h:155
static HRESULT interp_memberid(script_ctx_t *ctx)
Definition: engine.c:1094
static HRESULT interp_identid(script_ctx_t *ctx)
Definition: engine.c:1325
jsstr_t * jsstr_concat(jsstr_t *str1, jsstr_t *str2)
Definition: jsstr.c:211
static HRESULT detach_variable_object(script_ctx_t *ctx, call_frame_t *frame, BOOL from_release)
Definition: engine.c:571
DWORD flags
Definition: engine.h:234
#define JS_E_FUNCTION_EXPECTED
Definition: jscript.h:553
static void print_backtrace(script_ctx_t *ctx)
Definition: engine.c:2691
ULONG nr
Definition: thread.c:7
jsstr_t * jsstr_undefined(void)
Definition: jsstr.c:293
static jsstr_t * get_op_str(script_ctx_t *ctx, int i)
Definition: engine.c:734
static HRESULT identifier_value(script_ctx_t *ctx, BSTR identifier)
Definition: engine.c:1258
Definition: jsstr.h:39
static HRESULT bind_event_target(script_ctx_t *ctx, function_code_t *func, jsdisp_t *func_obj)
Definition: engine.c:2839
static HRESULT stack_pop_object(script_ctx_t *ctx, IDispatch **r)
Definition: engine.c:150
static jsval_t steal_ret(call_frame_t *frame)
Definition: engine.c:386
jsdisp_t * jsobj
Definition: engine.h:204
__wchar_t WCHAR
Definition: xmlstorage.h:180
static jsval_t jsval_null(void)
Definition: jsval.h:130
static IDispatch * get_object(jsval_t v)
Definition: jsval.h:219
instr_arg_t arg[2]
Definition: engine.h:129
static jsstr_t * jsstr_addref(jsstr_t *str)
Definition: jsstr.h:116
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
jsdisp_t * variable_obj
Definition: engine.h:232
static unsigned local_off(call_frame_t *frame, int ref)
Definition: engine.c:178
unsigned stack_base
Definition: engine.h:224
static void pop_call_frame(script_ctx_t *ctx)
Definition: engine.c:2654
static HRESULT interp_typeofident(script_ctx_t *ctx)
Definition: engine.c:1985
static HRESULT interp_xor(script_ctx_t *ctx)
Definition: engine.c:1555
#define WARN(fmt,...)
Definition: debug.h:111
static HRESULT stack_push_string(script_ctx_t *ctx, const WCHAR *str)
Definition: engine.c:91
const builtin_info_t * builtin_info
Definition: jscript.h:238
IDispatch * obj
Definition: engine.h:205
void detach_arguments_object(jsdisp_t *) DECLSPEC_HIDDEN
Definition: function.c:199
static HRESULT interp_array(script_ctx_t *ctx)
Definition: engine.c:1023
IDispatch * disp
Definition: engine.c:59
static unsigned get_op_int(script_ctx_t *ctx, int i)
Definition: engine.c:728
unsigned off
Definition: engine.c:62
static double get_op_double(script_ctx_t *ctx)
Definition: engine.c:740
static HRESULT interp_rshift2(script_ctx_t *ctx)
Definition: engine.c:2484
GLdouble n
Definition: glext.h:7729
static const WCHAR messageW[]
Definition: error.c:31
static HRESULT interp_func(script_ctx_t *ctx)
Definition: engine.c:1005
static HRESULT interp_div(script_ctx_t *ctx)
Definition: engine.c:1800
static BOOL is_undefined(jsval_t v)
Definition: jsval.h:171
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
static HRESULT interp_add(script_ctx_t *ctx)
Definition: engine.c:1742
#define assert(x)
Definition: debug.h:53
static void clear_acc(script_ctx_t *ctx)
Definition: engine.c:393
static void jmp_abs(script_ctx_t *ctx, unsigned dst)
Definition: engine.c:751
struct _call_frame_t * call_ctx
Definition: jscript.h:410
static HRESULT interp_preinc(script_ctx_t *ctx)
Definition: engine.c:2096
static HRESULT interp_jmp(script_ctx_t *ctx)
Definition: engine.c:2555
static HRESULT interp_delete_ident(script_ctx_t *ctx)
Definition: engine.c:1875
union exprval_t::@412 u
unsigned func_cnt
Definition: engine.h:154
static BOOL is_string(parse_buffer *buf)
Definition: parsing.c:601
static HRESULT stack_push_exprval(script_ctx_t *ctx, exprval_t *val)
Definition: engine.c:191
static jsval_t stack_topn(script_ctx_t *ctx, unsigned n)
Definition: engine.c:114
static HRESULT interp_local_ref(script_ctx_t *ctx)
Definition: engine.c:1278
static HRESULT interp_neg(script_ctx_t *ctx)
Definition: engine.c:2430
static HRESULT scope_push(scope_chain_t *scope, jsdisp_t *jsobj, IDispatch *obj, scope_chain_t **ret)
Definition: engine.c:399
jsdisp_t * function_instance
Definition: engine.h:231
OLECHAR * BSTR
Definition: compat.h:1927
static HRESULT interp_str(script_ctx_t *ctx)
Definition: engine.c:1374
static void jsstr_release(jsstr_t *str)
Definition: jsstr.h:110
function_code_t * function
Definition: engine.h:243
static void exprval_set_exception(exprval_t *val, HRESULT hres)
Definition: engine.c:368
static const WCHAR prototypeW[]
Definition: function.c:67
#define argv
Definition: mplay32.c:18
static HRESULT interp_cnd_z(script_ctx_t *ctx)
Definition: engine.c:1514
static BOOL is_number(jsval_t v)
Definition: jsval.h:191
void clear_ei(script_ctx_t *ctx)
Definition: engine.c:428
static HRESULT interp_local(script_ctx_t *ctx)
Definition: engine.c:1295
#define EXEC_RETURN_TO_INTERP
Definition: engine.h:250
#define PROPF_ENUMERABLE
Definition: jscript.h:97
#define E_FAIL
Definition: ddrawi.h:102
#define EXEC_EVAL
Definition: engine.h:251
#define EXEC_CONSTRUCTOR
Definition: engine.h:249
static BOOL is_null_instance(jsval_t v)
Definition: jsval.h:181
int32_t INT
Definition: typedefs.h:56
static HRESULT interp_double(script_ctx_t *ctx)
Definition: engine.c:1364
Definition: send.c:47
scope_chain_t * scope
Definition: engine.h:225
struct _scope_chain_t * next
Definition: engine.h:207
static void * heap_realloc(void *mem, size_t len)
Definition: appwiz.h:70
IDispatch * host_global
Definition: jscript.h:424
static const WCHAR stringW[]
Definition: engine.c:36
jsdisp_t * to_jsdisp(IDispatch *disp)
Definition: dispex.c:935
static void * heap_alloc(size_t len)
Definition: appwiz.h:65
static HRESULT interp_in(script_ctx_t *ctx)
Definition: engine.c:1651
#define DISPATCH_METHOD
Definition: oleauto.h:1006
local_ref_t * locals
Definition: engine.h:167
static HRESULT interp_case(script_ctx_t *ctx)
Definition: engine.c:848
GLsizei GLsizei GLuint * obj
Definition: glext.h:6042
unsigned ip
Definition: engine.h:222
BSTR name
Definition: engine.h:141
static HRESULT interp_enter_catch(script_ctx_t *ctx)
Definition: engine.c:984
double dbl
Definition: engine.h:130
unsigned var_cnt
Definition: engine.h:157
static HRESULT exprval_propput(script_ctx_t *ctx, exprval_t *ref, jsval_t v)
Definition: engine.c:284
static DWORD unk1
Definition: cursoricon.c:1521
#define WARN_ON(c)
Definition: module.h:255
static HRESULT disp_get_id(script_ctx_t *ctx, IDispatch *disp, const WCHAR *name, BSTR name_bstr, DWORD flags, DISPID *id)
Definition: engine.c:447
static HRESULT interp_gteq(script_ctx_t *ctx)
Definition: engine.c:2391
static HRESULT interp_null(script_ctx_t *ctx)
Definition: engine.c:1336
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
static HRESULT interp_eq2(script_ctx_t *ctx)
Definition: engine.c:2250
static scope_chain_t * scope_addref(scope_chain_t *scope)
Definition: engine.h:212
int jsstr_cmp(jsstr_t *str1, jsstr_t *str2)
Definition: jsstr.c:189
HRESULT to_number(script_ctx_t *, jsval_t, double *) DECLSPEC_HIDDEN
Definition: jsutils.c:601
bytecode_t * bytecode
Definition: engine.h:242
#define JS_E_ILLEGAL_ASSIGN
Definition: jscript.h:557
#define E_OUTOFMEMORY
Definition: ddrawi.h:100
static D3DRMMATRIX4D identity
Definition: frame.c:29
IDispatchEx IDispatchEx_iface
Definition: jscript.h:227
static HRESULT disp_cmp(IDispatch *disp1, IDispatch *disp2, BOOL *ret)
Definition: engine.c:484
static const WCHAR undefinedW[]
Definition: engine.c:37
static HRESULT interp_setret(script_ctx_t *ctx)
Definition: engine.c:2617
HRESULT jsval_copy(jsval_t v, jsval_t *r)
Definition: jsutils.c:229
static BOOL is_class(jsdisp_t *jsdisp, jsclass_t class)
Definition: jscript.h:497
static jsstr_t * get_string(jsval_t v)
Definition: jsval.h:229
HRESULT(* op_func_t)(script_ctx_t *)
Definition: engine.c:2640
static HRESULT interp_bool(script_ctx_t *ctx)
Definition: engine.c:1344
static BOOL get_bool(D3DXPARAMETER_TYPE type, const void *data)
HRESULT disp_call(script_ctx_t *ctx, IDispatch *disp, DISPID id, WORD flags, unsigned argc, jsval_t *argv, jsval_t *ret)
Definition: dispex.c:1157
static HRESULT enter_bytecode(script_ctx_t *ctx, jsval_t *r)
Definition: engine.c:2800
#define debugstr_w
Definition: kernel32.h:32
unsigned stack_top
Definition: engine.c:41
GLenum GLint ref
Definition: glext.h:6028
#define FIXME(fmt,...)
Definition: debug.h:110
static PVOID ptr
Definition: dispmode.c:27
jsval_t acc
Definition: jscript.h:429
static HRESULT to_string(VARIANT *src, BSTR *dst)
Definition: host.c:48
static HRESULT interp_delete(script_ctx_t *ctx)
Definition: engine.c:1838
static void scope_pop(scope_chain_t **scope)
Definition: engine.c:419
static const char mbstate_t *static wchar_t const char mbstate_t *static const wchar_t int *static double
Definition: string.c:80
HRESULT disp_propget(script_ctx_t *ctx, IDispatch *disp, DISPID id, jsval_t *val)
Definition: dispex.c:1479
LONG lng
Definition: engine.h:110
const WCHAR * str
const struct builtin_class_descr * desc
Definition: regcontrol.c:48
UINT msg
Definition: msvc.h:92
static HRESULT interp_member(script_ctx_t *ctx)
Definition: engine.c:1065
static HRESULT interp_push_acc(script_ctx_t *ctx)
Definition: engine.c:2628
static HRESULT interp_typeofid(script_ctx_t *ctx)
Definition: engine.c:1959
smooth NULL
Definition: ftsmooth.c:416
jsval_t val
Definition: jscript.h:396
BSTR WINAPI SysAllocString(LPCOLESTR str)
Definition: oleaut.c:241
HRESULT to_int32(script_ctx_t *, jsval_t, INT *) DECLSPEC_HIDDEN
Definition: jsutils.c:657
jsstr_t * str
Definition: engine.h:111
static BOOL is_object_instance(jsval_t v)
Definition: jsval.h:166
static HRESULT interp_regexp(script_ctx_t *ctx)
Definition: engine.c:1384
static jsval_t stack_top(script_ctx_t *ctx)
Definition: engine.c:102
GLuint index
Definition: glext.h:6031
static jsval_t jsval_string(jsstr_t *str)
Definition: jsval.h:109
#define DISPATCH_PROPERTYPUT
Definition: oleauto.h:1008
#define b
Definition: ke_i.h:79
static DWORD make_grfdex(script_ctx_t *ctx, DWORD flags)
Definition: jscript.h:520
static HRESULT typeof_string(jsval_t v, const WCHAR **ret)
Definition: engine.c:1921
static HRESULT interp_new(script_ctx_t *ctx)
Definition: engine.c:1161
static unsigned get_op_uint(script_ctx_t *ctx, int i)
Definition: engine.c:722
GLuint GLfloat * val
Definition: glext.h:7180
static HRESULT interp_void(script_ctx_t *ctx)
Definition: engine.c:1912
static HRESULT interp_eq(script_ctx_t *ctx)
Definition: engine.c:2208
_In_ ULONG _In_ ULONG_PTR ident
Definition: winddi.h:3993
static BSTR get_op_bstr(script_ctx_t *ctx, int i)
Definition: engine.c:716
static void exprval_set_disp_ref(exprval_t *ref, IDispatch *obj, DISPID id)
Definition: engine.c:374
HRESULT disp_propput(script_ctx_t *ctx, IDispatch *disp, DISPID id, jsval_t val)
Definition: dispex.c:1380
r l[0]
Definition: byte_order.h:167
HRESULT create_regexp(script_ctx_t *, jsstr_t *, DWORD, jsdisp_t **) DECLSPEC_HIDDEN
Definition: jsregexp.c:644
static HRESULT interp_sub(script_ctx_t *ctx)
Definition: engine.c:1762
HRESULT jsval_strict_equal(jsval_t lval, jsval_t rval, BOOL *ret)
Definition: engine.c:529
static HRESULT interp_postinc(script_ctx_t *ctx)
Definition: engine.c:2066
static HRESULT interp_pop(script_ctx_t *ctx)
Definition: engine.c:2587
_Check_return_ double __cdecl fmod(_In_ double x, _In_ double y)
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
HRESULT exec_source(script_ctx_t *ctx, DWORD flags, bytecode_t *bytecode, function_code_t *function, scope_chain_t *scope, IDispatch *this_obj, jsdisp_t *function_instance, jsdisp_t *variable_obj, unsigned argc, jsval_t *argv, jsval_t *r)
Definition: engine.c:2952
HRESULT jsdisp_define_property(jsdisp_t *obj, const WCHAR *name, property_desc_t *desc)
Definition: dispex.c:1670
#define TRACE(s)
Definition: solgame.cpp:4
const char * debugstr_jsstr(jsstr_t *str)
Definition: jsstr.c:37
Definition: jsval.h:46
static jsval_t jsval_disp(IDispatch *obj)
Definition: jsval.h:117
unsigned int BOOL
Definition: ntddk_ex.h:94
HRESULT hres
Definition: protocol.c:465
static jsval_t * stack_top_ref(script_ctx_t *ctx, unsigned n)
Definition: engine.c:108
static HRESULT interp_throw(script_ctx_t *ctx)
Definition: engine.c:873
HRESULT jsdisp_propget_name(jsdisp_t *obj, const WCHAR *name, jsval_t *val)
Definition: dispex.c:1429
static HRESULT interp_throw_ref(script_ctx_t *ctx)
Definition: engine.c:882
LONG HRESULT
Definition: typedefs.h:77
const GUID IID_IUnknown
static HRESULT interp_ret(script_ctx_t *ctx)
Definition: engine.c:2597
unsigned stack_top
Definition: jscript.h:428
struct _call_frame_t * frame
Definition: engine.h:206
static HRESULT interp_assign_call(script_ctx_t *ctx)
Definition: engine.c:2527
#define JS_E_OBJECT_REQUIRED
Definition: jscript.h:532
static const WCHAR unknownW[]
Definition: engine.c:38
unsigned short WORD
Definition: ntddk_ex.h:93
unsigned long DWORD
Definition: ntddk_ex.h:95
static HRESULT interp_lshift(script_ctx_t *ctx)
Definition: engine.c:2448
HRESULT to_boolean(jsval_t, BOOL *) DECLSPEC_HIDDEN
Definition: jsutils.c:464
static BOOL is_null(jsval_t v)
Definition: jsval.h:176
static HRESULT interp_or(script_ctx_t *ctx)
Definition: engine.c:1536
static jsdisp_t * jsdisp_addref(jsdisp_t *jsdisp)
Definition: jscript.h:258
static HRESULT interp_forin(script_ctx_t *ctx)
Definition: engine.c:757
static HRESULT interp_pop_scope(script_ctx_t *ctx)
Definition: engine.c:839
except_frame_t * next
Definition: engine.c:46
instr_t * instrs
Definition: engine.h:175
#define JS_E_INVALID_ACTION
Definition: jscript.h:535
GLbitfield flags
Definition: glext.h:7161
static HRESULT interp_and(script_ctx_t *ctx)
Definition: engine.c:1574
static HRESULT interp_call_member(script_ctx_t *ctx)
Definition: engine.c:1203
static VARIANT * get_variant(jsval_t v)
Definition: jsval.h:234
#define JS_E_INVALID_PROPERTY
Definition: jscript.h:534
jsop_t op
Definition: engine.h:127
static HRESULT interp_jmp_z(script_ctx_t *ctx)
Definition: engine.c:2565
static HRESULT less_eval(script_ctx_t *ctx, jsval_t lval, jsval_t rval, BOOL greater, BOOL *ret)
Definition: engine.c:2292
const GUID IID_IDispatch
static double get_number(jsval_t v)
Definition: jsval.h:224
unsigned param_cnt
Definition: engine.h:163
static HRESULT interp_mul(script_ctx_t *ctx)
Definition: engine.c:1781
GLint GLint GLsizei GLsizei GLsizei depth
Definition: gl.h:1546
static const unsigned op_move[]
Definition: engine.c:2648
int ret
static int local_ref_cmp(const void *key, const void *ref)
Definition: engine.c:622
static BOOL stack_pop_exprval(script_ctx_t *ctx, exprval_t *r)
Definition: engine.c:277
#define IID_NULL
Definition: guiddef.h:93
float rval
Definition: cylfrac.c:48
static jsval_type_t jsval_type(jsval_t v)
Definition: jsval.h:210
jsop_t
Definition: engine.h:101
jsval_t val
Definition: engine.c:57
#define EXEC_GLOBAL
Definition: engine.h:248
#define except(x)
Definition: btrfs_drv.h:127
jsclass_t class
Definition: jscript.h:215
HRESULT jsdisp_get_id(jsdisp_t *jsdisp, const WCHAR *name, DWORD flags, DISPID *id)
Definition: dispex.c:1088
UINT WINAPI SysStringLen(BSTR str)
Definition: oleaut.c:199
static HRESULT interp_bneg(script_ctx_t *ctx)
Definition: engine.c:2412
HRESULT disp_delete(IDispatch *disp, DISPID id, BOOL *ret)
Definition: dispex.c:1532
static HRESULT interp_mod(script_ctx_t *ctx)
Definition: engine.c:1819
static HRESULT interp_typeof(script_ctx_t *ctx)
Definition: engine.c:2015
local_ref_t * lookup_local(const function_code_t *function, const WCHAR *identifier)
Definition: engine.c:627
static HRESULT interp_minus(script_ctx_t *ctx)
Definition: engine.c:2033
static void exprval_release(exprval_t *val)
Definition: engine.c:352
GLsizei const GLfloat * value
Definition: glext.h:6069
jsval_t * stack
Definition: jscript.h:426
static HRESULT interp_refval(script_ctx_t *ctx)
Definition: engine.c:1142
static IDispatch * to_disp(jsdisp_t *jsdisp)
Definition: jscript.h:241
static HRESULT interp_instanceof(script_ctx_t *ctx)
Definition: engine.c:1593
unsigned pop_variables
Definition: engine.h:240
unsigned catch_off
Definition: engine.c:43
struct _call_frame_t * prev_frame
Definition: engine.h:245
static BOOL lookup_global_members(script_ctx_t *ctx, BSTR identifier, exprval_t *ret)
Definition: engine.c:602
#define ERR(fmt,...)
Definition: debug.h:109
enum exprval_t::@411 type
static HRESULT interp_call(script_ctx_t *ctx)
Definition: engine.c:1185
scope_chain_t * base_scope
Definition: engine.h:226
HRESULT throw_reference_error(script_ctx_t *ctx, HRESULT error, const WCHAR *str)
Definition: error.c:423
int isnan(double x)
jsdisp_t * iface_to_jsdisp(IDispatch *iface)
Definition: dispex.c:1081
HRESULT jsdisp_propput_idx(jsdisp_t *obj, DWORD idx, jsval_t val)
Definition: dispex.c:1370
static HRESULT exprval_propget(script_ctx_t *ctx, exprval_t *ref, jsval_t *r)
Definition: engine.c:300
static jsval_t jsval_undefined(void)
Definition: jsval.h:137
static const WCHAR booleanW[]
Definition: engine.c:32
static const char * debugstr_variant(const VARIANT *var)
Definition: container.c:46
static HRESULT interp_cnd_nz(script_ctx_t *ctx)
Definition: engine.c:1492
static HRESULT interp_neq(script_ctx_t *ctx)
Definition: engine.c:2229
#define S_OK
Definition: intsafe.h:59
static VARIANTARG static DISPID
Definition: ordinal.c:49
static BOOL stack_topn_exprval(script_ctx_t *ctx, unsigned n, exprval_t *r)
Definition: engine.c:221
DISPID id
Definition: engine.c:60
scope_chain_t * scope
Definition: engine.c:42
IDispatch * this_obj
Definition: engine.h:230
static ATOM item
Definition: dde.c:856
static HRESULT unwind_exception(script_ctx_t *ctx, HRESULT exception_hres)
Definition: engine.c:2723
const GLdouble * v
Definition: gl.h:2040
static const WCHAR argumentsW[]
Definition: function.c:73
unsigned pop_locals
Definition: engine.h:237
static HRESULT interp_end_finally(script_ctx_t *ctx)
Definition: engine.c:961
static const WCHAR objectW[]
Definition: engine.c:35
static HRESULT interp_throw_type(script_ctx_t *ctx)
Definition: engine.c:891
static HRESULT interp_push_scope(script_ctx_t *ctx)
Definition: engine.c:819
#define DISPATCH_JSCRIPT_CALLEREXECSSOURCE
Definition: jscript.h:112
static BOOL is_bool(jsval_t v)
Definition: jsval.h:205
static HRESULT interp_rshift(script_ctx_t *ctx)
Definition: engine.c:2466
static HRESULT interp_ident(script_ctx_t *ctx)
Definition: engine.c:1315
#define E_NOTIMPL
Definition: ddrawi.h:99
IActiveScriptSite * site
Definition: jscript.h:412
static HRESULT interp_neq2(script_ctx_t *ctx)
Definition: engine.c:2271
static HRESULT interp_lteq(script_ctx_t *ctx)
Definition: engine.c:2349
GLenum GLenum dst
Definition: glext.h:6340
HRESULT create_array(script_ctx_t *ctx, DWORD length, jsdisp_t **ret)
Definition: array.c:1310
HRESULT create_dispex(script_ctx_t *ctx, const builtin_info_t *builtin_info, jsdisp_t *prototype, jsdisp_t **dispex)
Definition: dispex.c:978
struct _function_code_t::@415 * variables
BSTR bstr
Definition: engine.h:109
LOCAL char * rstr(char *s1, char *s2)
Definition: tree.c:165
INT copy(TCHAR source[MAX_PATH], TCHAR dest[MAX_PATH], INT append, DWORD lpdwFlags, BOOL bTouch)
Definition: copy.c:51
void WINAPI DECLSPEC_HOTPATCH SysFreeString(BSTR str)
Definition: oleaut.c:274
static void jsdisp_release(jsdisp_t *jsdisp)
Definition: jscript.h:264
#define OP_LIST
Definition: engine.h:21
unsigned locals_cnt
Definition: engine.h:166
jsdisp_t * global
Definition: jscript.h:436
static HRESULT equal_values(script_ctx_t *ctx, jsval_t lval, jsval_t rval, BOOL *ret)
Definition: engine.c:2128
jsval_type_t
Definition: jsval.h:44
HRESULT create_source_function(script_ctx_t *, bytecode_t *, function_code_t *, scope_chain_t *, jsdisp_t **) DECLSPEC_HIDDEN
Definition: function.c:699
LOCAL int prim(arg_t *ap)
Definition: match.c:440
static jsval_t jsval_obj(jsdisp_t *obj)
Definition: jsval.h:125
static HRESULT exprval_to_value(script_ctx_t *ctx, exprval_t *ref, jsval_t *r)
Definition: engine.c:336
static HRESULT interp_new_obj(script_ctx_t *ctx)
Definition: engine.c:1435
struct define * next
Definition: wpp.c:35
struct exprval_t::@412::@413 idref
#define msg(x)
Definition: auth_time.c:54
void release_bytecode(bytecode_t *code)
Definition: compile.c:2223
static void jmp_next(script_ctx_t *ctx)
Definition: engine.c:746
static HRESULT identifier_eval(script_ctx_t *ctx, BSTR identifier, exprval_t *ret)
Definition: engine.c:633
static const op_func_t op_funcs[]
Definition: engine.c:2642
static jsval_t * stack_args(script_ctx_t *ctx, unsigned n)
Definition: engine.c:119
HRESULT disp_call_value(script_ctx_t *ctx, IDispatch *disp, IDispatch *jsthis, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r)
Definition: dispex.c:1249
Definition: name.c:36
#define JS_E_UNDEFINED_VARIABLE
Definition: jscript.h:558
jsdisp_t * as_jsdisp(IDispatch *disp)
Definition: dispex.c:929
WINE_UNICODE_INLINE int strcmpW(const WCHAR *str1, const WCHAR *str2)
Definition: unicode.h:229
HRESULT to_object(script_ctx_t *, jsval_t, IDispatch **) DECLSPEC_HIDDEN
Definition: jsutils.c:808
HRESULT jsdisp_propput_name(jsdisp_t *obj, const WCHAR *name, jsval_t val)
Definition: dispex.c:1365
static const WCHAR functionW[]
Definition: engine.c:33
#define HRESULT
Definition: msvc.h:21
GLenum GLuint id
Definition: glext.h:5579
static HRESULT interp_undefined(script_ctx_t *ctx)
Definition: engine.c:2548
GLenum target
Definition: glext.h:7315
unsigned variables_off
Definition: engine.h:239
HRESULT create_object(script_ctx_t *, jsdisp_t *, jsdisp_t **) DECLSPEC_HIDDEN
Definition: object.c:597
HRESULT throw_type_error(script_ctx_t *ctx, HRESULT error, const WCHAR *str)
Definition: error.c:438
Definition: jsval.h:50
static BOOL jsstr_eq(jsstr_t *left, jsstr_t *right)
Definition: jsstr.h:176
jsdisp_t * prototype
Definition: jscript.h:236
unsigned uint
Definition: engine.h:112
named_item_t * named_items
Definition: jscript.h:411
static HRESULT interp_assign(script_ctx_t *ctx)
Definition: engine.c:2501
UINT op
Definition: effect.c:223
static HRESULT stack_pop_int(script_ctx_t *ctx, INT *r)
Definition: engine.c:168
static jsval_t jsval_bool(BOOL b)
Definition: jsval.h:101
unsigned finally_off
Definition: engine.c:44
EXCEPINFO ei
Definition: jscript.h:395
static HRESULT stack_pop_uint(script_ctx_t *ctx, DWORD *r)
Definition: engine.c:173
BSTR * params
Definition: engine.h:164
static HRESULT interp_gt(script_ctx_t *ctx)
Definition: engine.c:2370
static HRESULT interp_carray_set(script_ctx_t *ctx)
Definition: engine.c:1416
static HRESULT stack_pop_number(script_ctx_t *ctx, double *r)
Definition: engine.c:139
unsigned argc
Definition: engine.h:236
void scope_release(scope_chain_t *scope)
Definition: engine.c:435
#define memset(x, y, z)
Definition: compat.h:39
HRESULT setup_arguments_object(script_ctx_t *, call_frame_t *) DECLSPEC_HIDDEN
Definition: function.c:162
static jsval_t stack_pop(script_ctx_t *ctx)
Definition: engine.c:127
static HRESULT interp_pop_except(script_ctx_t *ctx)
Definition: engine.c:927
static HRESULT add_eval(script_ctx_t *ctx, jsval_t lval, jsval_t rval, jsval_t *ret)
Definition: engine.c:1690
static BSTR local_name(call_frame_t *frame, int ref)
Definition: engine.c:185
#define PROPF_CONFIGURABLE
Definition: jscript.h:99
#define JS_E_OBJECT_EXPECTED
Definition: jscript.h:556
HRESULT hres
Definition: engine.c:63
static HRESULT interp_this(script_ctx_t *ctx)
Definition: engine.c:1220
jsexcept_t ei
Definition: jscript.h:420
WINE_DEFAULT_DEBUG_CHANNEL(jscript)
HRESULT to_flat_string(script_ctx_t *, jsval_t, jsstr_t **, const WCHAR **) DECLSPEC_HIDDEN
Definition: jsutils.c:790
int ref
Definition: engine.h:142
#define SUCCEEDED(hr)
Definition: intsafe.h:57
static HRESULT interp_identifier_ref(script_ctx_t *ctx, BSTR identifier, unsigned flags)
Definition: engine.c:1230
static HRESULT interp_lt(script_ctx_t *ctx)
Definition: engine.c:2328
HRESULT disp_delete_name(script_ctx_t *ctx, IDispatch *disp, jsstr_t *name, BOOL *ret)
Definition: dispex.c:1567
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint GLenum GLenum GLenum GLint GLuint GLenum GLenum GLfloat GLenum GLfloat GLenum GLint const GLfloat GLenum GLint const GLushort GLint GLint GLsizei GLsizei GLenum GLsizei GLsizei GLenum GLenum const GLvoid GLenum GLdouble GLenum GLint GLenum GLenum GLint GLenum GLenum GLfloat GLenum GLenum GLfloat GLenum GLfloat GLenum GLushort const GLubyte GLenum GLenum GLenum GLint GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLvoid GLenum GLenum GLint GLenum GLint GLenum GLint GLuint GLdouble GLdouble GLdouble GLdouble GLdouble GLdouble const GLfloat GLenum const GLdouble GLdouble GLdouble GLdouble GLdouble GLdouble GLdouble GLdouble GLdouble GLdouble GLdouble GLint GLint GLsizei GLsizei GLenum GLuint GLenum array
Definition: glfuncs.h:320
static jsval_t jsval_number(double n)
Definition: jsval.h:144
const char * debugstr_jsval(const jsval_t) DECLSPEC_HIDDEN
Definition: jsutils.c:33
static HRESULT stack_push(script_ctx_t *ctx, jsval_t v)
Definition: engine.c:67
static bytecode_t * bytecode_addref(bytecode_t *code)
Definition: engine.h:196
Definition: path.c:42
static BOOL heap_free(void *mem)
Definition: appwiz.h:75
unsigned stack_size
Definition: jscript.h:427
static HRESULT interp_int(script_ctx_t *ctx)
Definition: engine.c:1354
HRESULT to_primitive(script_ctx_t *, jsval_t, jsval_t *, hint_t) DECLSPEC_HIDDEN
Definition: jsutils.c:396
off
Definition: i386-dis.c:3909
#define bsearch
GLuint const GLchar * name
Definition: glext.h:6031