vbscript.h File Reference

#include <stdarg.h>
#include <stdint.h>
#include "windef.h"
#include "winbase.h"
#include "ole2.h"
#include "dispex.h"
#include "activscp.h"
#include "activdbg.h"
#include "vbscript_classes.h"
#include "vbscript_defs.h"
#include "wine/heap.h"
#include "wine/list.h"

Include dependency graph for vbscript.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	heap_pool_t
struct	named_item_t
struct	array_desc_t
struct	vbdisp_prop_desc_t
struct	vbdisp_funcprop_desc_t
struct	_class_desc_t
struct	_vbdisp_t
struct	ScriptDisp
struct	BuiltinDisp
struct	_dynamic_var_t
struct	_script_ctx_t
union	instr_arg_t
struct	instr_t
struct	arg_desc_t
struct	var_desc_t
struct	_function_t
struct	_vbscode_t

Macros
#define	COBJMACROS
#define	OP_LIST
#define	X(x, n, a, b)   OP_##x,
#define	FACILITY_VBS   0xa
#define	MAKE_VBSERROR(code)   MAKE_HRESULT(SEVERITY_ERROR, FACILITY_VBS, code)
#define	VBSCRIPT_BUILD_VERSION   16978
#define	VBSCRIPT_MAJOR_VERSION   5
#define	VBSCRIPT_MINOR_VERSION   8

Typedefs
typedef struct _function_t	function_t
typedef struct _vbscode_t	vbscode_t
typedef struct _script_ctx_t	script_ctx_t
typedef struct _vbdisp_t	vbdisp_t
typedef struct named_item_t	named_item_t
typedef struct _class_desc_t	class_desc_t
typedef struct _ident_map_t	ident_map_t
typedef struct _builtin_prop_t	builtin_prop_t
typedef struct _dynamic_var_t	dynamic_var_t

Enumerations
enum	vbdisp_invoke_type_t { VBDISP_CALLGET , VBDISP_LET , VBDISP_SET , VBDISP_ANY }
enum	instr_arg_type_t {   ARG_NONE = 0 , ARG_ADDR , ARG_BSTR , ARG_DBL ,   ARG_FUNC , ARG_INT , ARG_STR , ARG_UINT ,   ARG_NONE = 0 , ARG_STR , ARG_BSTR , ARG_INT ,   ARG_UINT , ARG_ADDR , ARG_DOUBLE }
enum	vbsop_t { OP_LAST }
enum	function_type_t {   FUNC_GLOBAL , FUNC_FUNCTION , FUNC_SUB , FUNC_PROPGET ,   FUNC_PROPLET , FUNC_PROPSET , FUNC_DEFGET }

Functions
void	heap_pool_init (heap_pool_t *) DECLSPEC_HIDDEN
void *	heap_pool_alloc (heap_pool_t *, size_t) __WINE_ALLOC_SIZE(2) DECLSPEC_HIDDEN
void *	heap_pool_grow (heap_pool_t *, void *, DWORD, DWORD) DECLSPEC_HIDDEN
void	heap_pool_clear (heap_pool_t *) DECLSPEC_HIDDEN
void	heap_pool_free (heap_pool_t *) DECLSPEC_HIDDEN
heap_pool_t *	heap_pool_mark (heap_pool_t *) DECLSPEC_HIDDEN
HRESULT	create_vbdisp (const class_desc_t *, vbdisp_t **) DECLSPEC_HIDDEN
HRESULT	disp_get_id (IDispatch *, BSTR, vbdisp_invoke_type_t, BOOL, DISPID *) DECLSPEC_HIDDEN
HRESULT	vbdisp_get_id (vbdisp_t *, BSTR, vbdisp_invoke_type_t, BOOL, DISPID *) DECLSPEC_HIDDEN
HRESULT	disp_call (script_ctx_t *, IDispatch *, DISPID, DISPPARAMS *, VARIANT *) DECLSPEC_HIDDEN
HRESULT	disp_propput (script_ctx_t *, IDispatch *, DISPID, WORD, DISPPARAMS *) DECLSPEC_HIDDEN
HRESULT	get_disp_value (script_ctx_t *, IDispatch *, VARIANT *) DECLSPEC_HIDDEN
void	collect_objects (script_ctx_t *) DECLSPEC_HIDDEN
HRESULT	create_script_disp (script_ctx_t *, ScriptDisp **) DECLSPEC_HIDDEN
HRESULT	to_int (VARIANT *, int *) DECLSPEC_HIDDEN
static unsigned	arg_cnt (const DISPPARAMS *dp)
static VARIANT *	get_arg (DISPPARAMS *dp, DWORD i)
HRESULT	init_global (script_ctx_t *) DECLSPEC_HIDDEN
HRESULT	init_err (script_ctx_t *) DECLSPEC_HIDDEN
IUnknown *	create_ax_site (script_ctx_t *) DECLSPEC_HIDDEN
void	release_vbscode (vbscode_t *) DECLSPEC_HIDDEN
HRESULT	compile_script (script_ctx_t *, const WCHAR *, const WCHAR *, DWORD, vbscode_t **) DECLSPEC_HIDDEN
HRESULT	compile_procedure (script_ctx_t *, const WCHAR *, const WCHAR *, DWORD, class_desc_t **) DECLSPEC_HIDDEN
HRESULT	exec_script (script_ctx_t *, BOOL, function_t *, vbdisp_t *, DISPPARAMS *, VARIANT *) DECLSPEC_HIDDEN
void	release_dynamic_vars (dynamic_var_t *) DECLSPEC_HIDDEN
IDispatch *	lookup_named_item (script_ctx_t *, const WCHAR *, unsigned) DECLSPEC_HIDDEN
void	clear_ei (EXCEPINFO *) DECLSPEC_HIDDEN
HRESULT	report_script_error (script_ctx_t *) DECLSPEC_HIDDEN
void	detach_global_objects (script_ctx_t *) DECLSPEC_HIDDEN
HRESULT	get_builtin_id (BuiltinDisp *, const WCHAR *, DISPID *) DECLSPEC_HIDDEN
void	release_regexp_typelib (void) DECLSPEC_HIDDEN
static BOOL	is_int32 (double d)
HRESULT	create_regexp (IDispatch **) DECLSPEC_HIDDEN
HRESULT	map_hres (HRESULT) DECLSPEC_HIDDEN
HRESULT	create_safearray_iter (SAFEARRAY *sa, IEnumVARIANT **ev) DECLSPEC_HIDDEN
HRESULT WINAPI	VBScriptFactory_CreateInstance (IClassFactory *, IUnknown *, REFIID, void **) DECLSPEC_HIDDEN
HRESULT WINAPI	VBScriptRegExpFactory_CreateInstance (IClassFactory *, IUnknown *, REFIID, void **) DECLSPEC_HIDDEN
BSTR	get_vbscript_string (int) DECLSPEC_HIDDEN
BSTR	get_vbscript_error_string (HRESULT) DECLSPEC_HIDDEN
static LPWSTR	heap_strdupW (LPCWSTR str)

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 24 of file vbscript.h.

