ReactOS 0.4.15-dev-7924-g5949c20
Classes | Macros | Typedefs | Enumerations | Functions | Variables
interp.c File Reference
#include <assert.h>
#include "vbscript.h"
#include "wine/debug.h"
Include dependency graph for interp.c:

Go to the source code of this file.

Classes

struct  exec_ctx_t
 
struct  ref_t
 
struct  variant_val_t
 

Macros

#define X(x, n, a, b)   interp_ ## x,
 
#define X(x, n, a, b)   n,
 

Typedefs

typedef HRESULT(* instr_func_t) (exec_ctx_t *)
 

Enumerations

enum  ref_type_t {
  REF_NONE , REF_DISP , REF_VAR , REF_OBJ ,
  REF_CONST , REF_FUNC
}
 

Functions

 WINE_DEFAULT_DEBUG_CHANNEL (vbscript)
 
static BOOL lookup_dynamic_vars (dynamic_var_t *var, const WCHAR *name, ref_t *ref)
 
static HRESULT lookup_identifier (exec_ctx_t *ctx, BSTR name, vbdisp_invoke_type_t invoke_type, ref_t *ref)
 
static HRESULT add_dynamic_var (exec_ctx_t *ctx, const WCHAR *name, BOOL is_const, VARIANT **out_var)
 
void clear_ei (EXCEPINFO *ei)
 
static VARIANT * stack_pop (exec_ctx_t *ctx)
 
static VARIANT * stack_top (exec_ctx_t *ctx, unsigned n)
 
static HRESULT stack_push (exec_ctx_t *ctx, VARIANT *v)
 
static HRESULT stack_push_null (exec_ctx_t *ctx)
 
static void stack_popn (exec_ctx_t *ctx, unsigned n)
 
static void stack_pop_deref (exec_ctx_t *ctx, variant_val_t *r)
 
static void release_val (variant_val_t *v)
 
static HRESULT stack_pop_val (exec_ctx_t *ctx, variant_val_t *r)
 
static HRESULT stack_assume_val (exec_ctx_t *ctx, unsigned n)
 
static int stack_pop_bool (exec_ctx_t *ctx, BOOL *b)
 
static HRESULT stack_pop_disp (exec_ctx_t *ctx, IDispatch **ret)
 
static HRESULT stack_assume_disp (exec_ctx_t *ctx, unsigned n, IDispatch **disp)
 
static void instr_jmp (exec_ctx_t *ctx, unsigned addr)
 
static void vbstack_to_dp (exec_ctx_t *ctx, unsigned arg_cnt, BOOL is_propput, DISPPARAMS *dp)
 
static HRESULT array_access (exec_ctx_t *ctx, SAFEARRAY *array, DISPPARAMS *dp, VARIANT **ret)
 
static HRESULT do_icall (exec_ctx_t *ctx, VARIANT *res)
 
static HRESULT interp_icall (exec_ctx_t *ctx)
 
static HRESULT interp_icallv (exec_ctx_t *ctx)
 
static HRESULT do_mcall (exec_ctx_t *ctx, VARIANT *res)
 
static HRESULT interp_mcall (exec_ctx_t *ctx)
 
static HRESULT interp_mcallv (exec_ctx_t *ctx)
 
static HRESULT assign_value (exec_ctx_t *ctx, VARIANT *dst, VARIANT *src, WORD flags)
 
static HRESULT assign_ident (exec_ctx_t *ctx, BSTR name, WORD flags, DISPPARAMS *dp)
 
static HRESULT interp_assign_ident (exec_ctx_t *ctx)
 
static HRESULT interp_set_ident (exec_ctx_t *ctx)
 
static HRESULT interp_assign_member (exec_ctx_t *ctx)
 
static HRESULT interp_set_member (exec_ctx_t *ctx)
 
static HRESULT interp_const (exec_ctx_t *ctx)
 
static HRESULT interp_val (exec_ctx_t *ctx)
 
static HRESULT interp_pop (exec_ctx_t *ctx)
 
static HRESULT interp_new (exec_ctx_t *ctx)
 
static HRESULT interp_dim (exec_ctx_t *ctx)
 
static HRESULT interp_step (exec_ctx_t *ctx)
 
static HRESULT interp_newenum (exec_ctx_t *ctx)
 
static HRESULT interp_enumnext (exec_ctx_t *ctx)
 
static HRESULT interp_jmp (exec_ctx_t *ctx)
 
static HRESULT interp_jmp_false (exec_ctx_t *ctx)
 
static HRESULT interp_jmp_true (exec_ctx_t *ctx)
 
static HRESULT interp_ret (exec_ctx_t *ctx)
 
static HRESULT interp_retval (exec_ctx_t *ctx)
 
static HRESULT interp_stop (exec_ctx_t *ctx)
 
static HRESULT interp_me (exec_ctx_t *ctx)
 
static HRESULT interp_bool (exec_ctx_t *ctx)
 
static HRESULT interp_errmode (exec_ctx_t *ctx)
 
static HRESULT interp_string (exec_ctx_t *ctx)
 
static HRESULT interp_int (exec_ctx_t *ctx)
 
static HRESULT interp_double (exec_ctx_t *ctx)
 
static HRESULT interp_empty (exec_ctx_t *ctx)
 
static HRESULT interp_null (exec_ctx_t *ctx)
 
static HRESULT interp_nothing (exec_ctx_t *ctx)
 
static HRESULT interp_hres (exec_ctx_t *ctx)
 
static HRESULT interp_not (exec_ctx_t *ctx)
 
static HRESULT interp_and (exec_ctx_t *ctx)
 
static HRESULT interp_or (exec_ctx_t *ctx)
 
static HRESULT interp_xor (exec_ctx_t *ctx)
 
static HRESULT interp_eqv (exec_ctx_t *ctx)
 
static HRESULT interp_imp (exec_ctx_t *ctx)
 
static HRESULT var_cmp (exec_ctx_t *ctx, VARIANT *l, VARIANT *r)
 
static HRESULT cmp_oper (exec_ctx_t *ctx)
 
static HRESULT interp_equal (exec_ctx_t *ctx)
 
static HRESULT interp_nequal (exec_ctx_t *ctx)
 
static HRESULT interp_gt (exec_ctx_t *ctx)
 
static HRESULT interp_gteq (exec_ctx_t *ctx)
 
static HRESULT interp_lt (exec_ctx_t *ctx)
 
static HRESULT interp_lteq (exec_ctx_t *ctx)
 
static HRESULT interp_case (exec_ctx_t *ctx)
 
static HRESULT disp_cmp (IDispatch *disp1, IDispatch *disp2, VARIANT_BOOL *ret)
 
static HRESULT interp_is (exec_ctx_t *ctx)
 
static HRESULT interp_concat (exec_ctx_t *ctx)
 
static HRESULT interp_add (exec_ctx_t *ctx)
 
static HRESULT interp_sub (exec_ctx_t *ctx)
 
static HRESULT interp_mod (exec_ctx_t *ctx)
 
static HRESULT interp_idiv (exec_ctx_t *ctx)
 
static HRESULT interp_div (exec_ctx_t *ctx)
 
static HRESULT interp_mul (exec_ctx_t *ctx)
 
static HRESULT interp_exp (exec_ctx_t *ctx)
 
static HRESULT interp_neg (exec_ctx_t *ctx)
 
static HRESULT interp_incc (exec_ctx_t *ctx)
 
static HRESULT interp_catch (exec_ctx_t *ctx)
 
void release_dynamic_vars (dynamic_var_t *var)
 
static void release_exec (exec_ctx_t *ctx)
 
HRESULT exec_script (script_ctx_t *ctx, BOOL extern_caller, function_t *func, vbdisp_t *vbthis, DISPPARAMS *dp, VARIANT *res)
 

Variables

static DISPID propput_dispid = DISPID_PROPERTYPUT
 
static const instr_func_t op_funcs []
 
static const unsigned op_move []
 

Macro Definition Documentation

◆ X [1/2]

#define X (   x,
  n,
  a,
  b 
)    interp_ ## x,

◆ X [2/2]

#define X (   x,
  n,
  a,
  b 
)    n,

Typedef Documentation

◆ instr_func_t

typedef HRESULT(* instr_func_t) (exec_ctx_t *)

Definition at line 53 of file interp.c.

Enumeration Type Documentation

◆ ref_type_t

enum ref_type_t
Enumerator
REF_NONE 
REF_DISP 
REF_VAR 
REF_OBJ 
REF_CONST 
REF_FUNC 

Definition at line 55 of file interp.c.

55 {
56 REF_NONE,
57 REF_DISP,
58 REF_VAR,
59 REF_OBJ,
60 REF_CONST,
61 REF_FUNC
62} ref_type_t;
ref_type_t
ref_type_t
Definition: interp.c:55
REF_CONST
@ REF_CONST
Definition: interp.c:60
REF_DISP
@ REF_DISP
Definition: interp.c:57
REF_OBJ
@ REF_OBJ
Definition: interp.c:59
REF_NONE
@ REF_NONE
Definition: interp.c:56
REF_VAR
@ REF_VAR
Definition: interp.c:58
REF_FUNC
@ REF_FUNC
Definition: interp.c:61

Function Documentation

◆ add_dynamic_var()

static HRESULT add_dynamic_var ( exec_ctx_t *  ctx,
const WCHAR *  name,
BOOL  is_const,
VARIANT **  out_var 
)
static

Definition at line 207 of file interp.c.

209{
210 dynamic_var_t *new_var;
211 heap_pool_t *heap;
212 WCHAR *str;
213 unsigned size;
214
215 heap = ctx->func->type == FUNC_GLOBAL ? &ctx->script->heap : &ctx->heap;
216
217 new_var = heap_pool_alloc(heap, sizeof(*new_var));
218 if(!new_var)
219 return E_OUTOFMEMORY;
220
221 size = (lstrlenW(name)+1)*sizeof(WCHAR);
222 str = heap_pool_alloc(heap, size);
223 if(!str)
224 return E_OUTOFMEMORY;
225 memcpy(str, name, size);
226 new_var->name = str;
227 new_var->is_const = is_const;
228 V_VT(&new_var->v) = VT_EMPTY;
229
230 if(ctx->func->type == FUNC_GLOBAL) {
231 new_var->next = ctx->script->global_vars;
232 ctx->script->global_vars = new_var;
233 }else {
234 new_var->next = ctx->dynamic_vars;
235 ctx->dynamic_vars = new_var;
236 }
237
238 *out_var = &new_var->v;
239 return S_OK;
240}
E_OUTOFMEMORY
#define E_OUTOFMEMORY
Definition: ddrawi.h:100
VT_EMPTY
@ VT_EMPTY
Definition: compat.h:2295
lstrlenW
#define lstrlenW
Definition: compat.h:750
size
GLsizeiptr size
Definition: glext.h:5919
S_OK
#define S_OK
Definition: intsafe.h:52
heap_pool_alloc
void * heap_pool_alloc(heap_pool_t *, DWORD) __WINE_ALLOC_SIZE(2) DECLSPEC_HIDDEN
Definition: jsutils.c:77
memcpy
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
V_VT
#define V_VT(A)
Definition: oleauto.h:211
str
const WCHAR * str
Definition: rpc_transport.c:2724
heap
static HANDLE heap
Definition: heap.c:65
_dynamic_var_t
Definition: vbscript.h:172
_dynamic_var_t::v
VARIANT v
Definition: vbscript.h:174
_dynamic_var_t::is_const
BOOL is_const
Definition: vbscript.h:176
_dynamic_var_t::name
const WCHAR * name
Definition: vbscript.h:175
_dynamic_var_t::next
struct _dynamic_var_t * next
Definition: vbscript.h:173
heap_pool_t
Definition: jscript.h:60
name
Definition: name.c:39
FUNC_GLOBAL
@ FUNC_GLOBAL
Definition: vbscript.h:308
WCHAR
__wchar_t WCHAR
Definition: xmlstorage.h:180

Referenced by assign_ident(), do_icall(), and interp_const().

◆ array_access()

static HRESULT array_access ( exec_ctx_t *  ctx,
SAFEARRAY *  array,
DISPPARAMS *  dp,
VARIANT **  ret 
)
static

Definition at line 476 of file interp.c.

477{
478 unsigned i, argc = arg_cnt(dp);
479 LONG *indices;
480 HRESULT hres;
481
482 if(!array) {
483 FIXME("NULL array\n");
484 return E_FAIL;
485 }
486
487 hres = SafeArrayLock(array);
488 if(FAILED(hres))
489 return hres;
490
491 if(array->cDims != argc) {
492 FIXME("argc %d does not match cDims %d\n", dp->cArgs, array->cDims);
493 SafeArrayUnlock(array);
494 return E_FAIL;
495 }
496
497 indices = heap_alloc(sizeof(*indices) * argc);
498 if(!indices) {
499 SafeArrayUnlock(array);
500 return E_OUTOFMEMORY;
501 }
502
503 for(i=0; i<argc; i++) {
504 hres = to_int(get_arg(dp, i), indices+i);
505 if(FAILED(hres)) {
506 heap_free(indices);
507 SafeArrayUnlock(array);
508 return hres;
509 }
510 }
511
512 hres = SafeArrayPtrOfIndex(array, indices, (void**)ret);
513 SafeArrayUnlock(array);
514 heap_free(indices);
515 return hres;
516}
argc
static int argc
Definition: ServiceArgs.c:12
heap_alloc
static void * heap_alloc(size_t len)
Definition: appwiz.h:66
heap_free
static BOOL heap_free(void *mem)
Definition: appwiz.h:76
FIXME
#define FIXME(fmt,...)
Definition: debug.h:111
E_FAIL
#define E_FAIL
Definition: ddrawi.h:102
get_arg
static ULONG_PTR get_arg(int nr, DWORD flags, struct format_args *args)
Definition: format_msg.c:149
SafeArrayUnlock
HRESULT WINAPI SafeArrayUnlock(SAFEARRAY *psa)
Definition: safearray.c:831
SafeArrayPtrOfIndex
HRESULT WINAPI SafeArrayPtrOfIndex(SAFEARRAY *psa, LONG *rgIndices, void **ppvData)
Definition: safearray.c:1194
SafeArrayLock
HRESULT WINAPI SafeArrayLock(SAFEARRAY *psa)
Definition: safearray.c:795
indices
GLuint GLuint GLsizei GLenum const GLvoid * indices
Definition: gl.h:1545
i
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
FAILED
#define FAILED(hr)
Definition: intsafe.h:51
hres
HRESULT hres
Definition: protocol.c:465
LONG
long LONG
Definition: pedump.c:60
to_int
HRESULT to_int(VARIANT *v, int *ret)
Definition: global.c:410
arg_cnt
static unsigned arg_cnt(const DISPPARAMS *dp)
Definition: vbscript.h:162
ret
int ret
Definition: wcstombs-tests.c:31

