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/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	array_desc_t
struct	vbdisp_prop_desc_t
struct	vbdisp_funcprop_desc_t
struct	_class_desc_t
struct	_vbdisp_t
struct	_dynamic_var_t
struct	ScriptDisp
struct	BuiltinDisp
struct	named_item_t
struct	vbcaller
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	SP_CALLER_UNINITIALIZED   ((IServiceProvider*)IntToPtr(-1))
#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 _class_desc_t	class_desc_t
typedef struct _dynamic_var_t	dynamic_var_t
typedef struct _builtin_prop_t	builtin_prop_t
typedef struct named_item_t	named_item_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 , ARG_DATE }
enum	vbsop_t { OP_LAST }
enum	function_type_t {   FUNC_GLOBAL , FUNC_FUNCTION , FUNC_SUB , FUNC_PROPGET ,   FUNC_PROPLET , FUNC_PROPSET }

Functions
void	heap_pool_init (heap_pool_t *)
void *	heap_pool_alloc (heap_pool_t *, size_t) __WINE_ALLOC_SIZE(2)
void *	heap_pool_grow (heap_pool_t *, void *, DWORD, DWORD)
void	heap_pool_clear (heap_pool_t *)
void	heap_pool_free (heap_pool_t *)
heap_pool_t *	heap_pool_mark (heap_pool_t *)
HRESULT	create_vbdisp (const class_desc_t *, vbdisp_t **)
HRESULT	disp_get_id (IDispatch *, BSTR, vbdisp_invoke_type_t, BOOL, DISPID *)
HRESULT	vbdisp_get_id (vbdisp_t *, BSTR, vbdisp_invoke_type_t, BOOL, DISPID *)
HRESULT	disp_call (script_ctx_t *, IDispatch *, DISPID, DISPPARAMS *, VARIANT *)
HRESULT	disp_propput (script_ctx_t *, IDispatch *, DISPID, WORD, DISPPARAMS *)
HRESULT	get_disp_value (script_ctx_t *, IDispatch *, VARIANT *)
void	collect_objects (script_ctx_t *)
HRESULT	create_script_disp (script_ctx_t *, ScriptDisp **)
HRESULT	to_int (VARIANT *, int *)
static unsigned	arg_cnt (const DISPPARAMS *dp)
static VARIANT *	get_arg (DISPPARAMS *dp, DWORD i)
HRESULT	init_global (script_ctx_t *)
HRESULT	init_err (script_ctx_t *)
IUnknown *	create_ax_site (script_ctx_t *)
static void	grab_vbscode (vbscode_t *code)
void	release_vbscode (vbscode_t *)
HRESULT	compile_script (script_ctx_t *, const WCHAR *, const WCHAR *, const WCHAR *, DWORD_PTR, unsigned, DWORD, vbscode_t **)
HRESULT	compile_procedure (script_ctx_t *, const WCHAR *, const WCHAR *, const WCHAR *, DWORD_PTR, unsigned, DWORD, class_desc_t **)
HRESULT	exec_script (script_ctx_t *, BOOL, function_t *, vbdisp_t *, DISPPARAMS *, VARIANT *)
void	release_dynamic_var (dynamic_var_t *)
named_item_t *	lookup_named_item (script_ctx_t *, const WCHAR *, unsigned)
void	release_named_item (named_item_t *)
void	clear_ei (EXCEPINFO *)
HRESULT	report_script_error (script_ctx_t *, const vbscode_t *, unsigned)
void	detach_global_objects (script_ctx_t *)
HRESULT	get_builtin_id (BuiltinDisp *, const WCHAR *, DISPID *)
HRESULT	array_access (SAFEARRAY *array, DISPPARAMS *dp, VARIANT **ret)
void	release_regexp_typelib (void)
HRESULT	get_dispatch_typeinfo (ITypeInfo **)
static BOOL	is_int32 (double d)
static BOOL	is_digit (WCHAR c)
HRESULT	create_regexp (IDispatch **)
BSTR	string_replace (BSTR, BSTR, BSTR, int, int, int)
void	map_vbs_exception (EXCEPINFO *)
HRESULT	create_safearray_iter (SAFEARRAY *sa, BOOL owned, IEnumVARIANT **ev)
HRESULT WINAPI	VBScriptFactory_CreateInstance (IClassFactory *, IUnknown *, REFIID, void **)
HRESULT WINAPI	VBScriptRegExpFactory_CreateInstance (IClassFactory *, IUnknown *, REFIID, void **)
BSTR	get_vbscript_string (int)

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 24 of file vbscript.h.

