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	_function_code_t
struct	_bytecode_t
struct	_scope_chain_t
struct	_call_frame_t

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

Typedefs
typedef struct _function_code_t	function_code_t
typedef struct _bytecode_t	bytecode_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 }
enum	property_definition_type_t { PROPERTY_DEFINITION_VALUE , PROPERTY_DEFINITION_GETTER , PROPERTY_DEFINITION_SETTER }

Functions
local_ref_t *	lookup_local (const function_code_t *, const WCHAR *) DECLSPEC_HIDDEN
HRESULT	compile_script (script_ctx_t *, const WCHAR *, const WCHAR *, const WCHAR *, BOOL, BOOL, bytecode_t **) DECLSPEC_HIDDEN
void	release_bytecode (bytecode_t *) DECLSPEC_HIDDEN
static bytecode_t *	bytecode_addref (bytecode_t *code)
void	scope_release (scope_chain_t *) DECLSPEC_HIDDEN
static scope_chain_t *	scope_addref (scope_chain_t *scope)
HRESULT	exec_source (script_ctx_t *, DWORD, bytecode_t *, function_code_t *, scope_chain_t *, IDispatch *, jsdisp_t *, jsdisp_t *, unsigned, jsval_t *, jsval_t *) DECLSPEC_HIDDEN
HRESULT	create_source_function (script_ctx_t *, bytecode_t *, function_code_t *, scope_chain_t *, jsdisp_t **) DECLSPEC_HIDDEN
HRESULT	setup_arguments_object (script_ctx_t *, call_frame_t *) DECLSPEC_HIDDEN
void	detach_arguments_object (jsdisp_t *) DECLSPEC_HIDDEN

Macro Definition Documentation

EXEC_CONSTRUCTOR

#define EXEC_CONSTRUCTOR   0x0002

Definition at line 249 of file engine.h.

EXEC_EVAL

#define EXEC_EVAL   0x0008

Definition at line 251 of file engine.h.

EXEC_GLOBAL

#define EXEC_GLOBAL   0x0001

Definition at line 248 of file engine.h.

EXEC_RETURN_TO_INTERP

#define EXEC_RETURN_TO_INTERP   0x0004

Definition at line 250 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 102 of file engine.h.

Typedef Documentation

bytecode_t

typedef struct _bytecode_t bytecode_t

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 218 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

Definition at line 115 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 101 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 134 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 196 of file engine.h.

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

Referenced by create_source_function(), and exec_source().

compile_script()

HRESULT compile_script	(	script_ctx_t *	ctx,
		const WCHAR *	code,
		const WCHAR *	args,
		const WCHAR *	delimiter,
		BOOL	from_eval,
		BOOL	use_decode,
		bytecode_t **	ret
	)

Definition at line 2461 of file compile.c.

{
    compiler_ctx_t compiler = {0};
    HRESULT hres;
 
    hres = init_code(&compiler, code);
    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->source, 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);
    heap_pool_free(&compiler.heap);
    parser_release(compiler.parser);
    if(FAILED(hres)) {
        release_bytecode(compiler.code);
        return hres;
    }
 
    *ret = compiler.code;
    return S_OK;
}

Referenced by compile_procedure(), construct_function(), JScriptParse_ParseScriptText(), JScriptParseProcedure_ParseProcedureText(), JSGlobal_eval(), 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 767 of file function.c.

{
    InterpretedFunction *function;
    jsdisp_t *prototype;
    HRESULT hres;
 
    hres = create_object(ctx, NULL, &prototype);
    if(FAILED(hres))
        return hres;
 
    hres = create_function(ctx, NULL, &InterpretedFunctionVtbl, sizeof(InterpretedFunction), PROPF_CONSTR,
                           FALSE, NULL, (void**)&function);
    if(SUCCEEDED(hres)) {
        hres = jsdisp_define_data_property(&function->function.dispex, prototypeW, PROPF_WRITABLE,
                                           jsval_obj(prototype));
        if(SUCCEEDED(hres))
            hres = set_constructor_prop(ctx, &function->function.dispex, prototype);
        if(FAILED(hres))
            jsdisp_release(&function->function.dispex);
    }
    jsdisp_release(prototype);
    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(), and setup_scope().

detach_arguments_object()

void detach_arguments_object

(

jsdisp_t *

args_disp

)

Definition at line 229 of file function.c.

{
    ArgumentsInstance *arguments = arguments_from_jsdisp(args_disp);
    call_frame_t *frame = arguments->frame;
    const BOOL on_stack = frame->base_scope->frame == frame;
    HRESULT hres;
 
    /* 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(frame->base_scope->jsobj, argumentsW, jsval_undefined());
    arguments->frame = NULL;
 
    /* Don't bother coppying arguments if call frame holds the last reference. */
    if(arguments->jsdisp.ref > 1) {
        arguments->buf = heap_alloc(arguments->argc * sizeof(*arguments->buf));
        if(arguments->buf) {
            int i;
 
            for(i = 0; i < arguments->argc ; i++) {
                if(on_stack || i >= frame->function->param_cnt)
                    hres = jsval_copy(arguments->jsdisp.ctx->stack[frame->arguments_off + i], arguments->buf+i);
                else
                    hres = jsdisp_propget_name(frame->base_scope->jsobj, frame->function->params[i], arguments->buf+i);
                if(FAILED(hres))
                    arguments->buf[i] = jsval_undefined();
            }
        }else {
            ERR("out of memory\n");
            arguments->argc = 0;
        }
    }
 
    jsdisp_release(frame->arguments_obj);
}

Referenced by pop_call_frame().

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,
		jsdisp_t *	variable_obj,
		unsigned	argc,
		jsval_t *	argv,
		jsval_t *	r
	)