Referenced by assign_ident(), and do_icall().

◆ assign_ident()

static HRESULT assign_ident ( exec_ctx_t *  ctx,
BSTR  name,
WORD  flags,
DISPPARAMS *  dp 
)
static

Definition at line 716 of file interp.c.

717{
718 ref_t ref;
719 HRESULT hres;
720
721 hres = lookup_identifier(ctx, name, VBDISP_LET, &ref);
722 if(FAILED(hres))
723 return hres;
724
725 switch(ref.type) {
726 case REF_VAR: {
727 VARIANT *v = ref.u.v;
728
729 if(V_VT(v) == (VT_VARIANT|VT_BYREF))
730 v = V_VARIANTREF(v);
731
732 if(arg_cnt(dp)) {
733 SAFEARRAY *array;
734
735 if(!(V_VT(v) & VT_ARRAY)) {
736 FIXME("array assign on type %d\n", V_VT(v));
737 return E_FAIL;
738 }
739
740 switch(V_VT(v)) {
741 case VT_ARRAY|VT_BYREF|VT_VARIANT:
742 array = *V_ARRAYREF(v);
743 break;
744 case VT_ARRAY|VT_VARIANT:
745 array = V_ARRAY(v);
746 break;
747 default:
748 FIXME("Unsupported array type %x\n", V_VT(v));
749 return E_NOTIMPL;
750 }
751
752 if(!array) {
753 FIXME("null array\n");
754 return E_FAIL;
755 }
756
757 hres = array_access(ctx, array, dp, &v);
758 if(FAILED(hres))
759 return hres;
760 }else if(V_VT(v) == (VT_ARRAY|VT_BYREF|VT_VARIANT)) {
761 FIXME("non-array assign\n");
762 return E_NOTIMPL;
763 }
764
765 hres = assign_value(ctx, v, dp->rgvarg, flags);
766 break;
767 }
768 case REF_DISP:
769 hres = disp_propput(ctx->script, ref.u.d.disp, ref.u.d.id, flags, dp);
770 break;
771 case REF_FUNC:
772 FIXME("functions not implemented\n");
773 return E_NOTIMPL;
774 case REF_OBJ:
775 FIXME("REF_OBJ\n");
776 return E_NOTIMPL;
777 case REF_CONST:
778 FIXME("REF_CONST\n");
779 return E_NOTIMPL;
780 case REF_NONE:
781 if(ctx->func->code_ctx->option_explicit) {
782 FIXME("throw exception\n");
783 hres = E_FAIL;
784 }else {
785 VARIANT *new_var;
786
787 if(arg_cnt(dp)) {
788 FIXME("arg_cnt %d not supported\n", arg_cnt(dp));
789 return E_NOTIMPL;
790 }
791
792 TRACE("creating variable %s\n", debugstr_w(name));
793 hres = add_dynamic_var(ctx, name, FALSE, &new_var);
794 if(SUCCEEDED(hres))
795 hres = assign_value(ctx, new_var, dp->rgvarg, flags);
796 }
797 }
798
799 return hres;
800}
E_NOTIMPL
#define E_NOTIMPL
Definition: ddrawi.h:99
FALSE
#define FALSE
Definition: types.h:117
VT_BYREF
@ VT_BYREF
Definition: compat.h:2342
VT_ARRAY
@ VT_ARRAY
Definition: compat.h:2341
VT_VARIANT
@ VT_VARIANT
Definition: compat.h:2307
v
const GLdouble * v
Definition: gl.h:2040
flags
GLbitfield flags
Definition: glext.h:7161
assign_value
static HRESULT assign_value(exec_ctx_t *ctx, VARIANT *dst, VARIANT *src, WORD flags)
Definition: interp.c:690
lookup_identifier
static HRESULT lookup_identifier(exec_ctx_t *ctx, BSTR name, vbdisp_invoke_type_t invoke_type, ref_t *ref)
Definition: interp.c:98
array_access
static HRESULT array_access(exec_ctx_t *ctx, SAFEARRAY *array, DISPPARAMS *dp, VARIANT **ret)
Definition: interp.c:476
add_dynamic_var
static HRESULT add_dynamic_var(exec_ctx_t *ctx, const WCHAR *name, BOOL is_const, VARIANT **out_var)
Definition: interp.c:207
SUCCEEDED
#define SUCCEEDED(hr)
Definition: intsafe.h:50
disp_propput
HRESULT disp_propput(script_ctx_t *ctx, IDispatch *disp, DISPID id, jsval_t val)
Definition: dispex.c:1359
debugstr_w
#define debugstr_w
Definition: kernel32.h:32
V_ARRAY
#define V_ARRAY(A)
Definition: oleauto.h:222
V_ARRAYREF
#define V_ARRAYREF(A)
Definition: oleauto.h:223
V_VARIANTREF
#define V_VARIANTREF(A)
Definition: oleauto.h:283
TRACE
#define TRACE(s)
Definition: solgame.cpp:4
ref_t
Definition: interp.c:64
ref
Definition: send.c:48
VBDISP_LET
@ VBDISP_LET
Definition: vbscript.h:73

Referenced by interp_assign_ident(), interp_enumnext(), and interp_set_ident().

◆ assign_value()

static HRESULT assign_value ( exec_ctx_t *  ctx,
VARIANT *  dst,
VARIANT *  src,
WORD  flags 
)
static

Definition at line 690 of file interp.c.

691{
692 VARIANT value;
693 HRESULT hres;
694
695 V_VT(&value) = VT_EMPTY;
696 hres = VariantCopyInd(&value, src);
697 if(FAILED(hres))
698 return hres;
699
700 if(V_VT(&value) == VT_DISPATCH && !(flags & DISPATCH_PROPERTYPUTREF)) {
701 IDispatch *disp = V_DISPATCH(&value);
702
703 V_VT(&value) = VT_EMPTY;
704 hres = get_disp_value(ctx->script, disp, &value);
705 if(disp)
706 IDispatch_Release(disp);
707 if(FAILED(hres))
708 return hres;
709 }
710
711 VariantClear(dst);
712 *dst = value;
713 return S_OK;
714}
VT_DISPATCH
@ VT_DISPATCH
Definition: compat.h:2304
src
GLenum src
Definition: glext.h:6340
dst
GLenum GLenum dst
Definition: glext.h:6340
V_DISPATCH
#define V_DISPATCH(A)
Definition: oleauto.h:239
DISPATCH_PROPERTYPUTREF
#define DISPATCH_PROPERTYPUTREF
Definition: oleauto.h:1009
value
Definition: pdh_main.c:94
VariantClear
HRESULT WINAPI DECLSPEC_HOTPATCH VariantClear(VARIANTARG *pVarg)
Definition: variant.c:648
VariantCopyInd
HRESULT WINAPI VariantCopyInd(VARIANT *pvargDest, VARIANTARG *pvargSrc)
Definition: variant.c:847
get_disp_value
HRESULT get_disp_value(script_ctx_t *ctx, IDispatch *disp, VARIANT *v)
Definition: vbdisp.c:967

Referenced by assign_ident().

◆ clear_ei()

void clear_ei ( EXCEPINFO *  ei)

Definition at line 242 of file interp.c.

243{
244 SysFreeString(ei->bstrSource);
245 SysFreeString(ei->bstrDescription);
246 SysFreeString(ei->bstrHelpFile);
247 memset(ei, 0, sizeof(*ei));
248}
SysFreeString
void WINAPI DECLSPEC_HOTPATCH SysFreeString(BSTR str)
Definition: oleaut.c:271
memset
#define memset(x, y, z)
Definition: compat.h:39

Referenced by exec_script(), and interp_errmode().

◆ cmp_oper()

static HRESULT cmp_oper ( exec_ctx_t *  ctx)
static

Definition at line 1564 of file interp.c.

1565{
1566 variant_val_t l, r;
1567 HRESULT hres;
1568
1569 hres = stack_pop_val(ctx, &r);
1570 if(FAILED(hres))
1571 return hres;
1572
1573 hres = stack_pop_val(ctx, &l);
1574 if(SUCCEEDED(hres)) {
1575 hres = var_cmp(ctx, l.v, r.v);
1576 release_val(&l);
1577 }
1578
1579 release_val(&r);
1580 return hres;
1581}
l
r l[0]
Definition: byte_order.h:168
r
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
stack_pop_val
static HRESULT stack_pop_val(exec_ctx_t *ctx, variant_val_t *r)
Definition: interp.c:314
release_val
static void release_val(variant_val_t *v)
Definition: interp.c:308
var_cmp
static HRESULT var_cmp(exec_ctx_t *ctx, VARIANT *l, VARIANT *r)
Definition: interp.c:1555
variant_val_t
Definition: interp.c:77

Referenced by interp_equal(), interp_gt(), interp_gteq(), interp_lt(), interp_lteq(), and interp_nequal().

◆ disp_cmp()

static HRESULT disp_cmp ( IDispatch *  disp1,
IDispatch *  disp2,
VARIANT_BOOL *  ret 
)
static

Definition at line 1718 of file interp.c.

1719{
1720 IObjectIdentity *identity;
1721 IUnknown *unk1, *unk2;
1722 HRESULT hres;
1723
1724 if(disp1 == disp2) {
1725 *ret = VARIANT_TRUE;
1726 return S_OK;
1727 }
1728
1729 if(!disp1 || !disp2) {
1730 *ret = VARIANT_FALSE;
1731 return S_OK;
1732 }
1733
1734 hres = IDispatch_QueryInterface(disp1, &IID_IUnknown, (void**)&unk1);
1735 if(FAILED(hres))
1736 return hres;
1737
1738 hres = IDispatch_QueryInterface(disp2, &IID_IUnknown, (void**)&unk2);
1739 if(FAILED(hres)) {
1740 IUnknown_Release(unk1);
1741 return hres;
1742 }
1743
1744 if(unk1 == unk2) {
1745 *ret = VARIANT_TRUE;
1746 }else {
1747 hres = IUnknown_QueryInterface(unk1, &IID_IObjectIdentity, (void**)&identity);
1748 if(SUCCEEDED(hres)) {
1749 hres = IObjectIdentity_IsEqualObject(identity, unk2);
1750 IObjectIdentity_Release(identity);
1751 *ret = hres == S_OK ? VARIANT_TRUE : VARIANT_FALSE;
1752 }else {
1753 *ret = VARIANT_FALSE;
1754 }
1755 }
1756
1757 IUnknown_Release(unk1);
1758 IUnknown_Release(unk2);
1759 return S_OK;
1760}
IID_IUnknown
const GUID IID_IUnknown
Definition: classfactory.cpp:11
unk1
static DWORD unk1
Definition: cursoricon.c:1638

Referenced by interp_is().

◆ do_icall()

static HRESULT do_icall ( exec_ctx_t *  ctx,
VARIANT *  res 
)
static

Definition at line 518 of file interp.c.