FACILITY_VBS

#define FACILITY_VBS   0xa

Definition at line 378 of file vbscript.h.

MAKE_VBSERROR

#define MAKE_VBSERROR

(

code

)

MAKE_HRESULT(SEVERITY_ERROR, FACILITY_VBS, code)

Definition at line 379 of file vbscript.h.

OP_LIST

#define OP_LIST

Definition at line 222 of file vbscript.h.

VBSCRIPT_BUILD_VERSION

#define VBSCRIPT_BUILD_VERSION   16978

Definition at line 403 of file vbscript.h.

VBSCRIPT_MAJOR_VERSION

#define VBSCRIPT_MAJOR_VERSION   5

Definition at line 404 of file vbscript.h.

VBSCRIPT_MINOR_VERSION

#define VBSCRIPT_MINOR_VERSION   8

Definition at line 405 of file vbscript.h.

X

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

Definition at line 282 of file vbscript.h.

Typedef Documentation

builtin_prop_t

typedef struct _builtin_prop_t builtin_prop_t

Definition at line 141 of file vbscript.h.

class_desc_t

typedef struct _class_desc_t class_desc_t

dynamic_var_t

typedef struct _dynamic_var_t dynamic_var_t

function_t

typedef struct _function_t function_t

Definition at line 58 of file vbscript.h.

ident_map_t

typedef struct _ident_map_t ident_map_t

Definition at line 128 of file vbscript.h.

named_item_t

typedef struct named_item_t named_item_t

script_ctx_t

typedef struct _script_ctx_t script_ctx_t

Definition at line 60 of file vbscript.h.

vbdisp_t

typedef struct _vbdisp_t vbdisp_t

Definition at line 61 of file vbscript.h.

vbscode_t

typedef struct _vbscode_t vbscode_t

Definition at line 59 of file vbscript.h.

Enumeration Type Documentation

function_type_t

enum function_type_t

Enumerator
FUNC_GLOBAL
FUNC_FUNCTION
FUNC_SUB
FUNC_PROPGET
FUNC_PROPLET
FUNC_PROPSET
FUNC_DEFGET

Definition at line 307 of file vbscript.h.

             {
    FUNC_GLOBAL,
    FUNC_FUNCTION,
    FUNC_SUB,
    FUNC_PROPGET,
    FUNC_PROPLET,
    FUNC_PROPSET,
    FUNC_DEFGET
} function_type_t;

instr_arg_type_t

enum instr_arg_type_t

Enumerator
ARG_NONE
ARG_ADDR
ARG_BSTR
ARG_DBL
ARG_FUNC
ARG_INT
ARG_STR
ARG_UINT
ARG_NONE
ARG_STR
ARG_BSTR
ARG_INT
ARG_UINT
ARG_ADDR
ARG_DOUBLE

Definition at line 212 of file vbscript.h.

             {
    ARG_NONE = 0,
    ARG_STR,
    ARG_BSTR,
    ARG_INT,
    ARG_UINT,
    ARG_ADDR,
    ARG_DOUBLE
} instr_arg_type_t;

vbdisp_invoke_type_t

enum vbdisp_invoke_type_t

Enumerator
VBDISP_CALLGET
VBDISP_LET
VBDISP_SET
VBDISP_ANY

Definition at line 71 of file vbscript.h.

             {
    VBDISP_CALLGET,
    VBDISP_LET,
    VBDISP_SET,
    VBDISP_ANY
} vbdisp_invoke_type_t;

vbsop_t

enum vbsop_t

Enumerator
OP_LAST

Definition at line 281 of file vbscript.h.

             {
#define X(x,n,a,b) OP_##x,
OP_LIST
#undef X
    OP_LAST
} vbsop_t;

Function Documentation

arg_cnt()

static unsigned arg_cnt ( const DISPPARAMS *  dp )

inlinestatic

Definition at line 162 of file vbscript.h.

{
    return dp->cArgs - dp->cNamedArgs;
}

Referenced by array_access(), assign_ident(), Builtin_Invoke(), cf2_interpT2CharString(), compile_args(), compile_assign_expression(), compile_call_expression(), compile_member_expression(), compile_new_expression(), do_icall(), do_mcall(), exec_script(), interp_assign_ident(), interp_assign_member(), interp_set_ident(), interp_set_member(), invoke_variant_prop(), invoke_vbdisp(), parse_arguments(), and vbstack_to_dp().

clear_ei()

void clear_ei

(

EXCEPINFO *

ei

)

Definition at line 242 of file interp.c.

{
    SysFreeString(ei->bstrSource);
    SysFreeString(ei->bstrDescription);
    SysFreeString(ei->bstrHelpFile);
    memset(ei, 0, sizeof(*ei));
}

Referenced by exec_script(), and interp_errmode().

collect_objects()

void collect_objects

(

script_ctx_t *

ctx

)

Definition at line 835 of file vbdisp.c.

{
    vbdisp_t *iter, *iter2;
 
    LIST_FOR_EACH_ENTRY_SAFE(iter, iter2, &ctx->objects, vbdisp_t, entry)
        run_terminator(iter);
 
    while(!list_empty(&ctx->objects)) {
        iter = LIST_ENTRY(list_head(&ctx->objects), vbdisp_t, entry);
 
        IDispatchEx_AddRef(&iter->IDispatchEx_iface);
        clean_props(iter);
        iter->desc = NULL;
        list_remove(&iter->entry);
        list_init(&iter->entry);
        IDispatchEx_Release(&iter->IDispatchEx_iface);
    }
}

compile_procedure()

HRESULT compile_procedure	(	script_ctx_t *	script,
		const WCHAR *	src,
		const WCHAR *	delimiter,
		DWORD	flags,
		class_desc_t **	ret
	)

Definition at line 1930 of file compile.c.

{
    class_desc_t *desc;
    vbscode_t *code;
    HRESULT hres;
 
    hres = compile_script(script, src, delimiter, flags, &code);
    if(FAILED(hres))
        return hres;
 
    if(!(desc = compiler_alloc_zero(code, sizeof(*desc))))
        return E_OUTOFMEMORY;
    if(!(desc->funcs = compiler_alloc_zero(code, sizeof(*desc->funcs))))
        return E_OUTOFMEMORY;
 
    desc->ctx = script;
    desc->func_cnt = 1;
    desc->funcs->entries[VBDISP_CALLGET] = &code->main_code;
 
    desc->next = script->procs;
    script->procs = desc;
 
    *ret = desc;
    return S_OK;
}

Referenced by VBScriptParseProcedure_ParseProcedureText().

compile_script()

HRESULT compile_script	(	script_ctx_t *	script,
		const WCHAR *	src,
		const WCHAR *	delimiter,
		DWORD	flags,
		vbscode_t **	ret
	)

