engine.h File Reference

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

Go to the source code of this file.

Classes
union	instr_arg_t
struct	instr_t
struct	local_ref_t
struct	local_ref_scopes_t
struct	_function_code_t
struct	_bytecode_t
struct	vars_buffer
struct	_scope_chain_t
struct	_jsexcept_t
struct	_call_frame_t

Macros
#define	OP_LIST
#define	X(x, a, b, c)   OP_##x,
#define	INVALID_LOCAL_REF   0x7fffffff
#define	EXEC_GLOBAL   0x0001
#define	EXEC_CONSTRUCTOR   0x0002
#define	EXEC_RETURN_TO_INTERP   0x0004
#define	EXEC_EVAL   0x0008

Typedefs
typedef struct _bytecode_t	bytecode_t
typedef struct _function_code_t	function_code_t
typedef struct _scope_chain_t	scope_chain_t
typedef struct _except_frame_t	except_frame_t
typedef struct _call_frame_t	call_frame_t

Enumerations
enum	jsop_t { OP_LAST }
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	property_definition_type_t { PROPERTY_DEFINITION_VALUE , PROPERTY_DEFINITION_GETTER , PROPERTY_DEFINITION_SETTER }

Functions
IDispatch *	lookup_global_host (script_ctx_t *)
local_ref_t *	lookup_local (const function_code_t *, const WCHAR *, unsigned int)
HRESULT	compile_script (script_ctx_t *, const WCHAR *, UINT64, unsigned, const WCHAR *, const WCHAR *, BOOL, BOOL, named_item_t *, bytecode_t **)
void	release_bytecode (bytecode_t *)
unsigned	get_location_line (bytecode_t *code, unsigned loc, unsigned *char_pos)
static bytecode_t *	bytecode_addref (bytecode_t *code)
static scope_chain_t *	scope_addref (scope_chain_t *scope)
static void	scope_release (scope_chain_t *scope)
void	enter_script (script_ctx_t *, jsexcept_t *)
HRESULT	leave_script (script_ctx_t *, HRESULT)
void	reset_ei (jsexcept_t *)
void	set_error_location (jsexcept_t *, bytecode_t *, unsigned, unsigned, jsstr_t *)
HRESULT	exec_source (script_ctx_t *, DWORD, bytecode_t *, function_code_t *, scope_chain_t *, IDispatch *, jsdisp_t *, unsigned, jsval_t *, jsval_t *)
HRESULT	create_source_function (script_ctx_t *, bytecode_t *, function_code_t *, scope_chain_t *, jsdisp_t **)
HRESULT	setup_arguments_object (script_ctx_t *, call_frame_t *)
void	detach_arguments_object (call_frame_t *)

Macro Definition Documentation

EXEC_CONSTRUCTOR

#define EXEC_CONSTRUCTOR   0x0002

Definition at line 306 of file engine.h.

EXEC_EVAL

#define EXEC_EVAL   0x0008

Definition at line 308 of file engine.h.

EXEC_GLOBAL

#define EXEC_GLOBAL   0x0001

Definition at line 305 of file engine.h.

EXEC_RETURN_TO_INTERP

#define EXEC_RETURN_TO_INTERP   0x0004

Definition at line 307 of file engine.h.

INVALID_LOCAL_REF

#define INVALID_LOCAL_REF   0x7fffffff

Definition at line 152 of file engine.h.

OP_LIST

#define OP_LIST

Definition at line 21 of file engine.h.

X

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

Definition at line 106 of file engine.h.

Typedef Documentation

bytecode_t

typedef struct _bytecode_t bytecode_t

Definition at line 112 of file engine.h.

call_frame_t

typedef struct _call_frame_t call_frame_t

except_frame_t

typedef struct _except_frame_t except_frame_t

Definition at line 275 of file engine.h.

function_code_t

typedef struct _function_code_t function_code_t

scope_chain_t

typedef struct _scope_chain_t scope_chain_t

Enumeration Type Documentation

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 121 of file engine.h.

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