519{
520 BSTR identifier = ctx->instr->arg1.bstr;
521 const unsigned arg_cnt = ctx->instr->arg2.uint;
522 DISPPARAMS dp;
523 ref_t ref;
524 HRESULT hres;
525
526 hres = lookup_identifier(ctx, identifier, VBDISP_CALLGET, &ref);
527 if(FAILED(hres))
528 return hres;
529
530 switch(ref.type) {
531 case REF_VAR:
532 case REF_CONST: {
533 VARIANT *v;
534
535 if(!res) {
536 FIXME("REF_VAR no res\n");
537 return E_NOTIMPL;
538 }
539
540 v = V_VT(ref.u.v) == (VT_VARIANT|VT_BYREF) ? V_VARIANTREF(ref.u.v) : ref.u.v;
541
542 if(arg_cnt) {
543 SAFEARRAY *array = NULL;
544
545 switch(V_VT(v)) {
546 case VT_ARRAY|VT_BYREF|VT_VARIANT:
547 array = *V_ARRAYREF(ref.u.v);
548 break;
549 case VT_ARRAY|VT_VARIANT:
550 array = V_ARRAY(ref.u.v);
551 break;
552 case VT_DISPATCH:
553 vbstack_to_dp(ctx, arg_cnt, FALSE, &dp);
554 hres = disp_call(ctx->script, V_DISPATCH(v), DISPID_VALUE, &dp, res);
555 if(FAILED(hres))
556 return hres;
557 break;
558 default:
559 FIXME("arguments not implemented\n");
560 return E_NOTIMPL;
561 }
562
563 if(!array)
564 break;
565
566 vbstack_to_dp(ctx, arg_cnt, FALSE, &dp);
567 hres = array_access(ctx, array, &dp, &v);
568 if(FAILED(hres))
569 return hres;
570 }
571
572 V_VT(res) = VT_BYREF|VT_VARIANT;
573 V_BYREF(res) = v;
574 break;
575 }
576 case REF_DISP:
577 vbstack_to_dp(ctx, arg_cnt, FALSE, &dp);
578 hres = disp_call(ctx->script, ref.u.d.disp, ref.u.d.id, &dp, res);
579 if(FAILED(hres))
580 return hres;
581 break;
582 case REF_FUNC:
583 vbstack_to_dp(ctx, arg_cnt, FALSE, &dp);
584 hres = exec_script(ctx->script, FALSE, ref.u.f, NULL, &dp, res);
585 if(FAILED(hres))
586 return hres;
587 break;
588 case REF_OBJ:
589 if(arg_cnt) {
590 FIXME("arguments on object\n");
591 return E_NOTIMPL;
592 }
593
594 if(res) {
595 IDispatch_AddRef(ref.u.obj);
596 V_VT(res) = VT_DISPATCH;
597 V_DISPATCH(res) = ref.u.obj;
598 }
599 break;
600 case REF_NONE:
601 if(res && !ctx->func->code_ctx->option_explicit && arg_cnt == 0) {
602 VARIANT *new;
603 hres = add_dynamic_var(ctx, identifier, FALSE, &new);
604 if(FAILED(hres))
605 return hres;
606 V_VT(res) = VT_BYREF|VT_VARIANT;
607 V_BYREF(res) = new;
608 break;
609 }
610 FIXME("%s not found\n", debugstr_w(identifier));
611 return DISP_E_UNKNOWNNAME;
612 }
613
614 stack_popn(ctx, arg_cnt);
615 return S_OK;
616}
NULL
#define NULL
Definition: types.h:112
BSTR
OLECHAR * BSTR
Definition: compat.h:2293
res
GLuint res
Definition: glext.h:9613
stack_popn
static void stack_popn(exec_ctx_t *ctx, unsigned n)
Definition: interp.c:288
exec_script
HRESULT exec_script(script_ctx_t *ctx, BOOL extern_caller, function_t *func, vbdisp_t *vbthis, DISPPARAMS *dp, VARIANT *res)
Definition: interp.c:2086
vbstack_to_dp
static void vbstack_to_dp(exec_ctx_t *ctx, unsigned arg_cnt, BOOL is_propput, DISPPARAMS *dp)
Definition: interp.c:452
disp_call
HRESULT disp_call(script_ctx_t *ctx, IDispatch *disp, DISPID id, WORD flags, unsigned argc, jsval_t *argv, jsval_t *ret)
Definition: dispex.c:1136
stdole::DISPPARAMS
struct stdole::DISPPARAMS DISPPARAMS
V_BYREF
#define V_BYREF(A)
Definition: oleauto.h:228
VBDISP_CALLGET
@ VBDISP_CALLGET
Definition: vbscript.h:72
DISP_E_UNKNOWNNAME
#define DISP_E_UNKNOWNNAME
Definition: winerror.h:2515

Referenced by interp_icall(), and interp_icallv().

◆ do_mcall()

static HRESULT do_mcall ( exec_ctx_t *  ctx,
VARIANT *  res 
)
static

Definition at line 638 of file interp.c.

639{
640 const BSTR identifier = ctx->instr->arg1.bstr;
641 const unsigned arg_cnt = ctx->instr->arg2.uint;
642 IDispatch *obj;
643 DISPPARAMS dp;
644 DISPID id;
645 HRESULT hres;
646
647 hres = stack_pop_disp(ctx, &obj);
648 if(FAILED(hres))
649 return hres;
650
651 if(!obj) {
652 FIXME("NULL obj\n");
653 return E_FAIL;
654 }
655
656 vbstack_to_dp(ctx, arg_cnt, FALSE, &dp);
657
658 hres = disp_get_id(obj, identifier, VBDISP_CALLGET, FALSE, &id);
659 if(SUCCEEDED(hres))
660 hres = disp_call(ctx->script, obj, id, &dp, res);
661 IDispatch_Release(obj);
662 if(FAILED(hres))
663 return hres;
664
665 stack_popn(ctx, arg_cnt);
666 return S_OK;
667}
disp_get_id
static HRESULT disp_get_id(script_ctx_t *ctx, IDispatch *disp, const WCHAR *name, BSTR name_bstr, DWORD flags, DISPID *id)
Definition: engine.c:449
id
GLuint id
Definition: glext.h:5910
stack_pop_disp
static HRESULT stack_pop_disp(exec_ctx_t *ctx, IDispatch **ret)
Definition: interp.c:393
DISPID
static VARIANTARG static DISPID
Definition: ordinal.c:52

Referenced by interp_mcall(), and interp_mcallv().

◆ exec_script()

HRESULT exec_script ( script_ctx_t *  ctx,
BOOL  extern_caller,
function_t *  func,
vbdisp_t *  vbthis,
DISPPARAMS *  dp,
VARIANT *  res 
)

Definition at line 2086 of file interp.c.

2087{
2088 exec_ctx_t exec = {func->code_ctx};
2089 vbsop_t op;
2090 HRESULT hres = S_OK;
2091
2092 exec.code = func->code_ctx;
2093
2094 if(dp ? func->arg_cnt != arg_cnt(dp) : func->arg_cnt) {
2095 FIXME("wrong arg_cnt %d, expected %d\n", dp ? arg_cnt(dp) : 0, func->arg_cnt);
2096 return E_FAIL;
2097 }
2098
2099 heap_pool_init(&exec.heap);
2100
2101 if(func->arg_cnt) {
2102 VARIANT *v;
2103 unsigned i;
2104
2105 exec.args = heap_alloc_zero(func->arg_cnt * sizeof(VARIANT));
2106 if(!exec.args) {
2107 release_exec(&exec);
2108 return E_OUTOFMEMORY;
2109 }
2110
2111 for(i=0; i < func->arg_cnt; i++) {
2112 v = get_arg(dp, i);
2113 if(V_VT(v) == (VT_VARIANT|VT_BYREF)) {
2114 if(func->args[i].by_ref)
2115 exec.args[i] = *v;
2116 else
2117 hres = VariantCopyInd(exec.args+i, V_VARIANTREF(v));
2118 }else {
2119 hres = VariantCopyInd(exec.args+i, v);
2120 }
2121 if(FAILED(hres)) {
2122 release_exec(&exec);
2123 return hres;
2124 }
2125 }
2126 }else {
2127 exec.args = NULL;
2128 }
2129
2130 if(func->var_cnt) {
2131 exec.vars = heap_alloc_zero(func->var_cnt * sizeof(VARIANT));
2132 if(!exec.vars) {
2133 release_exec(&exec);
2134 return E_OUTOFMEMORY;
2135 }
2136 }else {
2137 exec.vars = NULL;
2138 }
2139
2140 exec.stack_size = 16;
2141 exec.top = 0;
2142 exec.stack = heap_alloc(exec.stack_size * sizeof(VARIANT));
2143 if(!exec.stack) {
2144 release_exec(&exec);
2145 return E_OUTOFMEMORY;
2146 }
2147
2148 if(extern_caller)
2149 IActiveScriptSite_OnEnterScript(ctx->site);
2150
2151 if(vbthis) {
2152 exec.this_obj = (IDispatch*)&vbthis->IDispatchEx_iface;
2153 exec.vbthis = vbthis;
2154 }else if (ctx->host_global) {
2155 exec.this_obj = ctx->host_global;
2156 }else {
2157 exec.this_obj = (IDispatch*)&ctx->script_obj->IDispatchEx_iface;
2158 }
2159 IDispatch_AddRef(exec.this_obj);
2160
2161 exec.instr = exec.code->instrs + func->code_off;
2162 exec.script = ctx;
2163 exec.func = func;
2164
2165 while(exec.instr) {
2166 op = exec.instr->op;
2167 hres = op_funcs[op](&exec);
2168 if(FAILED(hres)) {
2169 if(hres != SCRIPT_E_RECORDED) {
2170 clear_ei(&ctx->ei);
2171
2172 ctx->ei.scode = hres = map_hres(hres);
2173 ctx->ei.bstrSource = get_vbscript_string(VBS_RUNTIME_ERROR);
2174 ctx->ei.bstrDescription = get_vbscript_error_string(hres);
2175 }else {
2176 hres = ctx->ei.scode;
2177 }
2178
2179 if(exec.resume_next) {
2180 unsigned stack_off;
2181
2182 WARN("Failed %08x in resume next mode\n", hres);
2183
2184 /*
2185 * Unwinding here is simple. We need to find the next OP_catch, which contains
2186 * information about expected stack size and jump offset on error. Generated
2187 * bytecode needs to guarantee, that simple jump and stack adjustment will
2188 * guarantee proper execution continuation.
2189 */
2190 while((++exec.instr)->op != OP_catch);
2191
2192 TRACE("unwind jmp %d stack_off %d\n", exec.instr->arg1.uint, exec.instr->arg2.uint);
2193
2194 stack_off = exec.instr->arg2.uint;
2195 instr_jmp(&exec, exec.instr->arg1.uint);
2196
2197 if(exec.top > stack_off) {
2198 stack_popn(&exec, exec.top-stack_off);
2199 }else if(exec.top < stack_off) {
2200 VARIANT v;
2201
2202 V_VT(&v) = VT_EMPTY;
2203 while(exec.top < stack_off) {
2204 hres = stack_push(&exec, &v);
2205 if(FAILED(hres))
2206 break;
2207 }
2208 }
2209
2210 continue;
2211 }else {
2212 WARN("Failed %08x\n", hres);
2213 stack_popn(&exec, exec.top);
2214 break;
2215 }
2216 }
2217
2218 exec.instr += op_move[op];
2219 }
2220
2221 assert(!exec.top);
2222
2223 if(extern_caller) {
2224 IActiveScriptSite_OnLeaveScript(ctx->site);
2225 if(FAILED(hres)) {
2226 if(!ctx->ei.scode)
2227 ctx->ei.scode = hres;
2228 hres = report_script_error(ctx);
2229 }
2230 }
2231
2232 if(SUCCEEDED(hres) && res) {
2233 *res = exec.ret_val;
2234 V_VT(&exec.ret_val) = VT_EMPTY;
2235 }
2236
2237 release_exec(&exec);
2238 return hres;
2239}
WARN
#define WARN(fmt,...)
Definition: debug.h:112
op
UINT op
Definition: effect.c:236
report_script_error
HRESULT report_script_error(script_ctx_t *ctx)
Definition: vbscript.c:315
VBS_RUNTIME_ERROR
#define VBS_RUNTIME_ERROR
Definition: vbscript_defs.h:272
assert
#define assert(x)
Definition: debug.h:53
func
GLenum func
Definition: glext.h:6028
clear_ei
void clear_ei(EXCEPINFO *ei)
Definition: interp.c:242
instr_jmp
static void instr_jmp(exec_ctx_t *ctx, unsigned addr)
Definition: interp.c:447
op_move
static const unsigned op_move[]
Definition: interp.c:2038
stack_push
static HRESULT stack_push(exec_ctx_t *ctx, VARIANT *v)
Definition: interp.c:262
op_funcs
static const instr_func_t op_funcs[]
Definition: interp.c:2032
release_exec
static void release_exec(exec_ctx_t *ctx)
Definition: interp.c:2052
heap_pool_init
void heap_pool_init(heap_pool_t *) DECLSPEC_HIDDEN
Definition: jsutils.c:71
map_hres
HRESULT map_hres
Definition: sec_mgr.c:1753
_vbdisp_t::IDispatchEx_iface
IDispatchEx IDispatchEx_iface
Definition: vbscript.h:117
_vbscode_t::instrs
instr_t * instrs
Definition: vbscript.h:337
exec_ctx_t
Definition: interp.c:29
exec_ctx_t::heap
heap_pool_t heap
Definition: interp.c:42
exec_ctx_t::args
VARIANT * args
Definition: interp.c:37
exec_ctx_t::func
function_t * func
Definition: interp.c:33
exec_ctx_t::script
script_ctx_t * script
Definition: interp.c:32
exec_ctx_t::ret_val
VARIANT ret_val
Definition: interp.c:50
exec_ctx_t::vbthis
vbdisp_t * vbthis
Definition: interp.c:35
exec_ctx_t::code
vbscode_t * code
Definition: interp.c:30
exec_ctx_t::stack
VARIANT * stack
Definition: interp.c:48
exec_ctx_t::top
unsigned top
Definition: interp.c:47
exec_ctx_t::vars
VARIANT * vars
Definition: interp.c:38
exec_ctx_t::stack_size
unsigned stack_size
Definition: interp.c:46
exec_ctx_t::instr
instr_t * instr
Definition: interp.c:31
exec_ctx_t::this_obj
IDispatch * this_obj
Definition: interp.c:34
exec_ctx_t::resume_next
BOOL resume_next
Definition: interp.c:44
instr_t::arg2
instr_arg_t arg2
Definition: vbscript.h:299
instr_t::arg1
instr_arg_t arg1
Definition: vbscript.h:298
instr_t::op
jsop_t op
Definition: engine.h:127
instr_arg_t::uint
unsigned uint
Definition: engine.h:112
get_vbscript_error_string
BSTR get_vbscript_error_string(HRESULT) DECLSPEC_HIDDEN
Definition: vbscript_main.c:45
vbsop_t
vbsop_t
Definition: vbscript.h:281
get_vbscript_string
BSTR get_vbscript_string(int) DECLSPEC_HIDDEN
Definition: vbscript_main.c:38

Referenced by do_icall().

◆ instr_jmp()

static void instr_jmp ( exec_ctx_t *  ctx,
unsigned  addr 
)
inlinestatic

Definition at line 447 of file interp.c.

448{
449 ctx->instr = ctx->code->instrs + addr;
450}
addr
GLenum const GLvoid * addr
Definition: glext.h:9621

Referenced by exec_script(), interp_case(), interp_enumnext(), interp_jmp(), interp_jmp_false(), interp_jmp_true(), and interp_step().

◆ interp_add()

static HRESULT interp_add ( exec_ctx_t *  ctx)
static

Definition at line 1813 of file interp.c.