Definition at line 1828 of file compile.c.

{
    function_t *new_func;
    function_decl_t *func_decl;
    class_decl_t *class_decl;
    compile_ctx_t ctx;
    vbscode_t *code;
    HRESULT hres;
 
    if (!src) src = L"";
 
    hres = parse_script(&ctx.parser, src, delimiter, flags);
    if(FAILED(hres))
        return compile_error(script, hres);
 
    code = ctx.code = alloc_vbscode(&ctx, src);
    if(!ctx.code)
        return compile_error(script, E_OUTOFMEMORY);
 
    ctx.funcs = NULL;
    ctx.func_decls = NULL;
    ctx.global_vars = NULL;
    ctx.classes = NULL;
    ctx.labels = NULL;
    ctx.global_consts = NULL;
    ctx.stat_ctx = NULL;
    ctx.labels_cnt = ctx.labels_size = 0;
 
    hres = compile_func(&ctx, ctx.parser.stats, &ctx.code->main_code);
    if(FAILED(hres)) {
        release_compiler(&ctx);
        return compile_error(script, hres);
    }
 
    ctx.global_consts = ctx.const_decls;
 
    for(func_decl = ctx.func_decls; func_decl; func_decl = func_decl->next) {
        hres = create_function(&ctx, func_decl, &new_func);
        if(FAILED(hres)) {
            release_compiler(&ctx);
            return compile_error(script, hres);
        }
 
        new_func->next = ctx.funcs;
        ctx.funcs = new_func;
    }
 
    for(class_decl = ctx.parser.class_decls; class_decl; class_decl = class_decl->next) {
        hres = compile_class(&ctx, class_decl);
        if(FAILED(hres)) {
            release_compiler(&ctx);
            return compile_error(script, hres);
        }
    }
 
    hres = check_script_collisions(&ctx, script);
    if(FAILED(hres)) {
        release_compiler(&ctx);
        return compile_error(script, hres);
    }
 
    if(ctx.global_vars) {
        dynamic_var_t *var;
 
        for(var = ctx.global_vars; var->next; var = var->next);
 
        var->next = script->global_vars;
        script->global_vars = ctx.global_vars;
    }
 
    if(ctx.funcs) {
        for(new_func = ctx.funcs; new_func->next; new_func = new_func->next);
 
        new_func->next = script->global_funcs;
        script->global_funcs = ctx.funcs;
    }
 
    if(ctx.classes) {
        class_desc_t *class = ctx.classes;
 
        while(1) {
            class->ctx = script;
            if(!class->next)
                break;
            class = class->next;
        }
 
        class->next = script->classes;
        script->classes = ctx.classes;
    }
 
    if(TRACE_ON(vbscript_disas))
        dump_code(&ctx);
 
    ctx.code = NULL;
    release_compiler(&ctx);
 
    list_add_tail(&script->code_list, &code->entry);
    *ret = code;
    return S_OK;
}

create_ax_site()

IUnknown * create_ax_site

(

script_ctx_t *

ctx

)

Definition at line 324 of file jscript.c.

{
    IServiceProvider *sp = NULL;
    AXSite *ret;
    HRESULT hres;
 
    hres = IActiveScriptSite_QueryInterface(ctx->site, &IID_IServiceProvider, (void**)&sp);
    if(FAILED(hres)) {
        TRACE("Could not get IServiceProvider iface: %08x\n", hres);
    }
 
    ret = heap_alloc(sizeof(AXSite));
    if(!ret) {
        IServiceProvider_Release(sp);
        return NULL;
    }
 
    ret->IServiceProvider_iface.lpVtbl = &AXSiteVtbl;
    ret->ref = 1;
    ret->sp = sp;
 
    return (IUnknown*)&ret->IServiceProvider_iface;
}

Referenced by create_activex_object(), and set_object_site().

create_regexp()

HRESULT create_regexp

(

IDispatch **

ret

)

Definition at line 1596 of file vbregexp.c.

{
    RegExp2 *regexp;
    HRESULT hres;
 
    hres = init_regexp_typeinfo(RegExp2_tid);
    if(FAILED(hres))
        return hres;
 
    regexp = heap_alloc_zero(sizeof(*regexp));
    if(!regexp)
        return E_OUTOFMEMORY;
 
    regexp->IRegExp2_iface.lpVtbl = &RegExp2Vtbl;
    regexp->IRegExp_iface.lpVtbl = &RegExpVtbl;
    regexp->ref = 1;
    heap_pool_init(&regexp->pool);
 
    *ret = (IDispatch*)&regexp->IRegExp2_iface;
    return S_OK;
}

Referenced by VBScriptRegExpFactory_CreateInstance().

create_safearray_iter()

HRESULT create_safearray_iter	(	SAFEARRAY *	sa,
		IEnumVARIANT **	ev
	)

Definition at line 163 of file utils.c.

{
    safearray_iter *iter;
    HRESULT hres;
 
    if(sa && !(sa->fFeatures & FADF_VARIANT)) {
        FIXME("enumeration not supported: %x\n", sa->fFeatures);
        return E_NOTIMPL;
    }
 
    iter = heap_alloc(sizeof(*iter));
    if(!iter)
        return E_OUTOFMEMORY;
 
    if(sa) {
        hres = SafeArrayLock(sa);
        if(FAILED(hres)) {
            heap_free(iter);
            return hres;
        }
    }
 
    iter->IEnumVARIANT_iface.lpVtbl = &safearray_iter_EnumVARIANTVtbl;
    iter->ref = 1;
    iter->sa = sa;
    iter->i = 0;
    iter->size = get_safearray_size(sa);
 
    *ev = &iter->IEnumVARIANT_iface;
    return S_OK;
}

Referenced by interp_newenum().

create_script_disp()

HRESULT create_script_disp	(	script_ctx_t *	ctx,
		ScriptDisp **	ret
	)

Definition at line 819 of file vbdisp.c.

{
    ScriptDisp *script_disp;
 
    script_disp = heap_alloc_zero(sizeof(*script_disp));
    if(!script_disp)
        return E_OUTOFMEMORY;
 
    script_disp->IDispatchEx_iface.lpVtbl = &ScriptDispVtbl;
    script_disp->ref = 1;
    script_disp->ctx = ctx;
 
    *ret = script_disp;
    return S_OK;
}

Referenced by VBScript_SetScriptSite().

create_vbdisp()

HRESULT create_vbdisp	(	const class_desc_t *	desc,
		vbdisp_t **	ret
	)

Definition at line 470 of file vbdisp.c.