jsop_t

enum jsop_t

Enumerator
OP_LAST

Definition at line 105 of file engine.h.

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

property_definition_type_t

enum property_definition_type_t

Enumerator
PROPERTY_DEFINITION_VALUE
PROPERTY_DEFINITION_GETTER
PROPERTY_DEFINITION_SETTER

Definition at line 141 of file engine.h.

             {
    PROPERTY_DEFINITION_VALUE,
    PROPERTY_DEFINITION_GETTER,
    PROPERTY_DEFINITION_SETTER
} property_definition_type_t;

Function Documentation

bytecode_addref()

static bytecode_t * bytecode_addref ( bytecode_t *  code )

inlinestatic

Definition at line 221 of file engine.h.

{
    code->ref++;
    return code;
}

Referenced by alloc_detached_vars(), create_source_function(), DispatchEx_GetTypeInfo(), exec_source(), and set_error_location().

compile_script()

HRESULT compile_script	(	script_ctx_t *	ctx,
		const WCHAR *	code,
		UINT64	source_context,
		unsigned	start_line,
		const WCHAR *	args,
		const WCHAR *	delimiter,
		BOOL	from_eval,
		BOOL	use_decode,
		named_item_t *	named_item,
		bytecode_t **	ret
	)

Definition at line 2725 of file compile.c.

{
    compiler_ctx_t compiler = {0};
    HRESULT hres;
 
    hres = init_code(&compiler, code, source_context, start_line);
    if(FAILED(hres))
        return hres;
 
    if(args) {
        hres = compile_arguments(&compiler, args);
        if(FAILED(hres))
            return hres;
    }
 
    if(use_decode) {
        hres = decode_source(compiler.code->source);
        if(FAILED(hres)) {
            WARN("Decoding failed\n");
            return hres;
        }
    }
 
    hres = script_parse(ctx, &compiler, compiler.code, delimiter, from_eval, &compiler.parser);
    if(FAILED(hres)) {
        release_bytecode(compiler.code);
        return hres;
    }
 
    heap_pool_init(&compiler.heap);
    hres = compile_function(&compiler, compiler.parser->source, NULL, from_eval, &compiler.code->global_code);
    free(compiler.local_scopes);
    heap_pool_free(&compiler.heap);
    parser_release(compiler.parser);
    if(FAILED(hres)) {
        if(hres != DISP_E_EXCEPTION)
            throw_error(ctx, hres, NULL);
        set_error_location(ctx->ei, compiler.code, compiler.loc, IDS_COMPILATION_ERROR, NULL);
        release_bytecode(compiler.code);
        return DISP_E_EXCEPTION;
    }
 
    if(named_item) {
        compiler.code->named_item = named_item;
        named_item->ref++;
    }
 
    *ret = compiler.code;
    return S_OK;
}

Referenced by builtin_eval(), compile_procedure(), construct_function(), JScriptParse_ParseScriptText(), JScriptParseProcedure_ParseProcedureText(), and VBScriptParse_ParseScriptText().

create_source_function()

HRESULT create_source_function	(	script_ctx_t *	ctx,
		bytecode_t *	code,
		function_code_t *	func_code,
		scope_chain_t *	scope_chain,
		jsdisp_t **	ret
	)

Definition at line 953 of file function.c.

{
    InterpretedFunction *function;
    HRESULT hres;
 
    hres = create_function(ctx, &InterpretedFunction_info, &InterpretedFunctionVtbl, sizeof(InterpretedFunction),
                           PROPF_CONSTR, FALSE, NULL, (void**)&function);
    if(FAILED(hres))
        return hres;
 
    if(scope_chain) {
        scope_addref(scope_chain);
        function->scope_chain = scope_chain;
    }
 
    bytecode_addref(code);
    function->code = code;
    function->func_code = func_code;
    function->function.length = function->func_code->param_cnt;
 
    *ret = &function->function.dispex;
    return S_OK;
}

Referenced by construct_function(), exec_source(), interp_func(), JScriptParseProcedure_ParseProcedureText(), scope_init_locals(), and setup_scope().