1814{
1815 variant_val_t r, l;
1816 VARIANT v;
1817 HRESULT hres;
1818
1819 TRACE("\n");
1820
1821 hres = stack_pop_val(ctx, &r);
1822 if(FAILED(hres))
1823 return hres;
1824
1825 hres = stack_pop_val(ctx, &l);
1826 if(SUCCEEDED(hres)) {
1827 hres = VarAdd(l.v, r.v, &v);
1828 release_val(&l);
1829 }
1830 release_val(&r);
1831 if(FAILED(hres))
1832 return hres;
1833
1834 return stack_push(ctx, &v);
1835}
VarAdd
HRESULT WINAPI VarAdd(LPVARIANT left, LPVARIANT right, LPVARIANT result)
Definition: variant.c:3130

◆ interp_and()

static HRESULT interp_and ( exec_ctx_t *  ctx)
static

Definition at line 1435 of file interp.c.

1436{
1437 variant_val_t r, l;
1438 VARIANT v;
1439 HRESULT hres;
1440
1441 TRACE("\n");
1442
1443 hres = stack_pop_val(ctx, &r);
1444 if(FAILED(hres))
1445 return hres;
1446
1447 hres = stack_pop_val(ctx, &l);
1448 if(SUCCEEDED(hres)) {
1449 hres = VarAnd(l.v, r.v, &v);
1450 release_val(&l);
1451 }
1452 release_val(&r);
1453 if(FAILED(hres))
1454 return hres;
1455
1456 return stack_push(ctx, &v);
1457}
VarAnd
HRESULT WINAPI VarAnd(LPVARIANT left, LPVARIANT right, LPVARIANT result)
Definition: variant.c:2893

◆ interp_assign_ident()

static HRESULT interp_assign_ident ( exec_ctx_t *  ctx)
static

Definition at line 802 of file interp.c.

803{
804 const BSTR arg = ctx->instr->arg1.bstr;
805 const unsigned arg_cnt = ctx->instr->arg2.uint;
806 DISPPARAMS dp;
807 HRESULT hres;
808
809 TRACE("%s\n", debugstr_w(arg));
810
811 vbstack_to_dp(ctx, arg_cnt, TRUE, &dp);
812 hres = assign_ident(ctx, arg, DISPATCH_PROPERTYPUT, &dp);
813 if(FAILED(hres))
814 return hres;
815
816 stack_popn(ctx, arg_cnt+1);
817 return S_OK;
818}
TRUE
#define TRUE
Definition: types.h:120
assign_ident
static HRESULT assign_ident(exec_ctx_t *ctx, BSTR name, WORD flags, DISPPARAMS *dp)
Definition: interp.c:716
DISPATCH_PROPERTYPUT
#define DISPATCH_PROPERTYPUT
Definition: oleauto.h:1008

◆ interp_assign_member()

static HRESULT interp_assign_member ( exec_ctx_t *  ctx)
static

Definition at line 847 of file interp.c.

848{
849 BSTR identifier = ctx->instr->arg1.bstr;
850 const unsigned arg_cnt = ctx->instr->arg2.uint;
851 IDispatch *obj;
852 DISPPARAMS dp;
853 DISPID id;
854 HRESULT hres;
855
856 TRACE("%s\n", debugstr_w(identifier));
857
858 hres = stack_assume_disp(ctx, arg_cnt+1, &obj);
859 if(FAILED(hres))
860 return hres;
861
862 if(!obj) {
863 FIXME("NULL obj\n");
864 return E_FAIL;
865 }
866
867 hres = disp_get_id(obj, identifier, VBDISP_LET, FALSE, &id);
868 if(SUCCEEDED(hres)) {
869 vbstack_to_dp(ctx, arg_cnt, TRUE, &dp);
870 hres = disp_propput(ctx->script, obj, id, DISPATCH_PROPERTYPUT, &dp);
871 }
872 if(FAILED(hres))
873 return hres;
874
875 stack_popn(ctx, arg_cnt+2);
876 return S_OK;
877}
stack_assume_disp
static HRESULT stack_assume_disp(exec_ctx_t *ctx, unsigned n, IDispatch **disp)
Definition: interp.c:420

◆ interp_bool()

static HRESULT interp_bool ( exec_ctx_t *  ctx)
static

Definition at line 1310 of file interp.c.

1311{
1312 const VARIANT_BOOL arg = ctx->instr->arg1.lng;
1313 VARIANT v;
1314
1315 TRACE("%s\n", arg ? "true" : "false");
1316
1317 V_VT(&v) = VT_BOOL;
1318 V_BOOL(&v) = arg;
1319 return stack_push(ctx, &v);
1320}
VARIANT_BOOL
short VARIANT_BOOL
Definition: compat.h:2290
VT_BOOL
@ VT_BOOL
Definition: compat.h:2306
V_BOOL
#define V_BOOL(A)
Definition: oleauto.h:224
arg
void * arg
Definition: msvc.h:10

◆ interp_case()

static HRESULT interp_case ( exec_ctx_t *  ctx)
static

Definition at line 1691 of file interp.c.

1692{
1693 const unsigned arg = ctx->instr->arg1.uint;
1694 variant_val_t v;
1695 HRESULT hres;
1696
1697 TRACE("%d\n", arg);
1698
1699 hres = stack_pop_val(ctx, &v);
1700 if(FAILED(hres))
1701 return hres;
1702
1703 hres = var_cmp(ctx, stack_top(ctx, 0), v.v);
1704 release_val(&v);
1705 if(FAILED(hres))
1706 return hres;
1707
1708 if(hres == VARCMP_EQ) {
1709 stack_popn(ctx, 1);
1710 instr_jmp(ctx, arg);
1711 }else {
1712 ctx->instr++;
1713 }
1714
1715 return S_OK;
1716}
stack_top
static VARIANT * stack_top(exec_ctx_t *ctx, unsigned n)
Definition: interp.c:256
VARCMP_EQ
#define VARCMP_EQ
Definition: oleauto.h:658

◆ interp_catch()

static HRESULT interp_catch ( exec_ctx_t *  ctx)
static

Definition at line 2026 of file interp.c.

2027{
2028 /* Nothing to do here, the OP is for unwinding only. */
2029 return S_OK;
2030}

◆ interp_concat()

static HRESULT interp_concat ( exec_ctx_t *  ctx)
static

Definition at line 1789 of file interp.c.

1790{
1791 variant_val_t r, l;
1792 VARIANT v;
1793 HRESULT hres;
1794
1795 TRACE("\n");
1796
1797 hres = stack_pop_val(ctx, &r);
1798 if(FAILED(hres))
1799 return hres;
1800
1801 hres = stack_pop_val(ctx, &l);
1802 if(SUCCEEDED(hres)) {
1803 hres = VarCat(l.v, r.v, &v);
1804 release_val(&l);
1805 }
1806 release_val(&r);
1807 if(FAILED(hres))
1808 return hres;
1809
1810 return stack_push(ctx, &v);
1811}
VarCat
HRESULT WINAPI VarCat(LPVARIANT left, LPVARIANT right, LPVARIANT out)
Definition: variant.c:2515

◆ interp_const()

static HRESULT interp_const ( exec_ctx_t *  ctx)
static

Definition at line 920 of file interp.c.

921{
922 BSTR arg = ctx->instr->arg1.bstr;
923 VARIANT *v;
924 ref_t ref;
925 HRESULT hres;
926
927 TRACE("%s\n", debugstr_w(arg));
928
929 assert(ctx->func->type == FUNC_GLOBAL);
930
931 hres = lookup_identifier(ctx, arg, VBDISP_CALLGET, &ref);
932 if(FAILED(hres))
933 return hres;
934
935 if(ref.type != REF_NONE) {
936 FIXME("%s already defined\n", debugstr_w(arg));
937 return E_FAIL;
938 }
939
940 hres = stack_assume_val(ctx, 0);
941 if(FAILED(hres))
942 return hres;
943
944 hres = add_dynamic_var(ctx, arg, TRUE, &v);
945 if(FAILED(hres))
946 return hres;
947
948 *v = *stack_pop(ctx);
949 return S_OK;
950}
stack_assume_val
static HRESULT stack_assume_val(exec_ctx_t *ctx, unsigned n)
Definition: interp.c:334
stack_pop
static VARIANT * stack_pop(exec_ctx_t *ctx)
Definition: interp.c:250

◆ interp_dim()

static HRESULT interp_dim ( exec_ctx_t *  ctx)
static

Definition at line 1023 of file interp.c.

1024{
1025 const BSTR ident = ctx->instr->arg1.bstr;
1026 const unsigned array_id = ctx->instr->arg2.uint;
1027 const array_desc_t *array_desc;
1028 ref_t ref;
1029 HRESULT hres;
1030
1031 TRACE("%s\n", debugstr_w(ident));
1032
1033 assert(array_id < ctx->func->array_cnt);
1034 if(!ctx->arrays) {
1035 ctx->arrays = heap_alloc_zero(ctx->func->array_cnt * sizeof(SAFEARRAY*));
1036 if(!ctx->arrays)
1037 return E_OUTOFMEMORY;
1038 }
1039
1040 hres = lookup_identifier(ctx, ident, VBDISP_LET, &ref);
1041 if(FAILED(hres)) {
1042 FIXME("lookup %s failed: %08x\n", debugstr_w(ident), hres);
1043 return hres;
1044 }
1045
1046 if(ref.type != REF_VAR) {
1047 FIXME("got ref.type = %d\n", ref.type);
1048 return E_FAIL;
1049 }
1050
1051 if(ctx->arrays[array_id]) {
1052 FIXME("Array already initialized\n");
1053 return E_FAIL;
1054 }
1055
1056 array_desc = ctx->func->array_descs + array_id;
1057 if(array_desc->dim_cnt) {
1058 ctx->arrays[array_id] = SafeArrayCreate(VT_VARIANT, array_desc->dim_cnt, array_desc->bounds);
1059 if(!ctx->arrays[array_id])
1060 return E_OUTOFMEMORY;
1061 }
1062
1063 V_VT(ref.u.v) = VT_ARRAY|VT_BYREF|VT_VARIANT;
1064 V_ARRAYREF(ref.u.v) = ctx->arrays+array_id;
1065 return S_OK;
1066}
SafeArrayCreate
SAFEARRAY *WINAPI SafeArrayCreate(VARTYPE vt, UINT cDims, SAFEARRAYBOUND *rgsabound)
Definition: safearray.c:600
array_desc_t
Definition: vbscript.h:78
array_desc_t::dim_cnt
unsigned dim_cnt
Definition: vbscript.h:79
array_desc_t::bounds
SAFEARRAYBOUND * bounds
Definition: vbscript.h:80
ident
_In_ ULONG _In_ ULONG_PTR ident
Definition: winddi.h:3994

◆ interp_div()

static HRESULT interp_div ( exec_ctx_t *  ctx)
static

Definition at line 1909 of file interp.c.

1910{
1911 variant_val_t r, l;
1912 VARIANT v;
1913 HRESULT hres;
1914
1915 TRACE("\n");
1916
1917 hres = stack_pop_val(ctx, &r);
1918 if(FAILED(hres))
1919 return hres;
1920
1921 hres = stack_pop_val(ctx, &l);
1922 if(SUCCEEDED(hres)) {
1923 hres = VarDiv(l.v, r.v, &v);
1924 release_val(&l);
1925 }
1926 release_val(&r);
1927 if(FAILED(hres))
1928 return hres;
1929
1930 return stack_push(ctx, &v);
1931}
VarDiv
HRESULT WINAPI VarDiv(LPVARIANT left, LPVARIANT right, LPVARIANT result)
Definition: variant.c:3521

◆ interp_double()

static HRESULT interp_double ( exec_ctx_t *  ctx)
static

Definition at line 1364 of file interp.c.

1365{
1366 const DOUBLE *arg = ctx->instr->arg1.dbl;
1367 VARIANT v;
1368
1369 TRACE("%lf\n", *arg);
1370
1371 V_VT(&v) = VT_R8;
1372 V_R8(&v) = *arg;
1373 return stack_push(ctx, &v);
1374}
VT_R8
@ VT_R8
Definition: compat.h:2300
V_R8
#define V_R8(A)
Definition: oleauto.h:262
DOUBLE
double DOUBLE
Definition: typedefs.h:70

◆ interp_empty()

static HRESULT interp_empty ( exec_ctx_t *  ctx)
static

Definition at line 1376 of file interp.c.

1377{
1378 VARIANT v;
1379
1380 TRACE("\n");
1381
1382 V_VT(&v) = VT_EMPTY;
1383 return stack_push(ctx, &v);
1384}

◆ interp_enumnext()

static HRESULT interp_enumnext ( exec_ctx_t *  ctx)
static

Definition at line 1170 of file interp.c.

1171{
1172 const unsigned loop_end = ctx->instr->arg1.uint;
1173 const BSTR ident = ctx->instr->arg2.bstr;
1174 VARIANT v;
1175 DISPPARAMS dp = {&v, &propput_dispid, 1, 1};
1176 IEnumVARIANT *iter;
1177 BOOL do_continue;
1178 HRESULT hres;
1179
1180 TRACE("\n");
1181
1182 if(V_VT(stack_top(ctx, 0)) == VT_EMPTY) {
1183 FIXME("uninitialized\n");
1184 return E_FAIL;
1185 }
1186
1187 assert(V_VT(stack_top(ctx, 0)) == VT_UNKNOWN);
1188 iter = (IEnumVARIANT*)V_UNKNOWN(stack_top(ctx, 0));
1189
1190 V_VT(&v) = VT_EMPTY;
1191 hres = IEnumVARIANT_Next(iter, 1, &v, NULL);
1192 if(FAILED(hres))
1193 return hres;
1194
1195 do_continue = hres == S_OK;
1196 hres = assign_ident(ctx, ident, DISPATCH_PROPERTYPUT|DISPATCH_PROPERTYPUTREF, &dp);
1197 VariantClear(&v);
1198 if(FAILED(hres))
1199 return hres;
1200
1201 if(do_continue) {
1202 ctx->instr++;
1203 }else {
1204 stack_popn(ctx, 1);
1205 instr_jmp(ctx, loop_end);
1206 }
1207 return S_OK;
1208}
VT_UNKNOWN
@ VT_UNKNOWN
Definition: compat.h:2308
BOOL
unsigned int BOOL
Definition: ntddk_ex.h:94
propput_dispid
static DISPID propput_dispid
Definition: interp.c:27
V_UNKNOWN
#define V_UNKNOWN(A)
Definition: oleauto.h:281