{
    vbdisp_t *vbdisp;
    HRESULT hres = S_OK;
 
    vbdisp = heap_alloc_zero( FIELD_OFFSET( vbdisp_t, props[desc->prop_cnt] ));
    if(!vbdisp)
        return E_OUTOFMEMORY;
 
    vbdisp->IDispatchEx_iface.lpVtbl = &DispatchExVtbl;
    vbdisp->ref = 1;
    vbdisp->desc = desc;
 
    list_add_tail(&desc->ctx->objects, &vbdisp->entry);
 
    if(desc->array_cnt) {
        vbdisp->arrays = heap_alloc_zero(desc->array_cnt * sizeof(*vbdisp->arrays));
        if(vbdisp->arrays) {
            unsigned i, j;
 
            for(i=0; i < desc->array_cnt; i++) {
                if(!desc->array_descs[i].dim_cnt)
                    continue;
 
                vbdisp->arrays[i] = SafeArrayCreate(VT_VARIANT, desc->array_descs[i].dim_cnt, desc->array_descs[i].bounds);
                if(!vbdisp->arrays[i]) {
                    hres = E_OUTOFMEMORY;
                    break;
                }
            }
 
            if(SUCCEEDED(hres)) {
                for(i=0, j=0; i < desc->prop_cnt; i++) {
                    if(desc->props[i].is_array) {
                        V_VT(vbdisp->props+i) = VT_ARRAY|VT_BYREF|VT_VARIANT;
                        V_ARRAYREF(vbdisp->props+i) = vbdisp->arrays + j++;
                    }
                }
            }
        }else {
            hres = E_OUTOFMEMORY;
        }
    }
 
    if(SUCCEEDED(hres) && desc->class_initialize_id) {
        DISPPARAMS dp = {0};
        hres = exec_script(desc->ctx, FALSE, desc->funcs[desc->class_initialize_id].entries[VBDISP_CALLGET],
                           vbdisp, &dp, NULL);
    }
 
    if(FAILED(hres)) {
        IDispatchEx_Release(&vbdisp->IDispatchEx_iface);
        return hres;
    }
 
    *ret = vbdisp;
    return S_OK;
}

Referenced by interp_new(), and VBScriptParseProcedure_ParseProcedureText().

detach_global_objects()

void detach_global_objects

(

script_ctx_t *

ctx

)

Definition at line 2855 of file global.c.

{
    if(ctx->err_obj) {
        ctx->err_obj->ctx = NULL;
        IDispatch_Release(&ctx->err_obj->IDispatch_iface);
        ctx->err_obj = NULL;
    }
 
    if(ctx->global_obj) {
        ctx->global_obj->ctx = NULL;
        IDispatch_Release(&ctx->global_obj->IDispatch_iface);
        ctx->global_obj = NULL;
    }
}

Referenced by release_script().

disp_call()

HRESULT disp_call	(	script_ctx_t *	ctx,
		IDispatch *	disp,
		DISPID	id,
		DISPPARAMS *	dp,
		VARIANT *	retv
	)

Definition at line 938 of file vbdisp.c.

{
    const WORD flags = DISPATCH_METHOD|(retv ? DISPATCH_PROPERTYGET : 0);
    IDispatchEx *dispex;
    vbdisp_t *vbdisp;
    EXCEPINFO ei;
    HRESULT hres;
 
    memset(&ei, 0, sizeof(ei));
    if(retv)
        V_VT(retv) = VT_EMPTY;
 
    vbdisp = unsafe_impl_from_IDispatch(disp);
    if(vbdisp && vbdisp->desc && vbdisp->desc->ctx == ctx)
        return invoke_vbdisp(vbdisp, id, flags, FALSE, dp, retv);
 
    hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
    if(FAILED(hres)) {
        UINT err = 0;
 
        TRACE("using IDispatch\n");
        return IDispatch_Invoke(disp, id, &IID_NULL, ctx->lcid, flags, dp, retv, &ei, &err);
    }
 
    hres = IDispatchEx_InvokeEx(dispex, id, ctx->lcid, flags, dp, retv, &ei, NULL /* CALLER_FIXME */);
    IDispatchEx_Release(dispex);
    return hres;
}

Referenced by get_disp_value().

disp_get_id()

HRESULT disp_get_id	(	IDispatch *	disp,
		BSTR	name,
		vbdisp_invoke_type_t	invoke_type,
		BOOL	search_private,
		DISPID *	id
	)

Definition at line 854 of file vbdisp.c.

{
    IDispatchEx *dispex;
    vbdisp_t *vbdisp;
    HRESULT hres;
 
    vbdisp = unsafe_impl_from_IDispatch(disp);
    if(vbdisp)
        return vbdisp_get_id(vbdisp, name, invoke_type, search_private, id);
 
    hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
    if(FAILED(hres)) {
        TRACE("using IDispatch\n");
        return IDispatch_GetIDsOfNames(disp, &IID_NULL, &name, 1, 0, id);
    }
 
    hres = IDispatchEx_GetDispID(dispex, name, fdexNameCaseInsensitive, id);
    IDispatchEx_Release(dispex);
    return hres;
}

disp_propput()

HRESULT disp_propput	(	script_ctx_t *	ctx,
		IDispatch *	disp,
		DISPID	id,
		WORD	flags,
		DISPPARAMS *	dp
	)

Definition at line 975 of file vbdisp.c.

{
    IDispatchEx *dispex;
    vbdisp_t *vbdisp;
    EXCEPINFO ei = {0};
    HRESULT hres;
 
    vbdisp = unsafe_impl_from_IDispatch(disp);
    if(vbdisp && vbdisp->desc && vbdisp->desc->ctx == ctx)
        return invoke_vbdisp(vbdisp, id, flags, FALSE, dp, NULL);
 
    hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
    if(SUCCEEDED(hres)) {
        hres = IDispatchEx_InvokeEx(dispex, id, ctx->lcid, flags, dp, NULL, &ei, NULL /* FIXME! */);
        IDispatchEx_Release(dispex);
    }else {
        ULONG err = 0;
 
        TRACE("using IDispatch\n");
        hres = IDispatch_Invoke(disp, id, &IID_NULL, ctx->lcid, flags, dp, NULL, &ei, &err);
    }
 
    return hres;
}

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.