FACILITY_VBS

#define FACILITY_VBS   0xa

Definition at line 424 of file vbscript.h.

MAKE_VBSERROR

#define MAKE_VBSERROR

(

code

)

MAKE_HRESULT(SEVERITY_ERROR, FACILITY_VBS, code)

Definition at line 425 of file vbscript.h.

OP_LIST

#define OP_LIST

Definition at line 235 of file vbscript.h.

SP_CALLER_UNINITIALIZED

#define SP_CALLER_UNINITIALIZED   ((IServiceProvider*)IntToPtr(-1))

Definition at line 185 of file vbscript.h.

VBSCRIPT_BUILD_VERSION

#define VBSCRIPT_BUILD_VERSION   16978

Definition at line 432 of file vbscript.h.

VBSCRIPT_MAJOR_VERSION

#define VBSCRIPT_MAJOR_VERSION   5

Definition at line 433 of file vbscript.h.

VBSCRIPT_MINOR_VERSION

#define VBSCRIPT_MINOR_VERSION   8

Definition at line 434 of file vbscript.h.

X

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

Definition at line 304 of file vbscript.h.

Typedef Documentation

builtin_prop_t

typedef struct _builtin_prop_t builtin_prop_t

Definition at line 144 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 54 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 56 of file vbscript.h.

vbdisp_t

typedef struct _vbdisp_t vbdisp_t

Definition at line 57 of file vbscript.h.

vbscode_t

typedef struct _vbscode_t vbscode_t

Definition at line 55 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

Definition at line 331 of file vbscript.h.

             {
    FUNC_GLOBAL,
    FUNC_FUNCTION,
    FUNC_SUB,
    FUNC_PROPGET,
    FUNC_PROPLET,
    FUNC_PROPSET,
} 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
ARG_DATE

Definition at line 224 of file vbscript.h.

             {
    ARG_NONE = 0,
    ARG_STR,
    ARG_BSTR,
    ARG_INT,
    ARG_UINT,
    ARG_ADDR,
    ARG_DOUBLE,
    ARG_DATE
} 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 59 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 303 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 175 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_call_expression(), compile_new_expression(), compile_redim_statement(), do_icall(), do_mcall(), exec_script(), interp_assign_ident(), interp_assign_member(), interp_icall(), interp_icallv(), interp_set_ident(), interp_set_member(), interp_vcall(), interp_vcallv(), invoke_variant_prop(), invoke_vbdisp(), parse_arguments(), variant_call(), and vbstack_to_dp().

array_access()

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

Definition at line 525 of file interp.c.

{
    unsigned i, argc = arg_cnt(dp);
    LONG *indices;
    HRESULT hres;
 
    if(!array) {
        FIXME("NULL array\n");
        return E_FAIL;
    }
 
    hres = SafeArrayLock(array);
    if(FAILED(hres))
        return hres;
 
    if(array->cDims != argc) {
        FIXME("argc %d does not match cDims %d\n", dp->cArgs, array->cDims);
        SafeArrayUnlock(array);
        return E_FAIL;
    }
 
    indices = malloc(sizeof(*indices) * argc);
    if(!indices) {
        SafeArrayUnlock(array);
        return E_OUTOFMEMORY;
    }
 
    for(i=0; i<argc; i++) {
        hres = to_int(get_arg(dp, i), (int *)(indices+i));
        if(FAILED(hres)) {
            free(indices);
            SafeArrayUnlock(array);
            return hres;
        }
    }
 
    hres = SafeArrayPtrOfIndex(array, indices, (void**)ret);
    SafeArrayUnlock(array);
    free(indices);
    return hres;
}

Referenced by assign_ident(), invoke_variant_prop(), and variant_call().

clear_ei()

void clear_ei

(

EXCEPINFO *

ei

)

Definition at line 288 of file interp.c.

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

Referenced by compile_error(), disp_call(), disp_propput(), Err_Clear(), exec_script(), interp_errmode(), and release_script().

collect_objects()

void collect_objects

(

script_ctx_t *

ctx

)

Definition at line 1563 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 *	item_name,
		const WCHAR *	delimiter,
		DWORD_PTR	cookie,
		unsigned	start_line,
		DWORD	flags,
		class_desc_t **	ret
	)