Definition at line 2958 of file engine.c.

{
    call_frame_t *frame;
    unsigned i;
    HRESULT hres;
 
    for(i = 0; i < function->func_cnt; i++) {
        jsdisp_t *func_obj;
 
        if(!function->funcs[i].event_target)
            continue;
 
        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_GLOBAL | EXEC_EVAL)) {
        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;
 
                hres = create_source_function(ctx, bytecode, function->funcs+function->variables[i].func_id, scope, &func_obj);
                if(FAILED(hres))
                    return hres;
 
                hres = jsdisp_propput_name(variable_obj, function->variables[i].name, jsval_obj(func_obj));
                jsdisp_release(func_obj);
            }else if(!(flags & EXEC_GLOBAL) || !lookup_global_members(ctx, function->variables[i].name, NULL)) {
                DISPID id = 0;
 
                hres = jsdisp_get_id(variable_obj, function->variables[i].name, fdexNameEnsure, &id);
                if(FAILED(hres))
                    return hres;
            }
        }
    }
 
    /* ECMA-262 3rd Edition    11.2.3.7 */
    if(this_obj) {
        jsdisp_t *jsthis;
 
        jsthis = iface_to_jsdisp(this_obj);
        if(jsthis) {
            if(jsthis->builtin_info->class == JSCLASS_GLOBAL || jsthis->builtin_info->class == JSCLASS_NONE)
                this_obj = NULL;
            jsdisp_release(jsthis);
        }
    }
 
    if(ctx->call_ctx && (flags & EXEC_EVAL)) {
        hres = detach_variable_object(ctx, ctx->call_ctx, FALSE);
        if(FAILED(hres))
            return hres;
    }
 
    frame = heap_alloc_zero(sizeof(*frame));
    if(!frame)
        return E_OUTOFMEMORY;
 
    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);
            heap_free(frame);
            return hres;
        }
    }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;
    else if(ctx->host_global)
        frame->this_obj = ctx->host_global;
    else
        frame->this_obj = to_disp(ctx->global);
    IDispatch_AddRef(frame->this_obj);
 
    if(function_instance)
        frame->function_instance = jsdisp_addref(function_instance);
 
    frame->flags = flags;
    frame->variable_obj = jsdisp_addref(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);
}

Referenced by exec_global_code(), InterpretedFunction_call(), JScriptParse_ParseScriptText(), and JSGlobal_eval().

lookup_local()

local_ref_t * lookup_local	(	const function_code_t *	function,
		const WCHAR *	identifier
	)

Definition at line 629 of file engine.c.

{
    return bsearch(identifier, function->locals, function->locals_cnt, sizeof(*function->locals), local_ref_cmp);
}

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

release_bytecode()

void release_bytecode

(

bytecode_t *

code

)

Definition at line 2226 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]);
 
    heap_free(code->source);
    heap_pool_free(&code->heap);
    heap_free(code->bstr_pool);
    heap_free(code->str_pool);
    heap_free(code->instrs);
    heap_free(code);
}

Referenced by clear_script_queue(), compile_script(), construct_function(), exec_source(), init_code(), InterpretedFunction_destructor(), JScriptParse_ParseScriptText(), JScriptParseProcedure_ParseProcedureText(), JSGlobal_eval(), and pop_call_frame().

scope_addref()

static scope_chain_t * scope_addref ( scope_chain_t *  scope )

inlinestatic

Definition at line 212 of file engine.h.

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

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

scope_release()

void scope_release

(

scope_chain_t *

scope

)

Definition at line 437 of file engine.c.

{
    if(--scope->ref)
        return;
 
    if(scope->next)
        scope_release(scope->next);
 
    IDispatch_Release(scope->obj);
    heap_free(scope);
}

Referenced by InterpretedFunction_destructor(), pop_call_frame(), scope_pop(), scope_release(), and setup_scope().

setup_arguments_object()

HRESULT setup_arguments_object	(	script_ctx_t *	ctx,
		call_frame_t *	frame
	)

Definition at line 192 of file function.c.

{
    ArgumentsInstance *args;
    HRESULT hres;
 
    static const WCHAR caleeW[] = {'c','a','l','l','e','e',0};
 
    args = heap_alloc_zero(sizeof(*args));
    if(!args)
        return E_OUTOFMEMORY;
 
    hres = init_dispex_from_constr(&args->jsdisp, ctx, &Arguments_info, ctx->object_constr);
    if(FAILED(hres)) {
        heap_free(args);
        return hres;
    }
 
    args->function = (InterpretedFunction*)function_from_jsdisp(jsdisp_addref(frame->function_instance));
    args->argc = frame->argc;
    args->frame = frame;
 
    hres = jsdisp_define_data_property(&args->jsdisp, lengthW, PROPF_WRITABLE | PROPF_CONFIGURABLE,
                                       jsval_number(args->argc));
    if(SUCCEEDED(hres))
        hres = jsdisp_define_data_property(&args->jsdisp, caleeW, PROPF_WRITABLE | PROPF_CONFIGURABLE,
                                           jsval_obj(&args->function->function.dispex));
    if(SUCCEEDED(hres))
        hres = jsdisp_propput(frame->base_scope->jsobj, argumentsW, PROPF_WRITABLE, jsval_obj(&args->jsdisp));
    if(FAILED(hres)) {
        jsdisp_release(&args->jsdisp);
        return hres;
    }
 
    frame->arguments_obj = &args->jsdisp;
    return S_OK;
}

Referenced by detach_variable_object(), and Function_get_arguments().