{
    exec_ctx_t exec = {func->code_ctx};
    vbsop_t op;
    HRESULT hres = S_OK;
 
    exec.code = func->code_ctx;
 
    if(dp ? func->arg_cnt != arg_cnt(dp) : func->arg_cnt) {
        FIXME("wrong arg_cnt %d, expected %d\n", dp ? arg_cnt(dp) : 0, func->arg_cnt);
        return E_FAIL;
    }
 
    heap_pool_init(&exec.heap);
 
    if(func->arg_cnt) {
        VARIANT *v;
        unsigned i;
 
        exec.args = heap_alloc_zero(func->arg_cnt * sizeof(VARIANT));
        if(!exec.args) {
            release_exec(&exec);
            return E_OUTOFMEMORY;
        }
 
        for(i=0; i < func->arg_cnt; i++) {
            v = get_arg(dp, i);
            if(V_VT(v) == (VT_VARIANT|VT_BYREF)) {
                if(func->args[i].by_ref)
                    exec.args[i] = *v;
                else
                    hres = VariantCopyInd(exec.args+i, V_VARIANTREF(v));
            }else {
                hres = VariantCopyInd(exec.args+i, v);
            }
            if(FAILED(hres)) {
                release_exec(&exec);
                return hres;
            }
        }
    }else {
        exec.args = NULL;
    }
 
    if(func->var_cnt) {
        exec.vars = heap_alloc_zero(func->var_cnt * sizeof(VARIANT));
        if(!exec.vars) {
            release_exec(&exec);
            return E_OUTOFMEMORY;
        }
    }else {
        exec.vars = NULL;
    }
 
    exec.stack_size = 16;
    exec.top = 0;
    exec.stack = heap_alloc(exec.stack_size * sizeof(VARIANT));
    if(!exec.stack) {
        release_exec(&exec);
        return E_OUTOFMEMORY;
    }
 
    if(extern_caller)
        IActiveScriptSite_OnEnterScript(ctx->site);
 
    if(vbthis) {
        exec.this_obj = (IDispatch*)&vbthis->IDispatchEx_iface;
        exec.vbthis = vbthis;
    }else if (ctx->host_global) {
        exec.this_obj = ctx->host_global;
    }else {
        exec.this_obj = (IDispatch*)&ctx->script_obj->IDispatchEx_iface;
    }
    IDispatch_AddRef(exec.this_obj);
 
    exec.instr = exec.code->instrs + func->code_off;
    exec.script = ctx;
    exec.func = func;
 
    while(exec.instr) {
        op = exec.instr->op;
        hres = op_funcs[op](&exec);
        if(FAILED(hres)) {
            if(hres != SCRIPT_E_RECORDED) {
                clear_ei(&ctx->ei);
 
                ctx->ei.scode = hres = map_hres(hres);
                ctx->ei.bstrSource = get_vbscript_string(VBS_RUNTIME_ERROR);
                ctx->ei.bstrDescription = get_vbscript_error_string(hres);
            }else {
                hres = ctx->ei.scode;
            }
 
            if(exec.resume_next) {
                unsigned stack_off;
 
                WARN("Failed %08x in resume next mode\n", hres);
 
                /*
                 * Unwinding here is simple. We need to find the next OP_catch, which contains
                 * information about expected stack size and jump offset on error. Generated
                 * bytecode needs to guarantee, that simple jump and stack adjustment will
                 * guarantee proper execution continuation.
                 */
                while((++exec.instr)->op != OP_catch);
 
                TRACE("unwind jmp %d stack_off %d\n", exec.instr->arg1.uint, exec.instr->arg2.uint);
 
                stack_off = exec.instr->arg2.uint;
                instr_jmp(&exec, exec.instr->arg1.uint);
 
                if(exec.top > stack_off) {
                    stack_popn(&exec, exec.top-stack_off);
                }else if(exec.top < stack_off) {
                    VARIANT v;
 
                    V_VT(&v) = VT_EMPTY;
                    while(exec.top < stack_off) {
                        hres = stack_push(&exec, &v);
                        if(FAILED(hres))
                            break;
                    }
                }
 
                continue;
            }else {
                WARN("Failed %08x\n", hres);
                stack_popn(&exec, exec.top);
                break;
            }
        }
 
        exec.instr += op_move[op];
    }
 
    assert(!exec.top);
 
    if(extern_caller) {
        IActiveScriptSite_OnLeaveScript(ctx->site);
        if(FAILED(hres)) {
            if(!ctx->ei.scode)
                ctx->ei.scode = hres;
            hres = report_script_error(ctx);
        }
    }
 
    if(SUCCEEDED(hres) && res) {
        *res = exec.ret_val;
        V_VT(&exec.ret_val) = VT_EMPTY;
    }
 
    release_exec(&exec);
    return hres;
}

Referenced by do_icall().

get_arg()

static VARIANT * get_arg ( DISPPARAMS *  dp, DWORD  i  )

inlinestatic

Definition at line 167 of file vbscript.h.

{
    return dp->rgvarg + dp->cArgs-i-1;
}

get_builtin_id()

HRESULT get_builtin_id	(	BuiltinDisp *	disp,
		const WCHAR *	name,
		DISPID *	id
	)

Definition at line 128 of file global.c.

{
    size_t min = 1, max = disp->member_cnt - 1, i;
    int r;
 
    while(min <= max) {
        i = (min + max) / 2;
        r = wcsicmp(disp->members[i].name, name);
        if(!r) {
            *id = i;
            return S_OK;
        }
        if(r < 0)
            min = i+1;
        else
            max = i-1;
    }
 
    return DISP_E_MEMBERNOTFOUND;
 
}

Referenced by Builtin_GetIDsOfNames().

get_disp_value()

HRESULT get_disp_value	(	script_ctx_t *	ctx,
		IDispatch *	disp,
		VARIANT *	v
	)

Definition at line 967 of file vbdisp.c.

{
    DISPPARAMS dp = {NULL};
    if(!disp)
        return MAKE_VBSERROR(VBSE_OBJECT_VARIABLE_NOT_SET);
    return disp_call(ctx, disp, DISPID_VALUE, &dp, v);
}

Referenced by assign_value(), get_propput_arg(), stack_assume_val(), and stack_pop_val().

get_vbscript_error_string()

BSTR get_vbscript_error_string

(

HRESULT

error

)

Definition at line 45 of file vbscript_main.c.

{
    BSTR ret;
    if(HRESULT_FACILITY(error) != FACILITY_VBS || !(ret = get_vbscript_string(HRESULT_CODE(error))))
        ret = get_vbscript_string(VBS_UNKNOWN_RUNTIME_ERROR);
    return ret;
}

Referenced by compile_error(), Err_Raise(), and exec_script().

get_vbscript_string()

BSTR get_vbscript_string

(

int

id

)

Definition at line 38 of file vbscript_main.c.

{
    WCHAR buf[512];
    if(!LoadStringW(vbscript_hinstance, id, buf, ARRAY_SIZE(buf))) return NULL;
    return SysAllocString(buf);
}

Referenced by compile_error(), Err_Raise(), exec_script(), and get_vbscript_error_string().

heap_pool_alloc()

void * heap_pool_alloc	(	heap_pool_t *	heap,
		size_t	size
	)

Definition at line 67 of file vbscript_main.c.