◆ interp_equal()

static HRESULT interp_equal ( exec_ctx_t *  ctx)
static

Definition at line 1583 of file interp.c.

1584{
1585 VARIANT v;
1586 HRESULT hres;
1587
1588 TRACE("\n");
1589
1590 hres = cmp_oper(ctx);
1591 if(FAILED(hres))
1592 return hres;
1593 if(hres == VARCMP_NULL)
1594 return stack_push_null(ctx);
1595
1596 V_VT(&v) = VT_BOOL;
1597 V_BOOL(&v) = hres == VARCMP_EQ ? VARIANT_TRUE : VARIANT_FALSE;
1598 return stack_push(ctx, &v);
1599}
stack_push_null
static HRESULT stack_push_null(exec_ctx_t *ctx)
Definition: interp.c:281
cmp_oper
static HRESULT cmp_oper(exec_ctx_t *ctx)
Definition: interp.c:1564
VARCMP_NULL
#define VARCMP_NULL
Definition: oleauto.h:660

◆ interp_eqv()

static HRESULT interp_eqv ( exec_ctx_t *  ctx)
static

Definition at line 1507 of file interp.c.

1508{
1509 variant_val_t r, l;
1510 VARIANT v;
1511 HRESULT hres;
1512
1513 TRACE("\n");
1514
1515 hres = stack_pop_val(ctx, &r);
1516 if(FAILED(hres))
1517 return hres;
1518
1519 hres = stack_pop_val(ctx, &l);
1520 if(SUCCEEDED(hres)) {
1521 hres = VarEqv(l.v, r.v, &v);
1522 release_val(&l);
1523 }
1524 release_val(&r);
1525 if(FAILED(hres))
1526 return hres;
1527
1528 return stack_push(ctx, &v);
1529}
VarEqv
HRESULT WINAPI VarEqv(LPVARIANT pVarLeft, LPVARIANT pVarRight, LPVARIANT pVarOut)
Definition: variant.c:4727

◆ interp_errmode()

static HRESULT interp_errmode ( exec_ctx_t *  ctx)
static

Definition at line 1322 of file interp.c.

1323{
1324 const int err_mode = ctx->instr->arg1.uint;
1325
1326 TRACE("%d\n", err_mode);
1327
1328 ctx->resume_next = err_mode;
1329 clear_ei(&ctx->script->ei);
1330 return S_OK;
1331}

◆ interp_exp()

static HRESULT interp_exp ( exec_ctx_t *  ctx)
static

Definition at line 1957 of file interp.c.

1958{
1959 variant_val_t r, l;
1960 VARIANT v;
1961 HRESULT hres;
1962
1963 TRACE("\n");
1964
1965 hres = stack_pop_val(ctx, &r);
1966 if(FAILED(hres))
1967 return hres;
1968
1969 hres = stack_pop_val(ctx, &l);
1970 if(SUCCEEDED(hres)) {
1971 hres = VarPow(l.v, r.v, &v);
1972 release_val(&l);
1973 }
1974 release_val(&r);
1975 if(FAILED(hres))
1976 return hres;
1977
1978 return stack_push(ctx, &v);
1979}
VarPow
HRESULT WINAPI VarPow(LPVARIANT left, LPVARIANT right, LPVARIANT result)
Definition: variant.c:5579

◆ interp_gt()

static HRESULT interp_gt ( exec_ctx_t *  ctx)
static

Definition at line 1619 of file interp.c.

1620{
1621 VARIANT v;
1622 HRESULT hres;
1623
1624 TRACE("\n");
1625
1626 hres = cmp_oper(ctx);
1627 if(FAILED(hres))
1628 return hres;
1629 if(hres == VARCMP_NULL)
1630 return stack_push_null(ctx);
1631
1632 V_VT(&v) = VT_BOOL;
1633 V_BOOL(&v) = hres == VARCMP_GT ? VARIANT_TRUE : VARIANT_FALSE;
1634 return stack_push(ctx, &v);
1635}
VARCMP_GT
#define VARCMP_GT
Definition: oleauto.h:659

◆ interp_gteq()

static HRESULT interp_gteq ( exec_ctx_t *  ctx)
static

Definition at line 1637 of file interp.c.

1638{
1639 VARIANT v;
1640 HRESULT hres;
1641
1642 TRACE("\n");
1643
1644 hres = cmp_oper(ctx);
1645 if(FAILED(hres))
1646 return hres;
1647 if(hres == VARCMP_NULL)
1648 return stack_push_null(ctx);
1649
1650 V_VT(&v) = VT_BOOL;
1651 V_BOOL(&v) = hres == VARCMP_GT || hres == VARCMP_EQ ? VARIANT_TRUE : VARIANT_FALSE;
1652 return stack_push(ctx, &v);
1653}

◆ interp_hres()

static HRESULT interp_hres ( exec_ctx_t *  ctx)
static

Definition at line 1403 of file interp.c.

1404{
1405 const unsigned arg = ctx->instr->arg1.uint;
1406 VARIANT v;
1407
1408 TRACE("%d\n", arg);
1409
1410 V_VT(&v) = VT_ERROR;
1411 V_ERROR(&v) = arg;
1412 return stack_push(ctx, &v);
1413}
VT_ERROR
@ VT_ERROR
Definition: compat.h:2305
V_ERROR
#define V_ERROR(A)
Definition: oleauto.h:241

◆ interp_icall()

static HRESULT interp_icall ( exec_ctx_t *  ctx)
static

Definition at line 618 of file interp.c.

619{
620 VARIANT v;
621 HRESULT hres;
622
623 TRACE("\n");
624
625 hres = do_icall(ctx, &v);
626 if(FAILED(hres))
627 return hres;
628
629 return stack_push(ctx, &v);
630}
do_icall
static HRESULT do_icall(exec_ctx_t *ctx, VARIANT *res)
Definition: interp.c:518

◆ interp_icallv()

static HRESULT interp_icallv ( exec_ctx_t *  ctx)
static

Definition at line 632 of file interp.c.

633{
634 TRACE("\n");
635 return do_icall(ctx, NULL);
636}

◆ interp_idiv()

static HRESULT interp_idiv ( exec_ctx_t *  ctx)
static

Definition at line 1885 of file interp.c.

1886{
1887 variant_val_t r, l;
1888 VARIANT v;
1889 HRESULT hres;
1890
1891 TRACE("\n");
1892
1893 hres = stack_pop_val(ctx, &r);
1894 if(FAILED(hres))
1895 return hres;
1896
1897 hres = stack_pop_val(ctx, &l);
1898 if(SUCCEEDED(hres)) {
1899 hres = VarIdiv(l.v, r.v, &v);
1900 release_val(&l);
1901 }
1902 release_val(&r);
1903 if(FAILED(hres))
1904 return hres;
1905
1906 return stack_push(ctx, &v);
1907}
VarIdiv
HRESULT WINAPI VarIdiv(LPVARIANT left, LPVARIANT right, LPVARIANT result)
Definition: variant.c:5183

◆ interp_imp()

static HRESULT interp_imp ( exec_ctx_t *  ctx)
static

Definition at line 1531 of file interp.c.

1532{
1533 variant_val_t r, l;
1534 VARIANT v;
1535 HRESULT hres;
1536
1537 TRACE("\n");
1538
1539 hres = stack_pop_val(ctx, &r);
1540 if(FAILED(hres))
1541 return hres;
1542
1543 hres = stack_pop_val(ctx, &l);
1544 if(SUCCEEDED(hres)) {
1545 hres = VarImp(l.v, r.v, &v);
1546 release_val(&l);
1547 }
1548 release_val(&r);
1549 if(FAILED(hres))
1550 return hres;
1551
1552 return stack_push(ctx, &v);
1553}
VarImp
HRESULT WINAPI VarImp(LPVARIANT left, LPVARIANT right, LPVARIANT result)
Definition: variant.c:5693

◆ interp_incc()

static HRESULT interp_incc ( exec_ctx_t *  ctx)
static

Definition at line 1999 of file interp.c.

2000{
2001 const BSTR ident = ctx->instr->arg1.bstr;
2002 VARIANT v;
2003 ref_t ref;
2004 HRESULT hres;
2005
2006 TRACE("\n");
2007
2008 hres = lookup_identifier(ctx, ident, VBDISP_LET, &ref);
2009 if(FAILED(hres))
2010 return hres;
2011
2012 if(ref.type != REF_VAR) {
2013 FIXME("ref.type is not REF_VAR\n");
2014 return E_FAIL;
2015 }
2016
2017 hres = VarAdd(stack_top(ctx, 0), ref.u.v, &v);
2018 if(FAILED(hres))
2019 return hres;
2020
2021 VariantClear(ref.u.v);
2022 *ref.u.v = v;
2023 return S_OK;
2024}

◆ interp_int()

static HRESULT interp_int ( exec_ctx_t *  ctx)
static

Definition at line 1347 of file interp.c.

1348{
1349 const LONG arg = ctx->instr->arg1.lng;
1350 VARIANT v;
1351
1352 TRACE("%d\n", arg);
1353
1354 if(arg == (INT16)arg) {
1355 V_VT(&v) = VT_I2;
1356 V_I2(&v) = arg;
1357 }else {
1358 V_VT(&v) = VT_I4;
1359 V_I4(&v) = arg;
1360 }
1361 return stack_push(ctx, &v);
1362}
INT16
signed short INT16
Definition: ProcessorBind.h:180
VT_I4
@ VT_I4
Definition: compat.h:2298
VT_I2
@ VT_I2
Definition: compat.h:2297
V_I4
#define V_I4(A)
Definition: oleauto.h:247
V_I2
#define V_I2(A)
Definition: oleauto.h:245

◆ interp_is()

static HRESULT interp_is ( exec_ctx_t *  ctx)
static

Definition at line 1762 of file interp.c.

1763{
1764 IDispatch *l, *r;
1765 VARIANT v;
1766 HRESULT hres;
1767
1768 TRACE("\n");
1769
1770 hres = stack_pop_disp(ctx, &r);
1771 if(FAILED(hres))
1772 return hres;
1773
1774 hres = stack_pop_disp(ctx, &l);
1775 if(SUCCEEDED(hres)) {
1776 V_VT(&v) = VT_BOOL;
1777 hres = disp_cmp(l, r, &V_BOOL(&v));
1778 if(l)
1779 IDispatch_Release(l);
1780 }
1781 if(r)
1782 IDispatch_Release(r);
1783 if(FAILED(hres))
1784 return hres;
1785
1786 return stack_push(ctx, &v);
1787}
disp_cmp
static HRESULT disp_cmp(IDispatch *disp1, IDispatch *disp2, VARIANT_BOOL *ret)
Definition: interp.c:1718

◆ interp_jmp()

static HRESULT interp_jmp ( exec_ctx_t *  ctx)
static

Definition at line 1210 of file interp.c.

1211{
1212 const unsigned arg = ctx->instr->arg1.uint;
1213
1214 TRACE("%u\n", arg);
1215
1216 instr_jmp(ctx, arg);
1217 return S_OK;
1218}

◆ interp_jmp_false()

static HRESULT interp_jmp_false ( exec_ctx_t *  ctx)
static

Definition at line 1220 of file interp.c.

1221{
1222 const unsigned arg = ctx->instr->arg1.uint;
1223 HRESULT hres;
1224 BOOL b;
1225
1226 TRACE("%u\n", arg);
1227
1228 hres = stack_pop_bool(ctx, &b);
1229 if(FAILED(hres))
1230 return hres;
1231
1232 if(b)
1233 ctx->instr++;
1234 else
1235 instr_jmp(ctx, ctx->instr->arg1.uint);
1236 return S_OK;
1237}
b
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
stack_pop_bool
static int stack_pop_bool(exec_ctx_t *ctx, BOOL *b)
Definition: interp.c:362
b
#define b
Definition: ke_i.h:79

◆ interp_jmp_true()

static HRESULT interp_jmp_true ( exec_ctx_t *  ctx)
static

Definition at line 1239 of file interp.c.

1240{
1241 const unsigned arg = ctx->instr->arg1.uint;
1242 HRESULT hres;
1243 BOOL b;
1244
1245 TRACE("%u\n", arg);
1246
1247 hres = stack_pop_bool(ctx, &b);
1248 if(FAILED(hres))
1249 return hres;
1250
1251 if(b)
1252 instr_jmp(ctx, ctx->instr->arg1.uint);
1253 else
1254 ctx->instr++;
1255 return S_OK;
1256}

◆ interp_lt()

static HRESULT interp_lt ( exec_ctx_t *  ctx)
static

Definition at line 1655 of file interp.c.

1656{
1657 VARIANT v;
1658 HRESULT hres;
1659
1660 TRACE("\n");
1661
1662 hres = cmp_oper(ctx);
1663 if(FAILED(hres))
1664 return hres;
1665 if(hres == VARCMP_NULL)
1666 return stack_push_null(ctx);
1667
1668 V_VT(&v) = VT_BOOL;
1669 V_BOOL(&v) = hres == VARCMP_LT ? VARIANT_TRUE : VARIANT_FALSE;
1670 return stack_push(ctx, &v);
1671}
VARCMP_LT
#define VARCMP_LT
Definition: oleauto.h:657

◆ interp_lteq()