detach_arguments_object()

void detach_arguments_object

(

call_frame_t *

frame

)

Definition at line 293 of file function.c.

{
    ArgumentsInstance *arguments = arguments_from_jsdisp(frame->arguments_obj);
    scope_chain_t *scope = arguments->scope;
    const BOOL on_stack = scope->frame == frame;
    jsdisp_t *jsobj = as_jsdisp(scope->obj);
 
    /* Reset arguments value to cut the reference cycle. Note that since all activation contexts have
     * their own arguments property, it's impossible to use prototype's one during name lookup */
    jsdisp_propput_name(jsobj, L"arguments", jsval_undefined());
 
    /* Don't bother coppying arguments if call frame holds the last reference. */
    if(arguments->jsdisp.ref > 1 && !arguments->jsdisp.ctx->html_mode) {
        arguments->buf = malloc(arguments->argc * sizeof(*arguments->buf));
        if(arguments->buf) {
            const jsval_t *args = on_stack ? arguments->jsdisp.ctx->stack + frame->arguments_off : scope->detached_vars->var;
            int i;
 
            for(i = 0; i < arguments->argc ; i++) {
                if(FAILED(jsval_copy(args[i], &arguments->buf[i])))
                    arguments->buf[i] = jsval_undefined();
            }
        }else {
            ERR("out of memory\n");
            arguments->argc = 0;
        }
 
        arguments->scope = NULL;
        scope_release(scope);
    }
 
    jsdisp_release(&arguments->jsdisp);
}

Referenced by pop_call_frame().

enter_script()

void enter_script	(	script_ctx_t *	ctx,
		jsexcept_t *	ei
	)

Definition at line 340 of file jscript.c.

{
    memset(ei, 0, sizeof(*ei));
    ei->prev = ctx->ei;
    ctx->ei = ei;
    TRACE("ctx %p ei %p prev %p\n", ctx, ei, ei->prev);
}

Referenced by DispatchEx_InvokeEx(), exec_queued_code(), JScriptParse_ParseScriptText(), JScriptParseProcedure_ParseProcedureText(), variant_change_type(), and VariantChangeType_ChangeType().

exec_source()

HRESULT exec_source	(	script_ctx_t *	ctx,
		DWORD	flags,
		bytecode_t *	bytecode,
		function_code_t *	function,
		scope_chain_t *	scope,
		IDispatch *	this_obj,
		jsdisp_t *	function_instance,
		unsigned	argc,
		jsval_t *	argv,
		jsval_t *	r
	)

Definition at line 3425 of file engine.c.