{
    struct list *list;
    void *tmp;
 
    size = (size+3)&~3;
 
    if(!heap->block_cnt) {
        if(!heap->blocks) {
            heap->blocks = heap_alloc(sizeof(void*));
            if(!heap->blocks)
                return NULL;
        }
 
        tmp = heap_alloc(block_size(0));
        if(!tmp)
            return NULL;
 
        heap->blocks[0] = tmp;
        heap->block_cnt = 1;
    }
 
    if(heap->offset + size <= block_size(heap->last_block)) {
        tmp = ((BYTE*)heap->blocks[heap->last_block])+heap->offset;
        heap->offset += size;
        return tmp;
    }
 
    if(size <= block_size(heap->last_block+1)) {
        if(heap->last_block+1 == heap->block_cnt) {
            tmp = heap_realloc(heap->blocks, (heap->block_cnt+1)*sizeof(void*));
            if(!tmp)
                return NULL;
 
            heap->blocks = tmp;
            heap->blocks[heap->block_cnt] = heap_alloc(block_size(heap->block_cnt));
            if(!heap->blocks[heap->block_cnt])
                return NULL;
 
            heap->block_cnt++;
        }
 
        heap->last_block++;
        heap->offset = size;
        return heap->blocks[heap->last_block];
    }
 
    list = heap_alloc(size + sizeof(struct list));
    if(!list)
        return NULL;
 
    list_add_head(&heap->custom_blocks, list);
    return list+1;
}

Referenced by heap_pool_grow().

heap_pool_clear()

void heap_pool_clear

(

heap_pool_t *

heap

)

Definition at line 146 of file jsutils.c.

{
    struct list *tmp;
 
    if(!heap)
        return;
 
    while((tmp = list_head(&heap->custom_blocks))) {
        list_remove(tmp);
        heap_free(tmp);
    }
 
    if(WARN_ON(heap)) {
        DWORD i;
 
        for(i=0; i < heap->block_cnt; i++)
            memset(heap->blocks[i], ARENA_FREE_FILLER, block_size(i));
    }
 
    heap->last_block = heap->offset = 0;
    heap->mark = FALSE;
}

Referenced by heap_pool_free().

heap_pool_free()

void heap_pool_free

(

heap_pool_t *

heap

)

Definition at line 169 of file jsutils.c.

{
    DWORD i;
 
    heap_pool_clear(heap);
 
    for(i=0; i < heap->block_cnt; i++)
        heap_free(heap->blocks[i]);
    heap_free(heap->blocks);
 
    heap_pool_init(heap);
}

heap_pool_grow()

void * heap_pool_grow	(	heap_pool_t *	heap,
		void *	mem,
		DWORD	size,
		DWORD	inc
	)

Definition at line 130 of file jsutils.c.

{
    void *ret;
 
    if(mem == (BYTE*)heap->blocks[heap->last_block] + heap->offset-size
       && heap->offset+inc < block_size(heap->last_block)) {
        heap->offset += inc;
        return mem;
    }
 
    ret = heap_pool_alloc(heap, size+inc);
    if(ret) /* FIXME: avoid copying for custom blocks */
        memcpy(ret, mem, size);
    return ret;
}

heap_pool_init()

void heap_pool_init

(

heap_pool_t *

heap

)

Definition at line 71 of file jsutils.c.

{
    memset(heap, 0, sizeof(*heap));
    list_init(&heap->custom_blocks);
}

Referenced by heap_pool_free().

heap_pool_mark()

heap_pool_t * heap_pool_mark

(

heap_pool_t *

heap

)

Definition at line 182 of file jsutils.c.

{
    if(heap->mark)
        return NULL;
 
    heap->mark = TRUE;
    return heap;
}

heap_strdupW()

static LPWSTR heap_strdupW ( LPCWSTR  str )

inlinestatic

Definition at line 387 of file vbscript.h.

{
    LPWSTR ret = NULL;
 
    if(str) {
        DWORD size;
 
        size = (lstrlenW(str)+1)*sizeof(WCHAR);
        ret = heap_alloc(size);
        if(ret)
            memcpy(ret, str, size);
    }
 
    return ret;
}

init_err()

HRESULT init_err

(

script_ctx_t *

)

init_global()

HRESULT init_global

(

script_ctx_t *

ctx

)

Definition at line 1105 of file global.c.

{
    unsigned const_flags = ctx->version >= SCRIPTLANGUAGEVERSION_ES5 ? 0 : PROPF_WRITABLE;
    jsdisp_t *math, *object_prototype, *constr;
    HRESULT hres;
 
    if(ctx->global)
        return S_OK;
 
    hres = create_dispex(ctx, &JSGlobal_info, NULL, &ctx->global);
    if(FAILED(hres))
        return hres;
 
    hres = create_object_prototype(ctx, &object_prototype);
    if(FAILED(hres))
        return hres;
 
    hres = init_constructors(ctx, object_prototype);
    jsdisp_release(object_prototype);
    if(FAILED(hres))
        return hres;
 
    hres = create_math(ctx, &math);
    if(FAILED(hres))
        return hres;
 
    hres = jsdisp_define_data_property(ctx->global, MathW, PROPF_WRITABLE, jsval_obj(math));
    jsdisp_release(math);
    if(FAILED(hres))
        return hres;
 
    if(ctx->version >= 2) {
        jsdisp_t *json;
 
        hres = create_json(ctx, &json);
        if(FAILED(hres))
            return hres;
 
        hres = jsdisp_define_data_property(ctx->global, JSONW, PROPF_WRITABLE, jsval_obj(json));
        jsdisp_release(json);
        if(FAILED(hres))
            return hres;
    }
 
    hres = create_activex_constr(ctx, &constr);
    if(FAILED(hres))
        return hres;
 
    hres = jsdisp_define_data_property(ctx->global, ActiveXObjectW, PROPF_WRITABLE,
                                       jsval_obj(constr));
    jsdisp_release(constr);
    if(FAILED(hres))
        return hres;
 
    hres = jsdisp_define_data_property(ctx->global, undefinedW, const_flags, jsval_undefined());
    if(FAILED(hres))
        return hres;
 
    hres = jsdisp_define_data_property(ctx->global, NaNW, const_flags, jsval_number(NAN));
    if(FAILED(hres))
        return hres;
 
    hres = jsdisp_define_data_property(ctx->global, InfinityW, const_flags, jsval_number(INFINITY));
    return hres;
}

Referenced by set_ctx_site(), and VBScriptFactory_CreateInstance().

is_int32()

static BOOL is_int32 ( double  d )

inlinestatic

Definition at line 367 of file vbscript.h.

{
    return INT32_MIN <= d && d <= INT32_MAX && (double)(int)d == d;
}

lookup_named_item()

IDispatch * lookup_named_item	(	script_ctx_t *	ctx,
		const WCHAR *	name,
		unsigned	flags
	)

Definition at line 99 of file vbscript.c.

{
    named_item_t *item;
    HRESULT hres;
 
    LIST_FOR_EACH_ENTRY(item, &ctx->named_items, named_item_t, entry) {
        if((item->flags & flags) == flags && !wcsicmp(item->name, name)) {
            if(!item->disp) {
                IUnknown *unk;
 
                hres = IActiveScriptSite_GetItemInfo(ctx->site, item->name,
                                                     SCRIPTINFO_IUNKNOWN, &unk, NULL);
                if(FAILED(hres)) {
                    WARN("GetItemInfo failed: %08x\n", hres);
                    continue;
                }
 
                hres = IUnknown_QueryInterface(unk, &IID_IDispatch, (void**)&item->disp);
                IUnknown_Release(unk);
                if(FAILED(hres)) {
                    WARN("object does not implement IDispatch\n");
                    continue;
                }
            }
 
            return item->disp;
        }
    }
 
    return NULL;
}