static HRESULT interp_lteq ( exec_ctx_t *  ctx)
static

Definition at line 1673 of file interp.c.

1674{
1675 VARIANT v;
1676 HRESULT hres;
1677
1678 TRACE("\n");
1679
1680 hres = cmp_oper(ctx);
1681 if(FAILED(hres))
1682 return hres;
1683 if(hres == VARCMP_NULL)
1684 return stack_push_null(ctx);
1685
1686 V_VT(&v) = VT_BOOL;
1687 V_BOOL(&v) = hres == VARCMP_LT || hres == VARCMP_EQ ? VARIANT_TRUE : VARIANT_FALSE;
1688 return stack_push(ctx, &v);
1689}

◆ interp_mcall()

static HRESULT interp_mcall ( exec_ctx_t *  ctx)
static

Definition at line 669 of file interp.c.

670{
671 VARIANT res;
672 HRESULT hres;
673
674 TRACE("\n");
675
676 hres = do_mcall(ctx, &res);
677 if(FAILED(hres))
678 return hres;
679
680 return stack_push(ctx, &res);
681}
do_mcall
static HRESULT do_mcall(exec_ctx_t *ctx, VARIANT *res)
Definition: interp.c:638

◆ interp_mcallv()

static HRESULT interp_mcallv ( exec_ctx_t *  ctx)
static

Definition at line 683 of file interp.c.

684{
685 TRACE("\n");
686
687 return do_mcall(ctx, NULL);
688}

◆ interp_me()

static HRESULT interp_me ( exec_ctx_t *  ctx)
static

Definition at line 1298 of file interp.c.

1299{
1300 VARIANT v;
1301
1302 TRACE("\n");
1303
1304 IDispatch_AddRef(ctx->this_obj);
1305 V_VT(&v) = VT_DISPATCH;
1306 V_DISPATCH(&v) = ctx->this_obj;
1307 return stack_push(ctx, &v);
1308}

◆ interp_mod()

static HRESULT interp_mod ( exec_ctx_t *  ctx)
static

Definition at line 1861 of file interp.c.

1862{
1863 variant_val_t r, l;
1864 VARIANT v;
1865 HRESULT hres;
1866
1867 TRACE("\n");
1868
1869 hres = stack_pop_val(ctx, &r);
1870 if(FAILED(hres))
1871 return hres;
1872
1873 hres = stack_pop_val(ctx, &l);
1874 if(SUCCEEDED(hres)) {
1875 hres = VarMod(l.v, r.v, &v);
1876 release_val(&l);
1877 }
1878 release_val(&r);
1879 if(FAILED(hres))
1880 return hres;
1881
1882 return stack_push(ctx, &v);
1883}
VarMod
HRESULT WINAPI VarMod(LPVARIANT left, LPVARIANT right, LPVARIANT result)
Definition: variant.c:5337

◆ interp_mul()

static HRESULT interp_mul ( exec_ctx_t *  ctx)
static

Definition at line 1933 of file interp.c.

1934{
1935 variant_val_t r, l;
1936 VARIANT v;
1937 HRESULT hres;
1938
1939 TRACE("\n");
1940
1941 hres = stack_pop_val(ctx, &r);
1942 if(FAILED(hres))
1943 return hres;
1944
1945 hres = stack_pop_val(ctx, &l);
1946 if(SUCCEEDED(hres)) {
1947 hres = VarMul(l.v, r.v, &v);
1948 release_val(&l);
1949 }
1950 release_val(&r);
1951 if(FAILED(hres))
1952 return hres;
1953
1954 return stack_push(ctx, &v);
1955}
VarMul
HRESULT WINAPI VarMul(LPVARIANT left, LPVARIANT right, LPVARIANT result)
Definition: variant.c:3343

◆ interp_neg()

static HRESULT interp_neg ( exec_ctx_t *  ctx)
static

Definition at line 1981 of file interp.c.

1982{
1983 variant_val_t val;
1984 VARIANT v;
1985 HRESULT hres;
1986
1987 hres = stack_pop_val(ctx, &val);
1988 if(FAILED(hres))
1989 return hres;
1990
1991 hres = VarNeg(val.v, &v);
1992 release_val(&val);
1993 if(FAILED(hres))
1994 return hres;
1995
1996 return stack_push(ctx, &v);
1997}
val
GLuint GLfloat * val
Definition: glext.h:7180
VarNeg
HRESULT WINAPI VarNeg(LPVARIANT pVarIn, LPVARIANT pVarOut)
Definition: variant.c:4781

◆ interp_nequal()

static HRESULT interp_nequal ( exec_ctx_t *  ctx)
static

Definition at line 1601 of file interp.c.

1602{
1603 VARIANT v;
1604 HRESULT hres;
1605
1606 TRACE("\n");
1607
1608 hres = cmp_oper(ctx);
1609 if(FAILED(hres))
1610 return hres;
1611 if(hres == VARCMP_NULL)
1612 return stack_push_null(ctx);
1613
1614 V_VT(&v) = VT_BOOL;
1615 V_BOOL(&v) = hres != VARCMP_EQ ? VARIANT_TRUE : VARIANT_FALSE;
1616 return stack_push(ctx, &v);
1617}

◆ interp_new()

static HRESULT interp_new ( exec_ctx_t *  ctx)
static

Definition at line 984 of file interp.c.

985{
986 const WCHAR *arg = ctx->instr->arg1.bstr;
987 class_desc_t *class_desc;
988 vbdisp_t *obj;
989 VARIANT v;
990 HRESULT hres;
991
992 static const WCHAR regexpW[] = {'r','e','g','e','x','p',0};
993
994 TRACE("%s\n", debugstr_w(arg));
995
996 if(!wcsicmp(arg, regexpW)) {
997 V_VT(&v) = VT_DISPATCH;
998 hres = create_regexp(&V_DISPATCH(&v));
999 if(FAILED(hres))
1000 return hres;
1001
1002 return stack_push(ctx, &v);
1003 }
1004
1005 for(class_desc = ctx->script->classes; class_desc; class_desc = class_desc->next) {
1006 if(!wcsicmp(class_desc->name, arg))
1007 break;
1008 }
1009 if(!class_desc) {
1010 FIXME("Class %s not found\n", debugstr_w(arg));
1011 return E_FAIL;
1012 }
1013
1014 hres = create_vbdisp(class_desc, &obj);
1015 if(FAILED(hres))
1016 return hres;
1017
1018 V_VT(&v) = VT_DISPATCH;
1019 V_DISPATCH(&v) = (IDispatch*)&obj->IDispatchEx_iface;
1020 return stack_push(ctx, &v);
1021}
wcsicmp
#define wcsicmp
Definition: compat.h:15
create_regexp
HRESULT create_regexp(script_ctx_t *, jsstr_t *, DWORD, jsdisp_t **) DECLSPEC_HIDDEN
Definition: jsregexp.c:644
_class_desc_t
Definition: vbscript.h:96
_class_desc_t::next
struct _class_desc_t * next
Definition: vbscript.h:113
_class_desc_t::name
const WCHAR * name
Definition: vbscript.h:97
_vbdisp_t
Definition: vbscript.h:116
create_vbdisp
HRESULT create_vbdisp(const class_desc_t *desc, vbdisp_t **ret)
Definition: vbdisp.c:470

◆ interp_newenum()

static HRESULT interp_newenum ( exec_ctx_t *  ctx)
static

Definition at line 1108 of file interp.c.

1109{
1110 variant_val_t v;
1111 VARIANT *r;
1112 HRESULT hres;
1113
1114 TRACE("\n");
1115
1116 stack_pop_deref(ctx, &v);
1117 assert(V_VT(stack_top(ctx, 0)) == VT_EMPTY);
1118 r = stack_top(ctx, 0);
1119
1120 switch(V_VT(v.v)) {
1121 case VT_DISPATCH|VT_BYREF:
1122 case VT_DISPATCH: {
1123 IEnumVARIANT *iter;
1124 DISPPARAMS dp = {0};
1125 VARIANT iterv;
1126
1127 hres = disp_call(ctx->script, V_ISBYREF(v.v) ? *V_DISPATCHREF(v.v) : V_DISPATCH(v.v), DISPID_NEWENUM, &dp, &iterv);
1128 release_val(&v);
1129 if(FAILED(hres))
1130 return hres;
1131
1132 if(V_VT(&iterv) != VT_UNKNOWN && V_VT(&iterv) != VT_DISPATCH) {
1133 FIXME("Unsupported iterv %s\n", debugstr_variant(&iterv));
1134 VariantClear(&iterv);
1135 return hres;
1136 }
1137
1138 hres = IUnknown_QueryInterface(V_UNKNOWN(&iterv), &IID_IEnumVARIANT, (void**)&iter);
1139 IUnknown_Release(V_UNKNOWN(&iterv));
1140 if(FAILED(hres)) {
1141 FIXME("Could not get IEnumVARIANT iface: %08x\n", hres);
1142 return hres;
1143 }
1144
1145 V_VT(r) = VT_UNKNOWN;
1146 V_UNKNOWN(r) = (IUnknown*)iter;
1147 break;
1148 }
1149 case VT_VARIANT|VT_ARRAY:
1150 case VT_VARIANT|VT_ARRAY|VT_BYREF: {
1151 IEnumVARIANT *iter;
1152
1153 hres = create_safearray_iter(V_ISBYREF(v.v) ? *V_ARRAYREF(v.v) : V_ARRAY(v.v), &iter);
1154 if(FAILED(hres))
1155 return hres;
1156
1157 V_VT(r) = VT_UNKNOWN;
1158 V_UNKNOWN(r) = (IUnknown*)iter;
1159 break;
1160 }
1161 default:
1162 FIXME("Unsupported for %s\n", debugstr_variant(v.v));
1163 release_val(&v);
1164 return E_NOTIMPL;
1165 }
1166
1167 return S_OK;
1168}
create_safearray_iter
HRESULT create_safearray_iter(SAFEARRAY *sa, IEnumVARIANT **ev)
Definition: utils.c:163
stack_pop_deref
static void stack_pop_deref(exec_ctx_t *ctx, variant_val_t *r)
Definition: interp.c:294
debugstr_variant
static const char * debugstr_variant(const VARIANT *var)
Definition: container.c:46
V_ISBYREF
#define V_ISBYREF(A)
Definition: oleauto.h:217
V_DISPATCHREF
#define V_DISPATCHREF(A)
Definition: oleauto.h:240

◆ interp_not()

static HRESULT interp_not ( exec_ctx_t *  ctx)
static

Definition at line 1415 of file interp.c.

1416{
1417 variant_val_t val;
1418 VARIANT v;
1419 HRESULT hres;
1420
1421 TRACE("\n");
1422
1423 hres = stack_pop_val(ctx, &val);
1424 if(FAILED(hres))
1425 return hres;
1426
1427 hres = VarNot(val.v, &v);
1428 release_val(&val);
1429 if(FAILED(hres))
1430 return hres;
1431
1432 return stack_push(ctx, &v);
1433}
VarNot
HRESULT WINAPI VarNot(LPVARIANT pVarIn, LPVARIANT pVarOut)
Definition: variant.c:4909

◆ interp_nothing()

static HRESULT interp_nothing ( exec_ctx_t *  ctx)
static

Definition at line 1392 of file interp.c.

1393{
1394 VARIANT v;
1395
1396 TRACE("\n");
1397
1398 V_VT(&v) = VT_DISPATCH;
1399 V_DISPATCH(&v) = NULL;
1400 return stack_push(ctx, &v);
1401}

◆ interp_null()

static HRESULT interp_null ( exec_ctx_t *  ctx)
static

Definition at line 1386 of file interp.c.

1387{
1388 TRACE("\n");
1389 return stack_push_null(ctx);
1390}

◆ interp_or()

static HRESULT interp_or ( exec_ctx_t *  ctx)
static

Definition at line 1459 of file interp.c.

1460{
1461 variant_val_t r, l;
1462 VARIANT v;
1463 HRESULT hres;
1464
1465 TRACE("\n");
1466
1467 hres = stack_pop_val(ctx, &r);
1468 if(FAILED(hres))
1469 return hres;
1470
1471 hres = stack_pop_val(ctx, &l);
1472 if(SUCCEEDED(hres)) {
1473 hres = VarOr(l.v, r.v, &v);
1474 release_val(&l);
1475 }
1476 release_val(&r);
1477 if(FAILED(hres))
1478 return hres;
1479
1480 return stack_push(ctx, &v);
1481}
VarOr
HRESULT WINAPI VarOr(LPVARIANT pVarLeft, LPVARIANT pVarRight, LPVARIANT pVarOut)
Definition: variant.c:3951

◆ interp_pop()

static HRESULT interp_pop ( exec_ctx_t *  ctx)
static

Definition at line 974 of file interp.c.

975{
976 const unsigned n = ctx->instr->arg1.uint;
977
978 TRACE("%u\n", n);
979
980 stack_popn(ctx, n);
981 return S_OK;
982}
n
GLdouble n
Definition: glext.h:7729

◆ interp_ret()

static HRESULT interp_ret ( exec_ctx_t *  ctx)
static

Definition at line 1258 of file interp.c.

1259{
1260 TRACE("\n");
1261
1262 ctx->instr = NULL;
1263 return S_OK;
1264}

◆ interp_retval()

static HRESULT interp_retval ( exec_ctx_t *  ctx)
static

Definition at line 1266 of file interp.c.

1267{
1268 variant_val_t val;
1269 HRESULT hres;
1270
1271 TRACE("\n");
1272
1273 hres = stack_pop_val(ctx, &val);
1274 if(FAILED(hres))
1275 return hres;
1276
1277 if(val.owned) {
1278 VariantClear(&ctx->ret_val);
1279 ctx->ret_val = *val.v;
1280 }
1281 else {
1282 hres = VariantCopy(&ctx->ret_val, val.v);
1283 if(FAILED(hres))
1284 return hres;
1285 }
1286
1287 return S_OK;
1288}
VariantCopy
HRESULT WINAPI VariantCopy(VARIANTARG *pvargDest, VARIANTARG *pvargSrc)
Definition: variant.c:748