Definition at line 2078 of file compile.c.

{
    class_desc_t *desc;
    vbscode_t *code;
    HRESULT hres;
 
    hres = compile_script(script, src, item_name, delimiter, cookie, start_line,
                          flags & ~SCRIPTTEXT_ISPERSISTENT, &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;
 
    *ret = desc;
    return S_OK;
}

Referenced by VBScriptParseProcedure_ParseProcedureText().

compile_script()

HRESULT compile_script	(	script_ctx_t *	script,
		const WCHAR *	src,
		const WCHAR *	item_name,
		const WCHAR *	delimiter,
		DWORD_PTR	cookie,
		unsigned	start_line,
		DWORD	flags,
		vbscode_t **	ret
	)

Definition at line 1986 of file compile.c.

{
    function_decl_t *func_decl;
    named_item_t *item = NULL;
    class_decl_t *class_decl;
    function_t *new_func;
    compile_ctx_t ctx;
    vbscode_t *code;
    HRESULT hres;
 
    if(item_name) {
        item = lookup_named_item(script, item_name, 0);
        if(!item) {
            WARN("Unknown context %s\n", debugstr_w(item_name));
            return E_INVALIDARG;
        }
        if(!item->script_obj) item = NULL;
    }
 
    memset(&ctx, 0, sizeof(ctx));
    code = ctx.code = alloc_vbscode(&ctx, src, cookie, start_line);
    if(!ctx.code)
        return E_OUTOFMEMORY;
    if(item) {
        code->named_item = item;
        item->ref++;
    }
 
    ctx.parser.lcid = script->lcid;
    hres = parse_script(&ctx.parser, code->source, delimiter, flags);
    if(FAILED(hres)) {
        if(ctx.parser.error_loc != -1)
            ctx.loc = ctx.parser.error_loc;
        hres = compile_error(script, &ctx, hres);
        release_vbscode(code);
        return hres;
    }
 
    hres = compile_func(&ctx, ctx.parser.stats, &ctx.code->main_code);
    if(FAILED(hres)) {
        hres = compile_error(script, &ctx, hres);
        release_compiler(&ctx);
        return hres;
    }
 
    code->option_explicit = ctx.parser.option_explicit;
    ctx.global_consts = ctx.const_decls;
    code->option_explicit = ctx.parser.option_explicit;
 
 
    for(func_decl = ctx.func_decls; func_decl; func_decl = func_decl->next) {
        hres = create_function(&ctx, func_decl, &new_func);
        if(FAILED(hres)) {
            hres = compile_error(script, &ctx, hres);
            release_compiler(&ctx);
            return hres;
        }
 
        new_func->next = ctx.code->funcs;
        ctx.code->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)) {
            hres = compile_error(script, &ctx, hres);
            release_compiler(&ctx);
            return hres;
        }
    }
 
    hres = check_script_collisions(&ctx, script);
    if(FAILED(hres)) {
        hres = compile_error(script, &ctx, hres);
        release_compiler(&ctx);
        return hres;
    }
 
    code->is_persistent = (flags & SCRIPTTEXT_ISPERSISTENT) != 0;
 
    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 614 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: %08lx\n", hres);
    }
 
    ret = malloc(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 1811 of file vbregexp.c.

{
    RegExp2 *regexp;
    HRESULT hres;
 
    hres = init_regexp_typeinfo(RegExp2_tid);
    if(FAILED(hres))
        return hres;
 
    regexp = calloc(1, 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,
		BOOL	owned,
		IEnumVARIANT **	ev
	)

Definition at line 167 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 = malloc(sizeof(*iter));
    if(!iter)
        return E_OUTOFMEMORY;
 
    if(sa) {
        hres = SafeArrayLock(sa);
        if(FAILED(hres)) {
            free(iter);
            return hres;
        }
    }
 
    iter->IEnumVARIANT_iface.lpVtbl = &safearray_iter_EnumVARIANTVtbl;
    iter->ref = 1;
    iter->sa = sa;
    iter->owned = owned;
    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 1545 of file vbdisp.c.

{
    ScriptDisp *script_disp;
 
    script_disp = calloc(1, sizeof(*script_disp));
    if(!script_disp)
        return E_OUTOFMEMORY;
 
    script_disp->IDispatchEx_iface.lpVtbl = &ScriptDispVtbl;
    script_disp->ref = 1;
    script_disp->ctx = ctx;
    heap_pool_init(&script_disp->heap);
    script_disp->rnd = 0x50000;
 
    *ret = script_disp;
    return S_OK;
}

Referenced by exec_global_code(), lookup_named_item(), and VBScript_SetScriptSite().

create_vbdisp()

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

Definition at line 507 of file vbdisp.c.

{
    vbdisp_t *vbdisp;
    HRESULT hres = S_OK;
 
    vbdisp = calloc( 1, 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 = calloc(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 3602 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 VBScript_Release().

disp_call()

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

Definition at line 1675 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(SUCCEEDED(hres)) {
        hres = IDispatchEx_InvokeEx(dispex, id, ctx->lcid, flags, dp, retv, &ei, &ctx->vbcaller->IServiceProvider_iface);
        IDispatchEx_Release(dispex);
    }else {
        UINT err = 0;
 
        TRACE("using IDispatch\n");
        hres = IDispatch_Invoke(disp, id, &IID_NULL, ctx->lcid, flags, dp, retv, &ei, &err);
    }
 
    if(hres == DISP_E_EXCEPTION) {
        clear_ei(&ctx->ei);
        ctx->ei = ei;
        hres = SCRIPT_E_RECORDED;
    }
    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 1582 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 1718 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, &ctx->vbcaller->IServiceProvider_iface);
        IDispatchEx_Release(dispex);
    }else {
        UINT err = 0;
 
        TRACE("using IDispatch\n");
        hres = IDispatch_Invoke(disp, id, &IID_NULL, ctx->lcid, flags, dp, NULL, &ei, &err);
    }
 
    if(hres == DISP_E_EXCEPTION) {
        clear_ei(&ctx->ei);
        ctx->ei = ei;
        hres = SCRIPT_E_RECORDED;
    }
    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 2455 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);
 
    TRACE("%s args=%u\n", debugstr_w(func->name),func->arg_cnt);
    if(func->arg_cnt) {
        VARIANT *v;
        unsigned i;
 
        exec.args = calloc(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);
            TRACE("  [%d] %s\n", i, debugstr_variant(v));
            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 = calloc(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 = malloc(exec.stack_size * sizeof(VARIANT));
    if(!exec.stack) {
        release_exec(&exec);
        return E_OUTOFMEMORY;
    }
 
    if(extern_caller)
        IActiveScriptSite_OnEnterScript(ctx->site);
 
    if(vbthis) {
        IDispatchEx_AddRef(&vbthis->IDispatchEx_iface);
        exec.vbthis = vbthis;
    }
 
    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) {
                /* SCRIPT_E_RECORDED means ctx->ei is already populated */
                clear_ei(&ctx->ei);
                ctx->ei.scode = hres;
            }
 
            if(!ctx->ei.bstrDescription)
                map_vbs_exception(&ctx->ei);
 
            if(exec.resume_next) {
                unsigned stack_off;
 
                WARN("Failed %08lx in resume next mode\n", ctx->ei.scode);
 
                /*
                 * 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);
 
                clear_error_loc(ctx);
                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 {
                if(!ctx->error_loc_code) {
                    grab_vbscode(exec.code);
                    ctx->error_loc_code = exec.code;
                    ctx->error_loc_offset = exec.instr->loc;
                }
                stack_popn(&exec, exec.top);
                break;
            }
        }
 
        exec.instr += op_move[op];
    }
 
    assert(!exec.top);
 
    if(extern_caller) {
        if(FAILED(hres)) {
            if(!ctx->ei.scode)
                ctx->ei.scode = hres;
            hres = report_script_error(ctx, ctx->error_loc_code, ctx->error_loc_offset);
            clear_error_loc(ctx);
        }
        IActiveScriptSite_OnLeaveScript(ctx->site);
    }
 
    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 180 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 127 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 1710 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_dispatch_typeinfo()

HRESULT get_dispatch_typeinfo

(

ITypeInfo **

out

)

Definition at line 78 of file jscript_main.c.

{
    ITypeInfo *typeinfo;
    ITypeLib *typelib;
    HRESULT hr;
 
    if (!dispatch_typeinfo)
    {
        hr = LoadRegTypeLib(&IID_StdOle, STDOLE_MAJORVERNUM, STDOLE_MINORVERNUM, STDOLE_LCID, &typelib);
        if (FAILED(hr)) return hr;
 
        hr = ITypeLib_GetTypeInfoOfGuid(typelib, &IID_IDispatch, &typeinfo);
        ITypeLib_Release(typelib);
        if (FAILED(hr)) return hr;
 
        if (InterlockedCompareExchangePointer((void**)&dispatch_typeinfo, typeinfo, NULL))
            ITypeInfo_Release(typeinfo);
    }
 
    *out = dispatch_typeinfo;
    return S_OK;
}

get_vbscript_string()

BSTR get_vbscript_string

(

int

id

)

Definition at line 39 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(), and map_vbs_exception().

grab_vbscode()

static void grab_vbscode ( vbscode_t *  code )

inlinestatic

Definition at line 386 of file vbscript.h.

{
    code->ref++;
}

Referenced by exec_script(), and ScriptDisp_GetTypeInfo().

heap_pool_alloc()

void * heap_pool_alloc	(	heap_pool_t *	heap,
		size_t	size
	)

Definition at line 60 of file vbscript_main.c.

{
    struct list *list;
    void *tmp;
 
    size = (size+3)&~3;
 
    if(!heap->block_cnt) {
        if(!heap->blocks) {
            heap->blocks = malloc(sizeof(void*));
            if(!heap->blocks)
                return NULL;
        }
 
        tmp = malloc(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 = realloc(heap->blocks, (heap->block_cnt+1)*sizeof(void*));
            if(!tmp)
                return NULL;
 
            heap->blocks = tmp;
            heap->blocks[heap->block_cnt] = malloc(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 = malloc(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 141 of file jsutils.c.

{
    struct list *tmp;
 
    if(!heap)
        return;
 
    while((tmp = list_head(&heap->custom_blocks))) {
        list_remove(tmp);
        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 164 of file jsutils.c.

{
    DWORD i;
 
    heap_pool_clear(heap);
 
    for(i=0; i < heap->block_cnt; i++)
        free(heap->blocks[i]);
    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 125 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 66 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 177 of file jsutils.c.

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

init_err()

HRESULT init_err

(

script_ctx_t *

)

init_global()

HRESULT init_global

(

script_ctx_t *

ctx

)

Definition at line 1091 of file global.c.

{
    unsigned const_flags = ctx->version >= SCRIPTLANGUAGEVERSION_ES5 ? 0 : PROPF_WRITABLE;
    jsdisp_t *math, *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, &ctx->object_prototype);
    if(FAILED(hres))
        return hres;
 
    hres = init_constructors(ctx, ctx->object_prototype);
    if(FAILED(hres))
        return hres;
 
    hres = init_object_prototype_accessors(ctx, ctx->object_prototype);
    if(FAILED(hres))
        return hres;
 
    hres = create_math(ctx, &math);
    if(FAILED(hres))
        return hres;
 
    hres = jsdisp_define_data_property(ctx->global, L"Math", PROPF_CONFIGURABLE | 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, L"JSON", PROPF_CONFIGURABLE | 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, L"ActiveXObject", PROPF_CONFIGURABLE | PROPF_WRITABLE,
                                       jsval_obj(constr));
    jsdisp_release(constr);
    if(FAILED(hres))
        return hres;
 
    hres = jsdisp_define_data_property(ctx->global, L"undefined", const_flags, jsval_undefined());
    if(FAILED(hres))
        return hres;
 
    hres = jsdisp_define_data_property(ctx->global, L"NaN", const_flags, jsval_number(NAN));
    if(FAILED(hres))
        return hres;
 
    hres = jsdisp_define_data_property(ctx->global, L"Infinity", const_flags, jsval_number(INFINITY));
    if(FAILED(hres))
        return hres;
 
    hres = init_arraybuf_constructors(ctx);
    if(FAILED(hres))
        return hres;
 
    return init_set_constructor(ctx);
}

Referenced by JScript_SetScriptSite(), and VBScriptFactory_CreateInstance().

is_digit()

static BOOL is_digit ( WCHAR  c )

inlinestatic

Definition at line 412 of file vbscript.h.

{
    return '0' <= c && c <= '9';
}

is_int32()

static BOOL is_int32 ( double  d )

inlinestatic

Definition at line 407 of file vbscript.h.

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

lookup_named_item()

named_item_t * lookup_named_item	(	script_ctx_t *	ctx,
		const WCHAR *	item_name,
		unsigned	flags
	)

Definition at line 162 of file jscript.c.

{
    named_item_t *item;
    HRESULT hr;
 
    LIST_FOR_EACH_ENTRY(item, &ctx->named_items, named_item_t, entry) {
        if((item->flags & flags) == flags && !wcscmp(item->name, item_name)) {
            if(!item->script_obj && !(item->flags & SCRIPTITEM_GLOBALMEMBERS)) {
                hr = create_named_item_script_obj(ctx, item);
                if(FAILED(hr)) return NULL;
            }
 
            if(!item->disp && (flags || !(item->flags & SCRIPTITEM_CODEONLY))) {
                hr = retrieve_named_item_disp(ctx->site, item);
                if(FAILED(hr)) continue;
            }
 
            return item;
        }
    }
 
    return NULL;
}

Referenced by compile_script(), identifier_eval(), JScript_GetScriptDispatch(), JScriptParse_ParseScriptText(), JScriptParseProcedure_ParseProcedureText(), lookup_identifier(), and VBScript_GetScriptDispatch().

map_vbs_exception()

void map_vbs_exception

(

EXCEPINFO *

ei

)

Definition at line 1605 of file vbdisp.c.

{
    int vbse_number;
 
    if(HRESULT_FACILITY(ei->scode) == FACILITY_VBS)
        vbse_number = HRESULT_CODE(ei->scode);
    else
    {
        switch(ei->scode) {
        case E_NOTIMPL:                  vbse_number = VBSE_ACTION_NOT_SUPPORTED; break;
        case E_NOINTERFACE:              vbse_number = VBSE_OLE_NOT_SUPPORTED; break;
        case DISP_E_UNKNOWNINTERFACE:    vbse_number = VBSE_OLE_NO_PROP_OR_METHOD; break;
        case DISP_E_MEMBERNOTFOUND:      vbse_number = VBSE_OLE_NO_PROP_OR_METHOD; break;
        case DISP_E_PARAMNOTFOUND:       vbse_number = VBSE_NAMED_PARAM_NOT_FOUND; break;
        case DISP_E_TYPEMISMATCH:        vbse_number = VBSE_TYPE_MISMATCH; break;
        case DISP_E_UNKNOWNNAME:         vbse_number = VBSE_OLE_NO_PROP_OR_METHOD; break;
        case DISP_E_NONAMEDARGS:         vbse_number = VBSE_NAMED_ARGS_NOT_SUPPORTED; break;
        case DISP_E_BADVARTYPE:          vbse_number = VBSE_INVALID_TYPELIB_VARIABLE; break;
        case DISP_E_OVERFLOW:            vbse_number = VBSE_OVERFLOW; break;
        case DISP_E_BADINDEX:            vbse_number = VBSE_OUT_OF_BOUNDS; break;
        case DISP_E_UNKNOWNLCID:         vbse_number = VBSE_LOCALE_SETTING_NOT_SUPPORTED; break;
        case DISP_E_ARRAYISLOCKED:       vbse_number = VBSE_ARRAY_LOCKED; break;
        case DISP_E_BADPARAMCOUNT:       vbse_number = VBSE_FUNC_ARITY_MISMATCH; break;
        case DISP_E_PARAMNOTOPTIONAL:    vbse_number = VBSE_PARAMETER_NOT_OPTIONAL; break;
        case DISP_E_NOTACOLLECTION:      vbse_number = VBSE_NOT_ENUM; break;
        case TYPE_E_DLLFUNCTIONNOTFOUND: vbse_number = VBSE_INVALID_DLL_FUNCTION_NAME; break;
        case TYPE_E_TYPEMISMATCH:        vbse_number = VBSE_TYPE_MISMATCH; break;
        case TYPE_E_OUTOFBOUNDS:         vbse_number = VBSE_OUT_OF_BOUNDS; break;
        case TYPE_E_IOERROR:             vbse_number = VBSE_IO_ERROR; break;
        case TYPE_E_CANTCREATETMPFILE:   vbse_number = VBSE_CANT_CREATE_TMP_FILE; break;
        case STG_E_FILENOTFOUND:         vbse_number = VBSE_OLE_FILE_NOT_FOUND; break;
        case STG_E_PATHNOTFOUND:         vbse_number = VBSE_PATH_NOT_FOUND; break;
        case STG_E_TOOMANYOPENFILES:     vbse_number = VBSE_TOO_MANY_FILES; break;
        case STG_E_ACCESSDENIED:         vbse_number = VBSE_PERMISSION_DENIED; break;
        case STG_E_INSUFFICIENTMEMORY:   vbse_number = VBSE_OUT_OF_MEMORY; break;
        case STG_E_NOMOREFILES:          vbse_number = VBSE_TOO_MANY_FILES; break;
        case STG_E_DISKISWRITEPROTECTED: vbse_number = VBSE_PERMISSION_DENIED; break;
        case STG_E_WRITEFAULT:           vbse_number = VBSE_IO_ERROR; break;
        case STG_E_READFAULT:            vbse_number = VBSE_IO_ERROR; break;
        case STG_E_SHAREVIOLATION:       vbse_number = VBSE_PATH_FILE_ACCESS; break;
        case STG_E_LOCKVIOLATION:        vbse_number = VBSE_PERMISSION_DENIED; break;
        case STG_E_FILEALREADYEXISTS:    vbse_number = VBSE_FILE_ALREADY_EXISTS; break;
        case STG_E_MEDIUMFULL:           vbse_number = VBSE_DISK_FULL; break;
        case STG_E_INVALIDNAME:          vbse_number = VBSE_FILE_NOT_FOUND; break;
        case STG_E_INUSE:                vbse_number = VBSE_PERMISSION_DENIED; break;
        case STG_E_NOTCURRENT:           vbse_number = VBSE_PERMISSION_DENIED; break;
        case STG_E_CANTSAVE:             vbse_number = VBSE_IO_ERROR; break;
        case REGDB_E_CLASSNOTREG:        vbse_number = VBSE_CANT_CREATE_OBJECT; break;
        case MK_E_UNAVAILABLE:           vbse_number = VBSE_CANT_CREATE_OBJECT; break;
        case MK_E_INVALIDEXTENSION:      vbse_number = VBSE_OLE_FILE_NOT_FOUND; break;
        case MK_E_CANTOPENFILE:          vbse_number = VBSE_OLE_FILE_NOT_FOUND; break;
        case CO_E_CLASSSTRING:           vbse_number = VBSE_CANT_CREATE_OBJECT; break;
        case CO_E_APPNOTFOUND:           vbse_number = VBSE_CANT_CREATE_OBJECT; break;
        case CO_E_APPDIDNTREG:           vbse_number = VBSE_CANT_CREATE_OBJECT; break;
        case E_ACCESSDENIED:             vbse_number = VBSE_PERMISSION_DENIED; break;
        case E_OUTOFMEMORY:              vbse_number = VBSE_OUT_OF_MEMORY; break;
        case E_INVALIDARG:               vbse_number = VBSE_ILLEGAL_FUNC_CALL; break;
        case RPC_E_SERVER_UNAVAILABLE:   vbse_number = VBSE_SERVER_NOT_FOUND; break;
        case CO_E_SERVER_EXEC_FAILURE:   vbse_number = VBSE_CANT_CREATE_OBJECT; break;
        default: return; /* early return, all other HRESULT left as-is */
        }
        ei->scode = MAKE_VBSERROR(vbse_number);
    }
    if(!ei->bstrSource)
        ei->bstrSource = get_vbscript_string(VBS_RUNTIME_ERROR);
    if(!ei->bstrDescription)
        if(!(ei->bstrDescription = get_vbscript_string(vbse_number)))
            ei->bstrDescription = get_vbscript_string(VBS_UNKNOWN_RUNTIME_ERROR);
}

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

release_dynamic_var()

void release_dynamic_var

(

dynamic_var_t *

var

)

Definition at line 2411 of file interp.c.

{
    VariantClear(&var->v);
    if(var->array)
        SafeArrayDestroy(var->array);
}

Referenced by release_exec(), and ScriptDisp_Release().

release_named_item()

void release_named_item

(

named_item_t *

item

)

Definition at line 186 of file jscript.c.

{
    if(--item->ref) return;
 
    free(item->name);
    free(item);
}

Referenced by decrease_state(), release_bytecode(), release_named_item_list(), release_script(), and release_vbscode().

release_regexp_typelib()

void release_regexp_typelib

(

void

)

Definition at line 1849 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 1915 of file compile.c.

{
    unsigned i;
 
    if(--code->ref)
        return;
 
    for(i=0; i < code->bstr_cnt; i++)
        SysFreeString(code->bstr_pool[i]);
 
    if(code->named_item)
        release_named_item(code->named_item);
    heap_pool_free(&code->heap);
 
    free(code->bstr_pool);
    free(code->source);
    free(code->instrs);
    free(code);
}

Referenced by alloc_vbscode(), clear_error_loc(), compile_script(), release_code_list(), release_compiler(), release_script(), and ScriptTypeInfo_Release().

report_script_error()

HRESULT report_script_error	(	script_ctx_t *	ctx,
		const vbscode_t *	code,
		unsigned	loc
	)

Definition at line 558 of file vbscript.c.

{
    VBScriptError *error;
    const WCHAR *p, *nl;
    HRESULT hres, result;
 
    if(!(error = malloc(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;
 
    p = code->source;
    error->cookie = code->cookie;
    error->line = code->start_line;
    for(nl = p = code->source; p < code->source + loc; p++) {
        if(*p != '\n') continue;
        error->line++;
        nl = p + 1;
    }
    error->character = code->source + loc - nl;
 
    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().

string_replace()

BSTR string_replace	(	BSTR	string,
		BSTR	find,
		BSTR	replace,
		int	from,
		int	cnt,
		int	mode
	)

Definition at line 1635 of file vbregexp.c.

{
    const WCHAR *ptr, *string_end;
    strbuf_t buf = { NULL, 0, 0 };
    size_t replace_len, find_len;
    BSTR ret = NULL;
    HRESULT hres = S_OK;
    int pos;
 
    string_end = string + SysStringLen(string);
    ptr = from > SysStringLen(string) ? string_end : string + from;
 
    find_len = SysStringLen(find);
    replace_len = SysStringLen(replace);
 
    while(string_end - ptr >= find_len && cnt && find_len) {
        pos = FindStringOrdinal(FIND_FROMSTART, ptr, string_end - ptr,
                                find, find_len, mode);
 
        if(pos == -1)
            break;
        else {
            hres = strbuf_append(&buf, ptr, pos);
            if(FAILED(hres))
                break;
            hres = strbuf_append(&buf, replace, replace_len);
            if(FAILED(hres))
                break;
 
            ptr = ptr + pos + find_len;
            if(cnt != -1)
                cnt--;
        }
    }
 
    if(SUCCEEDED(hres)) {
        hres = strbuf_append(&buf, ptr, string_end - ptr);
        if(SUCCEEDED(hres))
            ret = SysAllocStringLen(buf.buf, buf.len);
    }
 
    free(buf.buf);
    return ret;
}

Referenced by Global_Replace().

to_int()

HRESULT to_int	(	VARIANT *	v,
		int *	ret
	)

Definition at line 419 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(), array_bounds_from_stack(), Err_Raise(), Global_Chr(), Global_CLng(), Global_DateAdd(), Global_DateSerial(), Global_FormatCurrency(), Global_FormatDateTime(), Global_FormatNumber(), Global_FormatPercent(), Global_Hex(), Global_InStr(), Global_InStrRev(), Global_LBound(), Global_Left(), Global_Mid(), Global_MonthName(), Global_MsgBox(), Global_Oct(), Global_Replace(), Global_RGB(), Global_Right(), Global_Round(), Global_Space(), Global_Split(), Global_StrComp(), Global_String(), Global_TimeSerial(), Global_UBound(), Global_Weekday(), 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 60 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(), DispatchEx_GetDispID(), and lookup_identifier().

VBScriptFactory_CreateInstance()

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

Definition at line 1201 of file vbscript.c.

{
    struct vbcaller *vbcaller;
    script_ctx_t *ctx;
    VBScript *ret;
    HRESULT hres;
 
    TRACE("(%p %s %p)\n", pUnkOuter, debugstr_guid(riid), ppv);
 
    ret = calloc(1, sizeof(*ret));
    if(!ret)
        return E_OUTOFMEMORY;
 
    if(!(vbcaller = create_vbcaller())) {
        free(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 = calloc(1, sizeof(*ctx));
    if(!ctx) {
        IServiceProvider_Release(&vbcaller->IServiceProvider_iface);
        free(ret);
        return E_OUTOFMEMORY;
    }
 
    vbcaller->ctx = ctx;
    ctx->vbcaller = vbcaller;
    ctx->safeopt = INTERFACE_USES_DISPEX;
    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 1833 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;
}