Referenced by lookup_identifier(), and VBScriptParse_ParseScriptText().

map_hres()

HRESULT map_hres

(

HRESULT

hres

)

Definition at line 877 of file vbdisp.c.

{
    if(SUCCEEDED(hres) || HRESULT_FACILITY(hres) == FACILITY_VBS)
        return hres;
 
    switch(hres) {
    case E_NOTIMPL:                  return MAKE_VBSERROR(VBSE_ACTION_NOT_SUPPORTED);
    case E_NOINTERFACE:              return MAKE_VBSERROR(VBSE_OLE_NOT_SUPPORTED);
    case DISP_E_UNKNOWNINTERFACE:    return MAKE_VBSERROR(VBSE_OLE_NO_PROP_OR_METHOD);
    case DISP_E_MEMBERNOTFOUND:      return MAKE_VBSERROR(VBSE_OLE_NO_PROP_OR_METHOD);
    case DISP_E_PARAMNOTFOUND:       return MAKE_VBSERROR(VBSE_NAMED_PARAM_NOT_FOUND);
    case DISP_E_TYPEMISMATCH:        return MAKE_VBSERROR(VBSE_TYPE_MISMATCH);
    case DISP_E_UNKNOWNNAME:         return MAKE_VBSERROR(VBSE_OLE_NO_PROP_OR_METHOD);
    case DISP_E_NONAMEDARGS:         return MAKE_VBSERROR(VBSE_NAMED_ARGS_NOT_SUPPORTED);
    case DISP_E_BADVARTYPE:          return MAKE_VBSERROR(VBSE_INVALID_TYPELIB_VARIABLE);
    case DISP_E_OVERFLOW:            return MAKE_VBSERROR(VBSE_OVERFLOW);
    case DISP_E_BADINDEX:            return MAKE_VBSERROR(VBSE_OUT_OF_BOUNDS);
    case DISP_E_UNKNOWNLCID:         return MAKE_VBSERROR(VBSE_LOCALE_SETTING_NOT_SUPPORTED);
    case DISP_E_ARRAYISLOCKED:       return MAKE_VBSERROR(VBSE_ARRAY_LOCKED);
    case DISP_E_BADPARAMCOUNT:       return MAKE_VBSERROR(VBSE_FUNC_ARITY_MISMATCH);
    case DISP_E_PARAMNOTOPTIONAL:    return MAKE_VBSERROR(VBSE_PARAMETER_NOT_OPTIONAL);
    case DISP_E_NOTACOLLECTION:      return MAKE_VBSERROR(VBSE_NOT_ENUM);
    case TYPE_E_DLLFUNCTIONNOTFOUND: return MAKE_VBSERROR(VBSE_INVALID_DLL_FUNCTION_NAME);
    case TYPE_E_TYPEMISMATCH:        return MAKE_VBSERROR(VBSE_TYPE_MISMATCH);
    case TYPE_E_OUTOFBOUNDS:         return MAKE_VBSERROR(VBSE_OUT_OF_BOUNDS);
    case TYPE_E_IOERROR:             return MAKE_VBSERROR(VBSE_IO_ERROR);
    case TYPE_E_CANTCREATETMPFILE:   return MAKE_VBSERROR(VBSE_CANT_CREATE_TMP_FILE);
    case STG_E_FILENOTFOUND:         return MAKE_VBSERROR(VBSE_OLE_FILE_NOT_FOUND);
    case STG_E_PATHNOTFOUND:         return MAKE_VBSERROR(VBSE_PATH_NOT_FOUND);
    case STG_E_TOOMANYOPENFILES:     return MAKE_VBSERROR(VBSE_TOO_MANY_FILES);
    case STG_E_ACCESSDENIED:         return MAKE_VBSERROR(VBSE_PERMISSION_DENIED);
    case STG_E_INSUFFICIENTMEMORY:   return MAKE_VBSERROR(VBSE_OUT_OF_MEMORY);
    case STG_E_NOMOREFILES:          return MAKE_VBSERROR(VBSE_TOO_MANY_FILES);
    case STG_E_DISKISWRITEPROTECTED: return MAKE_VBSERROR(VBSE_PERMISSION_DENIED);
    case STG_E_WRITEFAULT:           return MAKE_VBSERROR(VBSE_IO_ERROR);
    case STG_E_READFAULT:            return MAKE_VBSERROR(VBSE_IO_ERROR);
    case STG_E_SHAREVIOLATION:       return MAKE_VBSERROR(VBSE_PATH_FILE_ACCESS);
    case STG_E_LOCKVIOLATION:        return MAKE_VBSERROR(VBSE_PERMISSION_DENIED);
    case STG_E_FILEALREADYEXISTS:    return MAKE_VBSERROR(VBSE_FILE_ALREADY_EXISTS);
    case STG_E_MEDIUMFULL:           return MAKE_VBSERROR(VBSE_DISK_FULL);
    case STG_E_INVALIDNAME:          return MAKE_VBSERROR(VBSE_FILE_NOT_FOUND);
    case STG_E_INUSE:                return MAKE_VBSERROR(VBSE_PERMISSION_DENIED);
    case STG_E_NOTCURRENT:           return MAKE_VBSERROR(VBSE_PERMISSION_DENIED);
    case STG_E_CANTSAVE:             return MAKE_VBSERROR(VBSE_IO_ERROR);
    case REGDB_E_CLASSNOTREG:        return MAKE_VBSERROR(VBSE_CANT_CREATE_OBJECT);
    case MK_E_UNAVAILABLE:           return MAKE_VBSERROR(VBSE_CANT_CREATE_OBJECT);
    case MK_E_INVALIDEXTENSION:      return MAKE_VBSERROR(VBSE_OLE_FILE_NOT_FOUND);
    case MK_E_CANTOPENFILE:          return MAKE_VBSERROR(VBSE_OLE_FILE_NOT_FOUND);
    case CO_E_CLASSSTRING:           return MAKE_VBSERROR(VBSE_CANT_CREATE_OBJECT);
    case CO_E_APPNOTFOUND:           return MAKE_VBSERROR(VBSE_CANT_CREATE_OBJECT);
    case CO_E_APPDIDNTREG:           return MAKE_VBSERROR(VBSE_CANT_CREATE_OBJECT);
    case E_ACCESSDENIED:             return MAKE_VBSERROR(VBSE_PERMISSION_DENIED);
    case E_OUTOFMEMORY:              return MAKE_VBSERROR(VBSE_OUT_OF_MEMORY);
    case E_INVALIDARG:               return MAKE_VBSERROR(VBSE_ILLEGAL_FUNC_CALL);
    case RPC_E_SERVER_UNAVAILABLE:   return MAKE_VBSERROR(VBSE_SERVER_NOT_FOUND);
    case CO_E_SERVER_EXEC_FAILURE:   return MAKE_VBSERROR(VBSE_CANT_CREATE_OBJECT);
    }
 
    return hres;
}