◆ interp_set_ident()

static HRESULT interp_set_ident ( exec_ctx_t *  ctx)
static

Definition at line 820 of file interp.c.

821{
822 const BSTR arg = ctx->instr->arg1.bstr;
823 const unsigned arg_cnt = ctx->instr->arg2.uint;
824 DISPPARAMS dp;
825 HRESULT hres;
826
827 TRACE("%s\n", debugstr_w(arg));
828
829 if(arg_cnt) {
830 FIXME("arguments not supported\n");
831 return E_NOTIMPL;
832 }
833
834 hres = stack_assume_disp(ctx, 0, NULL);
835 if(FAILED(hres))
836 return hres;
837
838 vbstack_to_dp(ctx, 0, TRUE, &dp);
839 hres = assign_ident(ctx, ctx->instr->arg1.bstr, DISPATCH_PROPERTYPUTREF, &dp);
840 if(FAILED(hres))
841 return hres;
842
843 stack_popn(ctx, 1);
844 return S_OK;
845}

◆ interp_set_member()

static HRESULT interp_set_member ( exec_ctx_t *  ctx)
static

Definition at line 879 of file interp.c.

880{
881 BSTR identifier = ctx->instr->arg1.bstr;
882 const unsigned arg_cnt = ctx->instr->arg2.uint;
883 IDispatch *obj;
884 DISPPARAMS dp;
885 DISPID id;
886 HRESULT hres;
887
888 TRACE("%s\n", debugstr_w(identifier));
889
890 if(arg_cnt) {
891 FIXME("arguments not supported\n");
892 return E_NOTIMPL;
893 }
894
895 hres = stack_assume_disp(ctx, 1, &obj);
896 if(FAILED(hres))
897 return hres;
898
899 if(!obj) {
900 FIXME("NULL obj\n");
901 return E_FAIL;
902 }
903
904 hres = stack_assume_disp(ctx, 0, NULL);
905 if(FAILED(hres))
906 return hres;
907
908 hres = disp_get_id(obj, identifier, VBDISP_SET, FALSE, &id);
909 if(SUCCEEDED(hres)) {
910 vbstack_to_dp(ctx, arg_cnt, TRUE, &dp);
911 hres = disp_propput(ctx->script, obj, id, DISPATCH_PROPERTYPUTREF, &dp);
912 }
913 if(FAILED(hres))
914 return hres;
915
916 stack_popn(ctx, 2);
917 return S_OK;
918}
VBDISP_SET
@ VBDISP_SET
Definition: vbscript.h:74

◆ interp_step()

static HRESULT interp_step ( exec_ctx_t *  ctx)
static

Definition at line 1068 of file interp.c.

1069{
1070 const BSTR ident = ctx->instr->arg2.bstr;
1071 BOOL gteq_zero;
1072 VARIANT zero;
1073 ref_t ref;
1074 HRESULT hres;
1075
1076 TRACE("%s\n", debugstr_w(ident));
1077
1078 V_VT(&zero) = VT_I2;
1079 V_I2(&zero) = 0;
1080 hres = VarCmp(stack_top(ctx, 0), &zero, ctx->script->lcid, 0);
1081 if(FAILED(hres))
1082 return hres;
1083
1084 gteq_zero = hres == VARCMP_GT || hres == VARCMP_EQ;
1085
1086 hres = lookup_identifier(ctx, ident, VBDISP_ANY, &ref);
1087 if(FAILED(hres))
1088 return hres;
1089
1090 if(ref.type != REF_VAR) {
1091 FIXME("%s is not REF_VAR\n", debugstr_w(ident));
1092 return E_FAIL;
1093 }
1094
1095 hres = VarCmp(ref.u.v, stack_top(ctx, 1), ctx->script->lcid, 0);
1096 if(FAILED(hres))
1097 return hres;
1098
1099 if(hres == VARCMP_EQ || hres == (gteq_zero ? VARCMP_LT : VARCMP_GT)) {
1100 ctx->instr++;
1101 }else {
1102 stack_popn(ctx, 2);
1103 instr_jmp(ctx, ctx->instr->arg1.uint);
1104 }
1105 return S_OK;
1106}
zero
int zero
Definition: sehframes.cpp:29
VarCmp
HRESULT WINAPI VarCmp(LPVARIANT left, LPVARIANT right, LCID lcid, DWORD flags)
Definition: variant.c:2712
VBDISP_ANY
@ VBDISP_ANY
Definition: vbscript.h:75

◆ interp_stop()

static HRESULT interp_stop ( exec_ctx_t *  ctx)
static

Definition at line 1290 of file interp.c.

1291{
1292 WARN("\n");
1293
1294 /* NOTE: this should have effect in debugging mode (that we don't support yet) */
1295 return S_OK;
1296}

◆ interp_string()

static HRESULT interp_string ( exec_ctx_t *  ctx)
static

Definition at line 1333 of file interp.c.

1334{
1335 VARIANT v;
1336
1337 TRACE("\n");
1338
1339 V_VT(&v) = VT_BSTR;
1340 V_BSTR(&v) = SysAllocString(ctx->instr->arg1.str);
1341 if(!V_BSTR(&v))
1342 return E_OUTOFMEMORY;
1343
1344 return stack_push(ctx, &v);
1345}
VT_BSTR
@ VT_BSTR
Definition: compat.h:2303
SysAllocString
BSTR WINAPI SysAllocString(LPCOLESTR str)
Definition: oleaut.c:238
V_BSTR
#define V_BSTR(A)
Definition: oleauto.h:226

◆ interp_sub()

static HRESULT interp_sub ( exec_ctx_t *  ctx)
static

Definition at line 1837 of file interp.c.

1838{
1839 variant_val_t r, l;
1840 VARIANT v;
1841 HRESULT hres;
1842
1843 TRACE("\n");
1844
1845 hres = stack_pop_val(ctx, &r);
1846 if(FAILED(hres))
1847 return hres;
1848
1849 hres = stack_pop_val(ctx, &l);
1850 if(SUCCEEDED(hres)) {
1851 hres = VarSub(l.v, r.v, &v);
1852 release_val(&l);
1853 }
1854 release_val(&r);
1855 if(FAILED(hres))
1856 return hres;
1857
1858 return stack_push(ctx, &v);
1859}
VarSub
HRESULT WINAPI VarSub(LPVARIANT left, LPVARIANT right, LPVARIANT result)
Definition: variant.c:3683

◆ interp_val()

static HRESULT interp_val ( exec_ctx_t *  ctx)
static

Definition at line 952 of file interp.c.

953{
954 variant_val_t val;
955 VARIANT v;
956 HRESULT hres;
957
958 TRACE("\n");
959
960 hres = stack_pop_val(ctx, &val);
961 if(FAILED(hres))
962 return hres;
963
964 if(!val.owned) {
965 V_VT(&v) = VT_EMPTY;
966 hres = VariantCopy(&v, val.v);
967 if(FAILED(hres))
968 return hres;
969 }
970
971 return stack_push(ctx, val.owned ? val.v : &v);
972}

◆ interp_xor()

static HRESULT interp_xor ( exec_ctx_t *  ctx)
static

Definition at line 1483 of file interp.c.

1484{
1485 variant_val_t r, l;
1486 VARIANT v;
1487 HRESULT hres;
1488
1489 TRACE("\n");
1490
1491 hres = stack_pop_val(ctx, &r);
1492 if(FAILED(hres))
1493 return hres;
1494
1495 hres = stack_pop_val(ctx, &l);
1496 if(SUCCEEDED(hres)) {
1497 hres = VarXor(l.v, r.v, &v);
1498 release_val(&l);
1499 }
1500 release_val(&r);
1501 if(FAILED(hres))
1502 return hres;
1503
1504 return stack_push(ctx, &v);
1505}
VarXor
HRESULT WINAPI VarXor(LPVARIANT pVarLeft, LPVARIANT pVarRight, LPVARIANT pVarOut)
Definition: variant.c:4546

◆ lookup_dynamic_vars()

static BOOL lookup_dynamic_vars ( dynamic_var_t *  var,
const WCHAR *  name,
ref_t *  ref 
)
static

Definition at line 83 of file interp.c.

84{
85 while(var) {
86 if(!wcsicmp(var->name, name)) {
87 ref->type = var->is_const ? REF_CONST : REF_VAR;
88 ref->u.v = &var->v;
89 return TRUE;
90 }
91
92 var = var->next;
93 }
94
95 return FALSE;
96}
var
const char * var
Definition: shader.c:5666

Referenced by lookup_identifier().

◆ lookup_identifier()

static HRESULT lookup_identifier ( exec_ctx_t *  ctx,
BSTR  name,
vbdisp_invoke_type_t  invoke_type,
ref_t *  ref 
)
static

Definition at line 98 of file interp.c.

99{
100 named_item_t *item;
101 function_t *func;
102 IDispatch *disp;
103 unsigned i;
104 DISPID id;
105 HRESULT hres;
106
107 if(invoke_type == VBDISP_LET
108 && (ctx->func->type == FUNC_FUNCTION || ctx->func->type == FUNC_PROPGET || ctx->func->type == FUNC_DEFGET)
109 && !wcsicmp(name, ctx->func->name)) {
110 ref->type = REF_VAR;
111 ref->u.v = &ctx->ret_val;
112 return S_OK;
113 }
114
115 for(i=0; i < ctx->func->var_cnt; i++) {
116 if(!wcsicmp(ctx->func->vars[i].name, name)) {
117 ref->type = REF_VAR;
118 ref->u.v = ctx->vars+i;
119 return TRUE;
120 }
121 }
122
123 for(i=0; i < ctx->func->arg_cnt; i++) {
124 if(!wcsicmp(ctx->func->args[i].name, name)) {
125 ref->type = REF_VAR;
126 ref->u.v = ctx->args+i;
127 return S_OK;
128 }
129 }
130
131 if(lookup_dynamic_vars(ctx->func->type == FUNC_GLOBAL ? ctx->script->global_vars : ctx->dynamic_vars, name, ref))
132 return S_OK;
133
134 if(ctx->func->type != FUNC_GLOBAL) {
135 if(ctx->vbthis) {
136 /* FIXME: Bind such identifier while generating bytecode. */
137 for(i=0; i < ctx->vbthis->desc->prop_cnt; i++) {
138 if(!wcsicmp(ctx->vbthis->desc->props[i].name, name)) {
139 ref->type = REF_VAR;
140 ref->u.v = ctx->vbthis->props+i;
141 return S_OK;
142 }
143 }
144 }
145
146 hres = disp_get_id(ctx->this_obj, name, invoke_type, TRUE, &id);
147 if(SUCCEEDED(hres)) {
148 ref->type = REF_DISP;
149 ref->u.d.disp = ctx->this_obj;
150 ref->u.d.id = id;
151 return S_OK;
152 }
153 }
154
155 if(ctx->func->code_ctx->context) {
156 hres = disp_get_id(ctx->func->code_ctx->context, name, invoke_type, TRUE, &id);
157 if(SUCCEEDED(hres)) {
158 ref->type = REF_DISP;
159 ref->u.d.disp = ctx->func->code_ctx->context;
160 ref->u.d.id = id;
161 return S_OK;
162 }
163 }
164
165 if(ctx->func->type != FUNC_GLOBAL && lookup_dynamic_vars(ctx->script->global_vars, name, ref))
166 return S_OK;
167
168 for(func = ctx->script->global_funcs; func; func = func->next) {
169 if(!wcsicmp(func->name, name)) {
170 ref->type = REF_FUNC;
171 ref->u.f = func;
172 return S_OK;
173 }
174 }
175
176 hres = get_builtin_id(ctx->script->global_obj, name, &id);
177 if(SUCCEEDED(hres)) {
178 ref->type = REF_DISP;
179 ref->u.d.disp = &ctx->script->global_obj->IDispatch_iface;
180 ref->u.d.id = id;
181 return S_OK;
182 }
183
184 disp = lookup_named_item(ctx->script, name, SCRIPTITEM_ISVISIBLE);
185 if(disp) {
186 ref->type = REF_OBJ;
187 ref->u.obj = disp;
188 return S_OK;
189 }
190
191 LIST_FOR_EACH_ENTRY(item, &ctx->script->named_items, named_item_t, entry) {
192 if((item->flags & SCRIPTITEM_GLOBALMEMBERS)) {
193 hres = disp_get_id(item->disp, name, invoke_type, FALSE, &id);
194 if(SUCCEEDED(hres)) {
195 ref->type = REF_DISP;
196 ref->u.d.disp = item->disp;
197 ref->u.d.id = id;
198 return S_OK;
199 }
200 }
201 }
202
203 ref->type = REF_NONE;
204 return S_OK;
205}
lookup_named_item
IDispatch * lookup_named_item(script_ctx_t *ctx, const WCHAR *name, unsigned flags)
Definition: vbscript.c:99
lookup_dynamic_vars
static BOOL lookup_dynamic_vars(dynamic_var_t *var, const WCHAR *name, ref_t *ref)
Definition: interp.c:83
entry
uint32_t entry
Definition: isohybrid.c:63
item
static ATOM item
Definition: dde.c:856
get_builtin_id
static HRESULT get_builtin_id(DispatchEx *This, BSTR name, DWORD grfdex, DISPID *ret)
Definition: dispex.c:873
LIST_FOR_EACH_ENTRY
#define LIST_FOR_EACH_ENTRY(elem, list, type, field)
Definition: list.h:198
_function_t
Definition: vbscript.h:321
named_item_t
Definition: jscript.h:362
FUNC_PROPGET
@ FUNC_PROPGET
Definition: vbscript.h:311
FUNC_DEFGET
@ FUNC_DEFGET
Definition: vbscript.h:314
FUNC_FUNCTION
@ FUNC_FUNCTION
Definition: vbscript.h:309