{
    jsdisp_t *variable_obj;
    call_frame_t *frame;
    unsigned i;
    HRESULT hres;
 
    if(!ctx->stack) {
        ctx->stack = malloc(stack_size * sizeof(*ctx->stack));
        if(!ctx->stack)
            return E_OUTOFMEMORY;
    }
 
    if(bytecode->named_item) {
        if(!bytecode->named_item->script_obj) {
            hres = create_named_item_script_obj(ctx, bytecode->named_item);
            if(FAILED(hres)) return hres;
        }
    }
 
    if(!ctx->ei->enter_notified) {
        ctx->ei->enter_notified = TRUE;
        IActiveScriptSite_OnEnterScript(ctx->site);
    }
 
    for(i = 0; i < function->func_cnt; i++) {
        jsdisp_t *func_obj;
 
        if(!function->funcs[i].event_target)
            continue;
 
        if (function->funcs[i].scope_index)
        {
            /* TODO: Add tests and handle in interp_push_scope(). */
            FIXME("Event target with scope index are not properly handled.\n");
        }
 
        hres = create_source_function(ctx, bytecode, function->funcs+i, scope, &func_obj);
        if(FAILED(hres))
            return hres;
 
        hres = bind_event_target(ctx, function->funcs+i, func_obj);
        jsdisp_release(func_obj);
        if(FAILED(hres))
            return hres;
    }
 
    if((flags & EXEC_EVAL) && scope) {
        variable_obj = jsdisp_addref(ctx->call_ctx->variable_obj);
    }else if(!(flags & (EXEC_GLOBAL | EXEC_EVAL))) {
        hres = create_dispex(ctx, NULL, NULL, &variable_obj);
        if(FAILED(hres)) return hres;
    }else if(bytecode->named_item) {
        variable_obj = jsdisp_addref(bytecode->named_item->script_obj);
    }else {
        variable_obj = jsdisp_addref(ctx->global);
    }
 
    if(flags & (EXEC_GLOBAL | EXEC_EVAL)) {
        named_item_t *item = bytecode->named_item;
        DISPID id;
 
        for(i=0; i < function->var_cnt; i++) {
            TRACE("[%d] %s %d\n", i, debugstr_w(function->variables[i].name), function->variables[i].func_id);
            if(function->variables[i].func_id != -1) {
                jsdisp_t *func_obj;
 
                if (function->funcs[function->variables[i].func_id].scope_index && flags & EXEC_EVAL)
                {
                    /* TODO: Add tests and handle in interp_push_scope(). */
                    FIXME("Functions with scope index inside eval() are not properly handled.\n");
                }
 
                hres = create_source_function(ctx, bytecode, function->funcs+function->variables[i].func_id, scope, &func_obj);
                if(FAILED(hres))
                    goto fail;
 
                hres = jsdisp_propput_name(variable_obj, function->variables[i].name, jsval_obj(func_obj));
                jsdisp_release(func_obj);
                continue;
            }
 
            if(item && !(item->flags & SCRIPTITEM_CODEONLY)
                && SUCCEEDED(disp_get_id(ctx, item->disp, function->variables[i].name, function->variables[i].name, 0, &id)))
                    continue;
 
            if(!item && (flags & EXEC_GLOBAL) && lookup_global_members(ctx, function->variables[i].name, NULL))
                continue;
 
            hres = jsdisp_get_id(variable_obj, function->variables[i].name, fdexNameEnsure, &id);
            if(FAILED(hres))
                goto fail;
        }
    }
 
    if(this_obj) {
        jsdisp_t *jsthis = to_jsdisp(this_obj);
 
        if(jsthis && jsthis->builtin_info->class == JSCLASS_GLOBAL)
            this_obj = NULL;
    }
 
    if(scope && (flags & EXEC_EVAL)) {
        hres = detach_variable_object(ctx, ctx->call_ctx, FALSE);
        if(FAILED(hres))
            goto fail;
    }
 
    frame = calloc(1, sizeof(*frame));
    if(!frame) {
        hres = E_OUTOFMEMORY;
        goto fail;
    }
 
    frame->function = function;
    frame->ret = jsval_undefined();
    frame->argc = argc;
    frame->bytecode = bytecode_addref(bytecode);
 
    if(!(flags & (EXEC_GLOBAL|EXEC_EVAL))) {
        hres = setup_scope(ctx, frame, scope, variable_obj, argc, argv);
        if(FAILED(hres)) {
            release_bytecode(frame->bytecode);
            free(frame);
            goto fail;
        }
    }else if(scope) {
        frame->base_scope = frame->scope = scope_addref(scope);
    }
 
    frame->ip = function->instr_off;
    frame->stack_base = ctx->stack_top;
    if(this_obj) {
        frame->this_obj = this_obj;
        IDispatch_AddRef(frame->this_obj);
    }
 
    if(function_instance)
        frame->function_instance = jsdisp_addref(function_instance);
 
    frame->flags = flags;
    frame->variable_obj = variable_obj;
 
    frame->prev_frame = ctx->call_ctx;
    ctx->call_ctx = frame;
 
    if(flags & EXEC_RETURN_TO_INTERP) {
        /*
         * We're called directly from interpreter, so we may just setup call frame and return.
         * Already running interpreter will take care of execution.
         */
        if(r)
            *r = jsval_undefined();
        return S_OK;
    }
 
    return enter_bytecode(ctx, r);
 
fail:
    jsdisp_release(variable_obj);
    return hres;
}