release_dynamic_vars()

void release_dynamic_vars

(

dynamic_var_t *

var

)

Definition at line 2044 of file interp.c.

{
    while(var) {
        VariantClear(&var->v);
        var = var->next;
    }
}

Referenced by release_exec(), and release_script().

release_regexp_typelib()

void release_regexp_typelib

(

void

)

Definition at line 1634 of file vbregexp.c.

{
    DWORD i;
 
    for(i=0; i<REGEXP_LAST_tid; i++) {
        if(typeinfos[i])
            ITypeInfo_Release(typeinfos[i]);
    }
    if(typelib)
        ITypeLib_Release(typelib);
}

Referenced by DllMain().

release_vbscode()

void release_vbscode

(

vbscode_t *

code

)

Definition at line 1768 of file compile.c.

{
    unsigned i;
 
    list_remove(&code->entry);
 
    for(i=0; i < code->bstr_cnt; i++)
        SysFreeString(code->bstr_pool[i]);
 
    if(code->context)
        IDispatch_Release(code->context);
    heap_pool_free(&code->heap);
 
    heap_free(code->bstr_pool);
    heap_free(code->source);
    heap_free(code->instrs);
    heap_free(code);
}

Referenced by alloc_vbscode(), destroy_script(), and release_compiler().

report_script_error()

HRESULT report_script_error

(

script_ctx_t *

ctx

)

Definition at line 315 of file vbscript.c.

{
    VBScriptError *error;
    HRESULT hres, result;
 
    if(!(error = heap_alloc(sizeof(*error))))
        return E_OUTOFMEMORY;
    error->IActiveScriptError_iface.lpVtbl = &VBScriptErrorVtbl;
 
    error->ref = 1;
    error->ei = ctx->ei;
    memset(&ctx->ei, 0, sizeof(ctx->ei));
    result = error->ei.scode;
 
    hres = IActiveScriptSite_OnScriptError(ctx->site, &error->IActiveScriptError_iface);
    IActiveScriptError_Release(&error->IActiveScriptError_iface);
    return hres == S_OK ? SCRIPT_E_REPORTED : result;
}

Referenced by compile_error(), and exec_script().

to_int()

HRESULT to_int	(	VARIANT *	v,
		int *	ret
	)

Definition at line 410 of file global.c.

{
    VARIANT r;
    HRESULT hres;
 
    V_VT(&r) = VT_EMPTY;
    hres = VariantChangeType(&r, v, 0, VT_I4);
    if(FAILED(hres))
        return hres;
 
    *ret = V_I4(&r);
    return S_OK;
}

Referenced by array_access(), Err_Raise(), Global_Chr(), Global_CLng(), Global_Hex(), Global_InStr(), Global_InStrRev(), Global_Left(), Global_Mid(), Global_MonthName(), Global_MsgBox(), Global_Oct(), Global_RGB(), Global_Right(), Global_Space(), Global_StrComp(), Global_UBound(), and Global_WeekdayName().

vbdisp_get_id()

HRESULT vbdisp_get_id	(	vbdisp_t *	This,
		BSTR	name,
		vbdisp_invoke_type_t	invoke_type,
		BOOL	search_private,
		DISPID *	id
	)

Definition at line 59 of file vbdisp.c.

{
    unsigned i;
 
    if(get_func_id(This, name, invoke_type, search_private, id))
        return S_OK;
 
    for(i=0; i < This->desc->prop_cnt; i++) {
        if(!search_private && !This->desc->props[i].is_public)
            continue;
 
        if(!wcsicmp(This->desc->props[i].name, name)) {
            *id = i + This->desc->func_cnt;
            return S_OK;
        }
    }
 
    *id = -1;
    return DISP_E_UNKNOWNNAME;
}

Referenced by disp_get_id(), and DispatchEx_GetDispID().

VBScriptFactory_CreateInstance()

HRESULT WINAPI VBScriptFactory_CreateInstance	(	IClassFactory *	iface,
		IUnknown *	pUnkOuter,
		REFIID	riid,
		void **	ppv
	)

Definition at line 930 of file vbscript.c.

{
    script_ctx_t *ctx;
    VBScript *ret;
    HRESULT hres;
 
    TRACE("(%p %s %p)\n", pUnkOuter, debugstr_guid(riid), ppv);
 
    ret = heap_alloc_zero(sizeof(*ret));
    if(!ret)
        return E_OUTOFMEMORY;
 
    ret->IActiveScript_iface.lpVtbl = &VBScriptVtbl;
    ret->IActiveScriptDebug_iface.lpVtbl = &VBScriptDebugVtbl;
    ret->IActiveScriptParse_iface.lpVtbl = &VBScriptParseVtbl;
    ret->IActiveScriptParseProcedure2_iface.lpVtbl = &VBScriptParseProcedureVtbl;
    ret->IObjectSafety_iface.lpVtbl = &VBScriptSafetyVtbl;
 
    ret->ref = 1;
    ret->state = SCRIPTSTATE_UNINITIALIZED;
 
    ctx = ret->ctx = heap_alloc_zero(sizeof(*ctx));
    if(!ctx) {
        heap_free(ret);
        return E_OUTOFMEMORY;
    }
 
    ctx->safeopt = INTERFACE_USES_DISPEX;
    heap_pool_init(&ctx->heap);
    list_init(&ctx->objects);
    list_init(&ctx->code_list);
    list_init(&ctx->named_items);
 
    hres = init_global(ctx);
    if(FAILED(hres)) {
        IActiveScript_Release(&ret->IActiveScript_iface);
        return hres;
    }
 
    hres = IActiveScript_QueryInterface(&ret->IActiveScript_iface, riid, ppv);
    IActiveScript_Release(&ret->IActiveScript_iface);
    return hres;
}

VBScriptRegExpFactory_CreateInstance()

HRESULT WINAPI VBScriptRegExpFactory_CreateInstance	(	IClassFactory *	iface,
		IUnknown *	pUnkOuter,
		REFIID	riid,
		void **	ppv
	)

Definition at line 1618 of file vbregexp.c.

{
    IDispatch *regexp;
    HRESULT hres;
 
    TRACE("(%p %s %p)\n", pUnkOuter, debugstr_guid(riid), ppv);
 
    hres = create_regexp(&regexp);
    if(FAILED(hres))
        return hres;
 
    hres = IDispatch_QueryInterface(regexp, riid, ppv);
    IDispatch_Release(regexp);
    return hres;
}