Referenced by assign_ident(), do_icall(), interp_const(), interp_dim(), interp_incc(), and interp_step().

◆ release_dynamic_vars()

void release_dynamic_vars ( dynamic_var_t *  var)

Definition at line 2044 of file interp.c.

2045{
2046 while(var) {
2047 VariantClear(&var->v);
2048 var = var->next;
2049 }
2050}

Referenced by release_exec(), and release_script().

◆ release_exec()

static void release_exec ( exec_ctx_t *  ctx)
static

Definition at line 2052 of file interp.c.

2053{
2054 unsigned i;
2055
2056 VariantClear(&ctx->ret_val);
2057 release_dynamic_vars(ctx->dynamic_vars);
2058
2059 if(ctx->this_obj)
2060 IDispatch_Release(ctx->this_obj);
2061
2062 if(ctx->args) {
2063 for(i=0; i < ctx->func->arg_cnt; i++)
2064 VariantClear(ctx->args+i);
2065 }
2066
2067 if(ctx->vars) {
2068 for(i=0; i < ctx->func->var_cnt; i++)
2069 VariantClear(ctx->vars+i);
2070 }
2071
2072 if(ctx->arrays) {
2073 for(i=0; i < ctx->func->var_cnt; i++) {
2074 if(ctx->arrays[i])
2075 SafeArrayDestroy(ctx->arrays[i]);
2076 }
2077 heap_free(ctx->arrays);
2078 }
2079
2080 heap_pool_free(&ctx->heap);
2081 heap_free(ctx->args);
2082 heap_free(ctx->vars);
2083 heap_free(ctx->stack);
2084}
SafeArrayDestroy
HRESULT WINAPI SafeArrayDestroy(SAFEARRAY *psa)
Definition: safearray.c:1347
release_dynamic_vars
void release_dynamic_vars(dynamic_var_t *var)
Definition: interp.c:2044
heap_pool_free
void heap_pool_free(heap_pool_t *) DECLSPEC_HIDDEN
Definition: jsutils.c:169

Referenced by exec_script().

◆ release_val()

static void release_val ( variant_val_t *  v)
inlinestatic

Definition at line 308 of file interp.c.

309{
310 if(v->owned)
311 VariantClear(v->v);
312}

Referenced by cmp_oper(), interp_add(), interp_and(), interp_case(), interp_concat(), interp_div(), interp_eqv(), interp_exp(), interp_idiv(), interp_imp(), interp_mod(), interp_mul(), interp_neg(), interp_newenum(), interp_not(), interp_or(), interp_sub(), interp_xor(), and stack_pop_bool().

◆ stack_assume_disp()

static HRESULT stack_assume_disp ( exec_ctx_t *  ctx,
unsigned  n,
IDispatch **  disp 
)
static

Definition at line 420 of file interp.c.

421{
422 VARIANT *v = stack_top(ctx, n), *ref;
423
424 if(V_VT(v) != VT_DISPATCH) {
425 if(V_VT(v) != (VT_VARIANT|VT_BYREF)) {
426 FIXME("not supported type: %s\n", debugstr_variant(v));
427 return E_FAIL;
428 }
429
430 ref = V_VARIANTREF(v);
431 if(V_VT(ref) != VT_DISPATCH) {
432 FIXME("not disp %s\n", debugstr_variant(ref));
433 return E_FAIL;
434 }
435
436 V_VT(v) = VT_DISPATCH;
437 V_DISPATCH(v) = V_DISPATCH(ref);
438 if(V_DISPATCH(v))
439 IDispatch_AddRef(V_DISPATCH(v));
440 }
441
442 if(disp)
443 *disp = V_DISPATCH(v);
444 return S_OK;
445}

Referenced by interp_assign_member(), interp_set_ident(), and interp_set_member().

◆ stack_assume_val()

static HRESULT stack_assume_val ( exec_ctx_t *  ctx,
unsigned  n 
)
static

Definition at line 334 of file interp.c.

335{
336 VARIANT *v = stack_top(ctx, n);
337 HRESULT hres;
338
339 if(V_VT(v) == (VT_BYREF|VT_VARIANT)) {
340 VARIANT *ref = V_VARIANTREF(v);
341
342 V_VT(v) = VT_EMPTY;
343 hres = VariantCopy(v, ref);
344 if(FAILED(hres))
345 return hres;
346 }
347
348 if(V_VT(v) == VT_DISPATCH) {
349 IDispatch *disp;
350
351 disp = V_DISPATCH(v);
352 hres = get_disp_value(ctx->script, disp, v);
353 if(disp)
354 IDispatch_Release(disp);
355 if(FAILED(hres))
356 return hres;
357 }
358
359 return S_OK;
360}

Referenced by interp_const().

◆ stack_pop()

static VARIANT * stack_pop ( exec_ctx_t *  ctx)
inlinestatic

Definition at line 250 of file interp.c.

251{
252 assert(ctx->top);
253 return ctx->stack + --ctx->top;
254}

Referenced by interp_const(), stack_pop_deref(), stack_pop_disp(), and stack_popn().

◆ stack_pop_bool()

static int stack_pop_bool ( exec_ctx_t *  ctx,
BOOL *  b 
)
static

Definition at line 362 of file interp.c.

363{
364 variant_val_t val;
365 HRESULT hres;
366
367 hres = stack_pop_val(ctx, &val);
368 if(FAILED(hres))
369 return hres;
370
371 switch (V_VT(val.v))
372 {
373 case VT_BOOL:
374 *b = V_BOOL(val.v);
375 break;
376 case VT_NULL:
377 *b = FALSE;
378 break;
379 case VT_I2:
380 *b = V_I2(val.v);
381 break;
382 case VT_I4:
383 *b = V_I4(val.v);
384 break;
385 default:
386 FIXME("unsupported for %s\n", debugstr_variant(val.v));
387 release_val(&val);
388 return E_NOTIMPL;
389 }
390 return S_OK;
391}
VT_NULL
@ VT_NULL
Definition: compat.h:2296

Referenced by interp_jmp_false(), and interp_jmp_true().

◆ stack_pop_deref()

static void stack_pop_deref ( exec_ctx_t *  ctx,
variant_val_t *  r 
)
static

Definition at line 294 of file interp.c.

295{
296 VARIANT *v;
297
298 v = stack_pop(ctx);
299 if(V_VT(v) == (VT_BYREF|VT_VARIANT)) {
300 r->owned = FALSE;
301 r->v = V_VARIANTREF(v);
302 }else {
303 r->owned = TRUE;
304 r->v = v;
305 }
306}

Referenced by interp_newenum(), and stack_pop_val().

◆ stack_pop_disp()

static HRESULT stack_pop_disp ( exec_ctx_t *  ctx,
IDispatch **  ret 
)
static

Definition at line 393 of file interp.c.

394{
395 VARIANT *v = stack_pop(ctx);
396
397 if(V_VT(v) == VT_DISPATCH) {
398 *ret = V_DISPATCH(v);
399 return S_OK;
400 }
401
402 if(V_VT(v) != (VT_VARIANT|VT_BYREF)) {
403 FIXME("not supported type: %s\n", debugstr_variant(v));
404 VariantClear(v);
405 return E_FAIL;
406 }
407
408 v = V_BYREF(v);
409 if(V_VT(v) != VT_DISPATCH) {
410 FIXME("not disp %s\n", debugstr_variant(v));
411 return E_FAIL;
412 }
413
414 if(V_DISPATCH(v))
415 IDispatch_AddRef(V_DISPATCH(v));
416 *ret = V_DISPATCH(v);
417 return S_OK;
418}

Referenced by do_mcall(), and interp_is().

◆ stack_pop_val()

static HRESULT stack_pop_val ( exec_ctx_t *  ctx,
variant_val_t *  r 
)
static

Definition at line 314 of file interp.c.

315{
316 stack_pop_deref(ctx, r);
317
318 if(V_VT(r->v) == VT_DISPATCH) {
319 HRESULT hres;
320
321 hres = get_disp_value(ctx->script, V_DISPATCH(r->v), &r->store);
322 if(r->owned && V_DISPATCH(r->v))
323 IDispatch_Release(V_DISPATCH(r->v));
324 if(FAILED(hres))
325 return hres;
326
327 r->owned = TRUE;
328 r->v = &r->store;
329 }
330
331 return S_OK;
332}

Referenced by cmp_oper(), interp_add(), interp_and(), interp_case(), interp_concat(), interp_div(), interp_eqv(), interp_exp(), interp_idiv(), interp_imp(), interp_mod(), interp_mul(), interp_neg(), interp_not(), interp_or(), interp_retval(), interp_sub(), interp_val(), interp_xor(), and stack_pop_bool().

◆ stack_popn()

static void stack_popn ( exec_ctx_t *  ctx,
unsigned  n 
)
static

Definition at line 288 of file interp.c.

289{
290 while(n--)
291 VariantClear(stack_pop(ctx));
292}

Referenced by do_icall(), do_mcall(), exec_script(), interp_assign_ident(), interp_assign_member(), interp_case(), interp_enumnext(), interp_pop(), interp_set_ident(), interp_set_member(), and interp_step().

◆ stack_push()

static HRESULT stack_push ( exec_ctx_t *  ctx,
VARIANT *  v 
)
static

Definition at line 262 of file interp.c.

263{
264 if(ctx->stack_size == ctx->top) {
265 VARIANT *new_stack;
266
267 new_stack = heap_realloc(ctx->stack, ctx->stack_size*2*sizeof(*ctx->stack));
268 if(!new_stack) {
269 VariantClear(v);
270 return E_OUTOFMEMORY;
271 }
272
273 ctx->stack = new_stack;
274 ctx->stack_size *= 2;
275 }
276
277 ctx->stack[ctx->top++] = *v;
278 return S_OK;
279}
heap_realloc
static void * heap_realloc(void *mem, size_t len)
Definition: appwiz.h:71

Referenced by exec_script(), interp_add(), interp_and(), interp_bool(), interp_concat(), interp_div(), interp_double(), interp_empty(), interp_equal(), interp_eqv(), interp_exp(), interp_gt(), interp_gteq(), interp_hres(), interp_icall(), interp_idiv(), interp_imp(), interp_int(), interp_is(), interp_lt(), interp_lteq(), interp_mcall(), interp_me(), interp_mod(), interp_mul(), interp_neg(), interp_nequal(), interp_new(), interp_not(), interp_nothing(), interp_or(), interp_string(), interp_sub(), interp_val(), interp_xor(), and stack_push_null().

◆ stack_push_null()

static HRESULT stack_push_null ( exec_ctx_t *  ctx)
inlinestatic

Definition at line 281 of file interp.c.

282{
283 VARIANT v;
284 V_VT(&v) = VT_NULL;
285 return stack_push(ctx, &v);
286}

Referenced by interp_equal(), interp_gt(), interp_gteq(), interp_lt(), interp_lteq(), interp_nequal(), and interp_null().

◆ stack_top()

static VARIANT * stack_top ( exec_ctx_t *  ctx,
unsigned  n 
)
inlinestatic

Definition at line 256 of file interp.c.

257{
258 assert(ctx->top >= n);
259 return ctx->stack + (ctx->top-n-1);
260}

Referenced by interp_case(), interp_enumnext(), interp_incc(), interp_newenum(), interp_step(), stack_assume_disp(), and stack_assume_val().

◆ var_cmp()

static HRESULT var_cmp ( exec_ctx_t *  ctx,
VARIANT *  l,
VARIANT *  r 
)
static

Definition at line 1555 of file interp.c.

1556{
1557 TRACE("%s %s\n", debugstr_variant(l), debugstr_variant(r));
1558
1559 /* FIXME: Fix comparing string to number */
1560
1561 return VarCmp(l, r, ctx->script->lcid, 0);
1562 }

Referenced by cmp_oper(), and interp_case().

◆ vbstack_to_dp()

static void vbstack_to_dp ( exec_ctx_t *  ctx,
unsigned  arg_cnt,
BOOL  is_propput,
DISPPARAMS *  dp 
)
static

Definition at line 452 of file interp.c.

453{
454 dp->cNamedArgs = is_propput ? 1 : 0;
455 dp->cArgs = arg_cnt + dp->cNamedArgs;
456 dp->rgdispidNamedArgs = is_propput ? &propput_dispid : NULL;
457
458 if(arg_cnt) {
459 VARIANT tmp;
460 unsigned i;
461
462 assert(ctx->top >= arg_cnt);
463
464 for(i=1; i*2 <= arg_cnt; i++) {
465 tmp = ctx->stack[ctx->top-i];
466 ctx->stack[ctx->top-i] = ctx->stack[ctx->top-arg_cnt+i-1];
467 ctx->stack[ctx->top-arg_cnt+i-1] = tmp;
468 }
469
470 dp->rgvarg = ctx->stack + ctx->top-dp->cArgs;
471 }else {
472 dp->rgvarg = is_propput ? ctx->stack+ctx->top-1 : NULL;
473 }
474}

Referenced by do_icall(), do_mcall(), interp_assign_ident(), interp_assign_member(), interp_set_ident(), and interp_set_member().

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( vbscript  )

Variable Documentation

◆ op_funcs

const instr_func_t op_funcs[]
static
Initial value:
= {
#define X(x,n,a,b)
OP_LIST
}
OP_LIST
#define OP_LIST
Definition: engine.h:21

Definition at line 2032 of file interp.c.

Referenced by exec_script().

◆ op_move

const unsigned op_move[]
static
Initial value:
= {
#define X(x,n,a,b)
OP_LIST
}

Definition at line 2038 of file interp.c.

Referenced by exec_script().

◆ propput_dispid

DISPID propput_dispid = DISPID_PROPERTYPUT
static

Definition at line 27 of file interp.c.

Referenced by disp_call(), interp_enumnext(), and vbstack_to_dp().