Referenced by builtin_eval(), exec_global_code(), and InterpretedFunction_call().

get_location_line()

unsigned get_location_line	(	bytecode_t *	code,
		unsigned	loc,
		unsigned *	char_pos
	)

Definition at line 2445 of file compile.c.

{
    unsigned line = code->start_line;
    const WCHAR *nl, *p;
 
    for(nl = p = code->source; p < code->source + loc; p++) {
        if(*p != '\n') continue;
        line++;
        nl = p + 1;
    }
    *char_pos = loc - (nl - code->source);
    return line;
}

Referenced by JScriptError_GetSourcePosition(), and print_backtrace().

leave_script()

HRESULT leave_script	(	script_ctx_t *	ctx,
		HRESULT	result
	)

Definition at line 348 of file jscript.c.

{
    jsexcept_t *ei = ctx->ei;
    BOOL enter_notified = ei->enter_notified;
    JScriptError *error;
 
    TRACE("ctx %p ei %p prev %p\n", ctx, ei, ei->prev);
 
    ctx->ei = ei->prev;
    if(result == DISP_E_EXCEPTION) {
        result = ei->error;
    }else {
        reset_ei(ei);
        ei->error = result;
    }
    if(FAILED(result)) {
        WARN("%08lx\n", result);
        if(ctx->site && (error = malloc(sizeof(*error)))) {
            HRESULT hres;
 
            error->IActiveScriptError_iface.lpVtbl = &JScriptErrorVtbl;
            error->ref = 1;
            error->ei = *ei;
            memset(ei, 0, sizeof(*ei));
 
            hres = IActiveScriptSite_OnScriptError(ctx->site, &error->IActiveScriptError_iface);
            IActiveScriptError_Release(&error->IActiveScriptError_iface);
            if(hres == S_OK)
                result = SCRIPT_E_REPORTED;
        }
    }
    if(enter_notified && ctx->site)
        IActiveScriptSite_OnLeaveScript(ctx->site);
    reset_ei(ei);
    return result;
}

Referenced by DispatchEx_InvokeEx(), exec_queued_code(), JScriptParse_ParseScriptText(), JScriptParseProcedure_ParseProcedureText(), variant_change_type(), and VariantChangeType_ChangeType().

lookup_global_host()

IDispatch * lookup_global_host

(

script_ctx_t *

ctx

)

Definition at line 845 of file engine.c.

{
    IDispatch *disp = NULL;
    named_item_t *item;
 
    LIST_FOR_EACH_ENTRY(item, &ctx->named_items, named_item_t, entry) {
        if(!(item->flags & SCRIPTITEM_GLOBALMEMBERS)) continue;
        disp = item->disp;
        break;
    }
    if(!disp) disp = to_disp(ctx->global);
 
    return disp;
}

Referenced by HostFunction_call(), interp_this(), and WineJSDispatch_GetScriptGlobal().

lookup_local()

local_ref_t * lookup_local	(	const function_code_t *	function,
		const WCHAR *	identifier,
		unsigned int	scope
	)

Definition at line 865 of file engine.c.

{
    return bsearch(identifier, function->local_scopes[scope].locals, function->local_scopes[scope].locals_cnt,
            sizeof(*function->local_scopes[scope].locals), local_ref_cmp);
}

Referenced by bind_local(), compile_function(), get_detached_var_ref(), and identifier_eval().

release_bytecode()

void release_bytecode

(

bytecode_t *

code

)

Definition at line 2459 of file compile.c.

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

Referenced by builtin_eval(), clear_persistent_code_list(), clear_script_queue(), compile_script(), construct_function(), exec_source(), init_code(), InterpretedFunction_destructor(), JScriptParse_ParseScriptText(), JScriptParseProcedure_ParseProcedureText(), pop_call_frame(), reset_ei(), scope_destructor(), and ScriptTypeInfo_Release().

reset_ei()

void reset_ei

(

jsexcept_t *

ei

)

Definition at line 314 of file jscript.c.

{
    ei->error = S_OK;
    if(ei->valid_value) {
        jsval_release(ei->value);
        ei->valid_value = FALSE;
    }
    if(ei->code) {
        release_bytecode(ei->code);
        ei->code = NULL;
        ei->loc = 0;
    }
    if(ei->source) {
        jsstr_release(ei->source);
        ei->source = NULL;
    }
    if(ei->message) {
        jsstr_release(ei->message);
        ei->message = NULL;
    }
    if(ei->line) {
        jsstr_release(ei->line);
        ei->line = NULL;
    }
}

Referenced by handle_dispatch_exception(), JScriptError_Release(), leave_script(), set_error_value(), and throw_error().

scope_addref()

static scope_chain_t * scope_addref ( scope_chain_t *  scope )

inlinestatic

Definition at line 242 of file engine.h.

{
    jsdisp_addref(&scope->dispex);
    return scope;
}

Referenced by create_source_function(), exec_source(), scope_push(), and setup_arguments_object().

scope_release()

static void scope_release ( scope_chain_t *  scope )

inlinestatic

Definition at line 248 of file engine.h.

{
    jsdisp_release(&scope->dispex);
}

Referenced by Arguments_destructor(), detach_arguments_object(), InterpretedFunction_destructor(), pop_call_frame(), scope_destructor(), scope_pop(), and setup_scope().

set_error_location()

void set_error_location	(	jsexcept_t *	ei,
		bytecode_t *	code,
		unsigned	loc,
		unsigned	source_id,
		jsstr_t *	line
	)

Definition at line 426 of file error.c.

{
    if(is_jscript_error(ei->error)) {
        if(!ei->source) {
            const WCHAR *res;
            size_t len;
 
            len = LoadStringW(jscript_hinstance, source_id, (WCHAR*)&res, 0);
            ei->source = jsstr_alloc_len(res, len);
        }
        if(!ei->message)
            ei->message = format_error_message(ei->error, NULL);
    }
 
    TRACE("source %s in %s\n", debugstr_w(code->source + loc), debugstr_w(code->source));
 
    ei->code = bytecode_addref(code);
    ei->loc = loc;
    if(line)
        ei->line = jsstr_addref(line);
}

Referenced by compile_script(), and unwind_exception().

setup_arguments_object()

HRESULT setup_arguments_object	(	script_ctx_t *	ctx,
		call_frame_t *	frame
	)

Definition at line 259 of file function.c.

{
    ArgumentsInstance *args;
    HRESULT hres;
 
    args = calloc(1, sizeof(*args));
    if(!args)
        return E_OUTOFMEMORY;
 
    hres = init_dispex_from_constr(&args->jsdisp, ctx, ctx->version < SCRIPTLANGUAGEVERSION_ES5 ? &Arguments_info : &Arguments_ES5_info, ctx->object_constr);
    if(FAILED(hres)) {
        free(args);
        return hres;
    }
 
    args->argc = frame->argc;
    args->scope = scope_addref(frame->base_scope);
 
    hres = jsdisp_define_data_property(&args->jsdisp, L"length", PROPF_WRITABLE | PROPF_CONFIGURABLE,
                                       jsval_number(args->argc));
    if(SUCCEEDED(hres))
        hres = jsdisp_define_data_property(&args->jsdisp, L"callee", PROPF_WRITABLE | PROPF_CONFIGURABLE,
                                           jsval_obj(frame->function_instance));
    if(SUCCEEDED(hres))
        hres = jsdisp_propput(as_jsdisp(frame->base_scope->obj), L"arguments", PROPF_WRITABLE, TRUE, jsval_obj(&args->jsdisp));
    if(FAILED(hres)) {
        jsdisp_release(&args->jsdisp);
        return hres;
    }
 
    frame->arguments_obj = &args->jsdisp;
    return S_OK;
}

Referenced by Arguments_get_caller(), detach_variable_object(), and Function_get_arguments().