compile.c File Reference

#include <math.h>
#include <assert.h>
#include "jscript.h"
#include "engine.h"
#include "parser.h"
#include "wine/rbtree.h"
#include "wine/debug.h"

Include dependency graph for compile.c:

Go to the source code of this file.

Classes
struct	_statement_ctx_t
struct	function_local_t
struct	_compiler_ctx_t

Macros
#define	X(n, a, b, c)   {#n,b,c},
#define	LABEL_FLAG   0x80000000

Typedefs
typedef struct _statement_ctx_t	statement_ctx_t
typedef struct _compiler_ctx_t	compiler_ctx_t

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (jscript)
	WINE_DECLARE_DEBUG_CHANNEL (jscript_disas)
static void	dump_instr_arg (instr_arg_type_t type, instr_arg_t *arg)
static void	dump_code (compiler_ctx_t *ctx, unsigned off)
static HRESULT	compile_expression (compiler_ctx_t *, expression_t *, BOOL)
static HRESULT	compile_statement (compiler_ctx_t *, statement_ctx_t *, statement_t *)
static void *	compiler_alloc (bytecode_t *code, size_t size)
jsstr_t *	compiler_alloc_string_len (compiler_ctx_t *ctx, const WCHAR *str, unsigned len)
static jsstr_t *	compiler_alloc_string (compiler_ctx_t *ctx, const WCHAR *str)
static BOOL	ensure_bstr_slot (compiler_ctx_t *ctx)
static BSTR	compiler_alloc_bstr (compiler_ctx_t *ctx, const WCHAR *str)
static BSTR	compiler_alloc_bstr_len (compiler_ctx_t *ctx, const WCHAR *str, size_t len)
static unsigned	push_instr (compiler_ctx_t *ctx, jsop_t op)
static instr_t *	instr_ptr (compiler_ctx_t *ctx, unsigned off)
static HRESULT	push_instr_int (compiler_ctx_t *ctx, jsop_t op, LONG arg)
static HRESULT	push_instr_str (compiler_ctx_t *ctx, jsop_t op, jsstr_t *str)
static HRESULT	push_instr_str_uint (compiler_ctx_t *ctx, jsop_t op, jsstr_t *str, unsigned arg2)
static HRESULT	push_instr_bstr (compiler_ctx_t *ctx, jsop_t op, const WCHAR *arg)
static HRESULT	push_instr_bstr_uint (compiler_ctx_t *ctx, jsop_t op, const WCHAR *arg1, unsigned arg2)
static HRESULT	push_instr_uint_str (compiler_ctx_t *ctx, jsop_t op, unsigned arg1, const WCHAR *arg2)
static HRESULT	push_instr_double (compiler_ctx_t *ctx, jsop_t op, double arg)
static void	set_arg_uint (compiler_ctx_t *ctx, unsigned instr, unsigned arg)
static HRESULT	push_instr_uint (compiler_ctx_t *ctx, jsop_t op, unsigned arg)
static HRESULT	compile_binary_expression (compiler_ctx_t *ctx, binary_expression_t *expr, jsop_t op)
static HRESULT	compile_unary_expression (compiler_ctx_t *ctx, unary_expression_t *expr, jsop_t op)
static HRESULT	compile_member_expression (compiler_ctx_t *ctx, member_expression_t *expr)
static unsigned	alloc_label (compiler_ctx_t *ctx)
static void	label_set_addr (compiler_ctx_t *ctx, unsigned label)
static BOOL	is_memberid_expr (expression_type_t type)
static BOOL	bind_local (compiler_ctx_t *ctx, const WCHAR *identifier, int *ret_ref)
static HRESULT	emit_identifier_ref (compiler_ctx_t *ctx, const WCHAR *identifier, unsigned flags)
static HRESULT	emit_identifier (compiler_ctx_t *ctx, const WCHAR *identifier)
static HRESULT	compile_memberid_expression (compiler_ctx_t *ctx, expression_t *expr, unsigned flags)
static HRESULT	compile_increment_expression (compiler_ctx_t *ctx, unary_expression_t *expr, jsop_t op, int n)
static HRESULT	compile_comma_expression (compiler_ctx_t *ctx, binary_expression_t *expr, BOOL emit_ret)
static HRESULT	compile_logical_expression (compiler_ctx_t *ctx, binary_expression_t *expr, jsop_t op)
static HRESULT	compile_conditional_expression (compiler_ctx_t *ctx, conditional_expression_t *expr)
static HRESULT	compile_new_expression (compiler_ctx_t *ctx, call_expression_t *expr)
static HRESULT	compile_call_expression (compiler_ctx_t *ctx, call_expression_t *expr, BOOL emit_ret)
static HRESULT	compile_delete_expression (compiler_ctx_t *ctx, unary_expression_t *expr)
static HRESULT	compile_assign_expression (compiler_ctx_t *ctx, binary_expression_t *expr, jsop_t op)
static HRESULT	compile_typeof_expression (compiler_ctx_t *ctx, unary_expression_t *expr)
static HRESULT	compile_literal (compiler_ctx_t *ctx, literal_t *literal)
static HRESULT	literal_as_string (compiler_ctx_t *ctx, literal_t *literal, jsstr_t **str)
static HRESULT	compile_array_literal (compiler_ctx_t *ctx, array_literal_expression_t *expr)
static HRESULT	compile_object_literal (compiler_ctx_t *ctx, property_value_expression_t *expr)
static HRESULT	compile_function_expression (compiler_ctx_t *ctx, function_expression_t *expr, BOOL emit_ret)
static BOOL	is_loop_statement (statement_type_t type)
static HRESULT	compile_block_statement (compiler_ctx_t *ctx, statement_t *iter)
static HRESULT	compile_variable_list (compiler_ctx_t *ctx, variable_declaration_t *list)
static HRESULT	compile_var_statement (compiler_ctx_t *ctx, var_statement_t *stat)
static HRESULT	compile_expression_statement (compiler_ctx_t *ctx, expression_statement_t *stat)
static HRESULT	compile_if_statement (compiler_ctx_t *ctx, if_statement_t *stat)
static HRESULT	compile_while_statement (compiler_ctx_t *ctx, while_statement_t *stat)
static HRESULT	compile_for_statement (compiler_ctx_t *ctx, for_statement_t *stat)
static HRESULT	compile_forin_statement (compiler_ctx_t *ctx, forin_statement_t *stat)
static HRESULT	pop_to_stat (compiler_ctx_t *ctx, statement_ctx_t *stat_ctx)
static HRESULT	compile_continue_statement (compiler_ctx_t *ctx, branch_statement_t *stat)
static HRESULT	compile_break_statement (compiler_ctx_t *ctx, branch_statement_t *stat)
static HRESULT	compile_return_statement (compiler_ctx_t *ctx, expression_statement_t *stat)
static HRESULT	compile_with_statement (compiler_ctx_t *ctx, with_statement_t *stat)
static HRESULT	compile_labelled_statement (compiler_ctx_t *ctx, labelled_statement_t *stat)
static HRESULT	compile_switch_statement (compiler_ctx_t *ctx, switch_statement_t *stat)
static HRESULT	compile_throw_statement (compiler_ctx_t *ctx, expression_statement_t *stat)
static HRESULT	compile_try_statement (compiler_ctx_t *ctx, try_statement_t *stat)
static int	function_local_cmp (const void *key, const struct wine_rb_entry *entry)
static function_local_t *	find_local (compiler_ctx_t *ctx, const WCHAR *name)
static BOOL	alloc_local (compiler_ctx_t *ctx, BSTR name, int ref)
static BOOL	alloc_variable (compiler_ctx_t *ctx, const WCHAR *name)
static HRESULT	visit_function_expression (compiler_ctx_t *ctx, function_expression_t *expr)
static HRESULT	visit_expression (compiler_ctx_t *ctx, expression_t *expr)
static HRESULT	visit_variable_list (compiler_ctx_t *ctx, variable_declaration_t *list)
static HRESULT	visit_statement (compiler_ctx_t *, statement_t *)
static HRESULT	visit_block_statement (compiler_ctx_t *ctx, statement_t *iter)
static void	resolve_labels (compiler_ctx_t *ctx, unsigned off)
void	release_bytecode (bytecode_t *code)
static HRESULT	init_code (compiler_ctx_t *compiler, const WCHAR *source)
static HRESULT	compile_function (compiler_ctx_t *ctx, source_elements_t *source, function_expression_t *func_expr, BOOL from_eval, function_code_t *func)
static HRESULT	parse_arguments (compiler_ctx_t *ctx, const WCHAR *args, BSTR *arg_array, unsigned *args_size)
static HRESULT	compile_arguments (compiler_ctx_t *ctx, const WCHAR *args)
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)

Variables
struct {
const char *   op_str
instr_arg_type_t   arg1_type
instr_arg_type_t   arg2_type
}	instr_info []

Macro Definition Documentation

LABEL_FLAG

#define LABEL_FLAG   0x80000000

Definition at line 393 of file compile.c.

X

#define X	(		n,
			a,
			b,
			c
	)		{#n,b,c},

Typedef Documentation

compiler_ctx_t

typedef struct _compiler_ctx_t compiler_ctx_t

statement_ctx_t

typedef struct _statement_ctx_t statement_ctx_t

Function Documentation

alloc_label()

static unsigned alloc_label ( compiler_ctx_t *  ctx )

static

Definition at line 395 of file compile.c.

{
    if(!ctx->labels_size) {
        ctx->labels = heap_alloc(8 * sizeof(*ctx->labels));
        if(!ctx->labels)
            return 0;
        ctx->labels_size = 8;
    }else if(ctx->labels_size == ctx->labels_cnt) {
        unsigned *new_labels;

        new_labels = heap_realloc(ctx->labels, 2*ctx->labels_size*sizeof(*ctx->labels));
        if(!new_labels)
            return 0;

        ctx->labels = new_labels;
        ctx->labels_size *= 2;
    }

    return ctx->labels_cnt++ | LABEL_FLAG;
}

Referenced by compile_for_statement(), compile_forin_statement(), compile_labelled_statement(), compile_switch_statement(), and compile_while_statement().

alloc_local()

static BOOL alloc_local ( compiler_ctx_t *  ctx, BSTR  name, int  ref  )

static

Definition at line 1848 of file compile.c.

{
    function_local_t *local;

    local = heap_pool_alloc(&ctx->heap, sizeof(*local));
    if(!local)
        return FALSE;

    local->name = name;
    local->ref = ref;
    wine_rb_put(&ctx->locals, name, &local->entry);
    ctx->locals_cnt++;
    return TRUE;
}

Referenced by alloc_variable(), and compile_function().

alloc_variable()

static BOOL alloc_variable ( compiler_ctx_t *  ctx, const WCHAR *  name  )

static

Definition at line 1863 of file compile.c.

{
    BSTR ident;

    if(find_local(ctx, name))
        return TRUE;

    ident = compiler_alloc_bstr(ctx, name);
    if(!ident)
        return FALSE;

    return alloc_local(ctx, ident, ctx->func->var_cnt++);
}

Referenced by visit_function_expression(), and visit_variable_list().

bind_local()

static BOOL bind_local ( compiler_ctx_t *  ctx, const WCHAR *  identifier, int *  ret_ref  )

static

Definition at line 427 of file compile.c.

{
    statement_ctx_t *iter;
    local_ref_t *ref;

    for(iter = ctx->stat_ctx; iter; iter = iter->next) {
        if(iter->using_scope)
            return FALSE;
    }

    ref = lookup_local(ctx->func, identifier);
    if(!ref)
        return FALSE;

    *ret_ref = ref->ref;
    return TRUE;
}

Referenced by emit_identifier(), and emit_identifier_ref().

compile_arguments()

static HRESULT compile_arguments ( compiler_ctx_t *  ctx, const WCHAR *  args  )

static

Definition at line 2445 of file compile.c.

{
    HRESULT hres;

    hres = parse_arguments(ctx, args, NULL, &ctx->code->global_code.param_cnt);
    if(FAILED(hres))
        return hres;

    ctx->code->global_code.params = compiler_alloc(ctx->code,
            ctx->code->global_code.param_cnt * sizeof(*ctx->code->global_code.params));
    if(!ctx->code->global_code.params)
        return E_OUTOFMEMORY;

    return parse_arguments(ctx, args, ctx->code->global_code.params, NULL);
}

Referenced by compile_script().

compile_array_literal()

static HRESULT compile_array_literal ( compiler_ctx_t *  ctx, array_literal_expression_t *  expr  )

static

Definition at line 865 of file compile.c.

{
    unsigned length = 0;
    array_element_t *iter;
    unsigned array_instr;
    HRESULT hres;

    array_instr = push_instr(ctx, OP_carray);

    for(iter = expr->element_list; iter; iter = iter->next) {
        length += iter->elision;

        hres = compile_expression(ctx, iter->expr, TRUE);
        if(FAILED(hres))
            return hres;

        hres = push_instr_uint(ctx, OP_carray_set, length);
        if(FAILED(hres))
            return hres;

        length++;
    }

    instr_ptr(ctx, array_instr)->u.arg[0].uint = length + expr->length;
    return S_OK;
}

Referenced by compile_expression().

compile_assign_expression()

static HRESULT compile_assign_expression ( compiler_ctx_t *  ctx, binary_expression_t *  expr, jsop_t  op  )

static

Definition at line 729 of file compile.c.

{
    BOOL use_throw_path = FALSE;
    unsigned arg_cnt = 0;
    HRESULT hres;

    if(expr->expression1->type == EXPR_CALL) {
        call_expression_t *call_expr = (call_expression_t*)expr->expression1;
        argument_t *arg;

        if(is_memberid_expr(call_expr->expression->type) && call_expr->argument_list) {
            hres = compile_memberid_expression(ctx, call_expr->expression, fdexNameEnsure);
            if(FAILED(hres))
                return hres;

            for(arg = call_expr->argument_list; arg; arg = arg->next) {
                hres = compile_expression(ctx, arg->expr, TRUE);
                if(FAILED(hres))
                    return hres;
                arg_cnt++;
            }

            if(op != OP_LAST) {
                unsigned instr;

                /* We need to call the functions twice: to get the value and to set it.
                 * JavaScript interpreted functions may to modify value on the stack,
                 * but assignment calls are allowed only on external functions, so we
                 * may reuse the stack here. */
                instr = push_instr(ctx, OP_call_member);
                if(!instr)
                    return E_OUTOFMEMORY;
                instr_ptr(ctx, instr)->u.arg[0].uint = arg_cnt;
                instr_ptr(ctx, instr)->u.arg[1].lng = 1;

                if(!push_instr(ctx, OP_push_acc))
                    return E_OUTOFMEMORY;
            }
        }else {
            use_throw_path = TRUE;
        }
    }else if(is_memberid_expr(expr->expression1->type)) {
        hres = compile_memberid_expression(ctx, expr->expression1, fdexNameEnsure);
        if(FAILED(hres))
            return hres;
        if(op != OP_LAST && !push_instr(ctx, OP_refval))
            return E_OUTOFMEMORY;
    }else {
        use_throw_path = TRUE;
    }

    if(use_throw_path) {
        /* Illegal assignment: evaluate and throw */
        hres = compile_expression(ctx, expr->expression1, TRUE);
        if(FAILED(hres))
            return hres;

        hres = compile_expression(ctx, expr->expression2, TRUE);
        if(FAILED(hres))
            return hres;

        if(op != OP_LAST && !push_instr(ctx, op))
            return E_OUTOFMEMORY;

        return push_instr_uint(ctx, OP_throw_ref, JS_E_ILLEGAL_ASSIGN);
    }

    hres = compile_expression(ctx, expr->expression2, TRUE);
    if(FAILED(hres))
        return hres;

    if(op != OP_LAST && !push_instr(ctx, op))
        return E_OUTOFMEMORY;

    if(arg_cnt)
        return push_instr_uint(ctx, OP_assign_call, arg_cnt);

    if(!push_instr(ctx, OP_assign))
        return E_OUTOFMEMORY;

    return S_OK;
}

Referenced by compile_expression().

compile_binary_expression()

static HRESULT compile_binary_expression ( compiler_ctx_t *  ctx, binary_expression_t *  expr, jsop_t  op  )

static

Definition at line 355 of file compile.c.

{
    HRESULT hres;

    hres = compile_expression(ctx, expr->expression1, TRUE);
    if(FAILED(hres))
        return hres;

    hres = compile_expression(ctx, expr->expression2, TRUE);
    if(FAILED(hres))
        return hres;

    return push_instr(ctx, op) ? S_OK : E_OUTOFMEMORY;
}

Referenced by compile_expression().

compile_block_statement()

static HRESULT compile_block_statement ( compiler_ctx_t *  ctx, statement_t *  iter  )

static

Definition at line 1113 of file compile.c.

{
    HRESULT hres;

    while(iter) {
        hres = compile_statement(ctx, NULL, iter);
        if(FAILED(hres))
            return hres;

        iter = iter->next;
    }

    return S_OK;
}

Referenced by compile_function(), and compile_statement().

compile_break_statement()

static HRESULT compile_break_statement ( compiler_ctx_t *  ctx, branch_statement_t *  stat  )

static

Definition at line 1472 of file compile.c.

{
    statement_ctx_t *pop_ctx;
    HRESULT hres;

    if(stat->identifier) {
        for(pop_ctx = ctx->stat_ctx; pop_ctx; pop_ctx = pop_ctx->next) {
            if(pop_ctx->labelled_stat && !wcscmp(pop_ctx->labelled_stat->identifier, stat->identifier)) {
                assert(pop_ctx->break_label);
                break;
            }
        }

        if(!pop_ctx) {
            WARN("Label not found\n");
            return JS_E_LABEL_NOT_FOUND;
        }
    }else {
        for(pop_ctx = ctx->stat_ctx; pop_ctx; pop_ctx = pop_ctx->next) {
            if(pop_ctx->break_label && !pop_ctx->labelled_stat)
                break;
        }

        if(!pop_ctx) {
            WARN("Break outside loop\n");
            return JS_E_INVALID_BREAK;
        }
    }

    hres = pop_to_stat(ctx, pop_ctx->next);
    if(FAILED(hres))
        return hres;

    return push_instr_uint(ctx, OP_jmp, pop_ctx->break_label);
}

Referenced by compile_statement().

compile_call_expression()

static HRESULT compile_call_expression ( compiler_ctx_t *  ctx, call_expression_t *  expr, BOOL  emit_ret  )

static

Definition at line 628 of file compile.c.

{
    unsigned arg_cnt = 0, extra_args;
    argument_t *arg;
    unsigned instr;
    jsop_t op;
    HRESULT hres;

    if(is_memberid_expr(expr->expression->type)) {
        op = OP_call_member;
        extra_args = 2;
        hres = compile_memberid_expression(ctx, expr->expression, 0);
    }else {
        op = OP_call;
        extra_args = 1;
        hres = compile_expression(ctx, expr->expression, TRUE);
    }

    if(FAILED(hres))
        return hres;

    for(arg = expr->argument_list; arg; arg = arg->next) {
        hres = compile_expression(ctx, arg->expr, TRUE);
        if(FAILED(hres))
            return hres;
        arg_cnt++;
    }

    instr = push_instr(ctx, op);
    if(!instr)
        return E_OUTOFMEMORY;

    instr_ptr(ctx, instr)->u.arg[0].uint = arg_cnt;
    instr_ptr(ctx, instr)->u.arg[1].lng = emit_ret;

    hres = push_instr_uint(ctx, OP_pop, arg_cnt + extra_args);
    if(FAILED(hres))
        return hres;

    return !emit_ret || push_instr(ctx, OP_push_acc) ? S_OK : E_OUTOFMEMORY;
}

Referenced by compile_expression().

compile_comma_expression()

static HRESULT compile_comma_expression ( compiler_ctx_t *  ctx, binary_expression_t *  expr, BOOL  emit_ret  )

static

Definition at line 532 of file compile.c.

{
    HRESULT hres;

    hres = compile_expression(ctx, expr->expression1, FALSE);
    if(FAILED(hres))
        return hres;

    return compile_expression(ctx, expr->expression2, emit_ret);
}

Referenced by compile_expression().

compile_conditional_expression()

static HRESULT compile_conditional_expression ( compiler_ctx_t *  ctx, conditional_expression_t *  expr  )

static

Definition at line 566 of file compile.c.

{
    unsigned jmp_false, jmp_end;
    HRESULT hres;

    hres = compile_expression(ctx, expr->expression, TRUE);
    if(FAILED(hres))
        return hres;

    jmp_false = push_instr(ctx, OP_cnd_z);
    if(!jmp_false)
        return E_OUTOFMEMORY;

    hres = compile_expression(ctx, expr->true_expression, TRUE);
    if(FAILED(hres))
        return hres;

    jmp_end = push_instr(ctx, OP_jmp);
    if(!jmp_end)
        return E_OUTOFMEMORY;

    set_arg_uint(ctx, jmp_false, ctx->code_off);
    hres = push_instr_uint(ctx, OP_pop, 1);
    if(FAILED(hres))
        return hres;

    hres = compile_expression(ctx, expr->false_expression, TRUE);
    if(FAILED(hres))
        return hres;

    set_arg_uint(ctx, jmp_end, ctx->code_off);
    return S_OK;
}

Referenced by compile_expression().

compile_continue_statement()

static HRESULT compile_continue_statement ( compiler_ctx_t *  ctx, branch_statement_t *  stat  )

static

Definition at line 1419 of file compile.c.

{
    statement_ctx_t *pop_ctx;
    HRESULT hres;

    if(stat->identifier) {
        statement_t *label_stat;
        statement_ctx_t *iter;

        pop_ctx = NULL;

        for(iter = ctx->stat_ctx; iter; iter = iter->next) {
            if(iter->continue_label)
                pop_ctx = iter;
            if(iter->labelled_stat && !wcscmp(iter->labelled_stat->identifier, stat->identifier))
                break;
        }

        if(!iter) {
            WARN("Label not found\n");
            return JS_E_LABEL_NOT_FOUND;
        }

        /* Labelled continue are allowed only on loops */
        for(label_stat = iter->labelled_stat->statement;
            label_stat->type == STAT_LABEL;
            label_stat = ((labelled_statement_t*)label_stat)->statement);
        if(!is_loop_statement(label_stat->type)) {
            WARN("Label is not a loop\n");
            return JS_E_INVALID_CONTINUE;
        }

        assert(pop_ctx != NULL);
    }else {
        for(pop_ctx = ctx->stat_ctx; pop_ctx; pop_ctx = pop_ctx->next) {
            if(pop_ctx->continue_label)
                break;
        }

        if(!pop_ctx) {
            WARN("continue outside loop\n");
            return JS_E_INVALID_CONTINUE;
        }
    }

    hres = pop_to_stat(ctx, pop_ctx);
    if(FAILED(hres))
        return hres;

    return push_instr_uint(ctx, OP_jmp, pop_ctx->continue_label);
}

Referenced by compile_statement().

compile_delete_expression()

static HRESULT compile_delete_expression ( compiler_ctx_t *  ctx, unary_expression_t *  expr  )

static

Definition at line 670 of file compile.c.

{
    HRESULT hres;

    switch(expr->expression->type) {
    case EXPR_ARRAY: {
        binary_expression_t *array_expr = (binary_expression_t*)expr->expression;

        hres = compile_expression(ctx, array_expr->expression1, TRUE);
        if(FAILED(hres))
            return hres;

        hres = compile_expression(ctx, array_expr->expression2, TRUE);
        if(FAILED(hres))
            return hres;

        if(!push_instr(ctx, OP_delete))
            return E_OUTOFMEMORY;
        break;
    }
    case EXPR_MEMBER: {
        member_expression_t *member_expr = (member_expression_t*)expr->expression;
        jsstr_t *jsstr;

        hres = compile_expression(ctx, member_expr->expression, TRUE);
        if(FAILED(hres))
            return hres;

        /* FIXME: Potential optimization */
        jsstr = compiler_alloc_string(ctx, member_expr->identifier);
        if(!jsstr)
            return E_OUTOFMEMORY;

        hres = push_instr_str(ctx, OP_str, jsstr);
        if(FAILED(hres))
            return hres;

        if(!push_instr(ctx, OP_delete))
            return E_OUTOFMEMORY;
        break;
    }
    case EXPR_IDENT:
        return push_instr_bstr(ctx, OP_delete_ident, ((identifier_expression_t*)expr->expression)->identifier);
    default: {
        static const WCHAR fixmeW[] = {'F','I','X','M','E',0};

        WARN("invalid delete, unimplemented exception message\n");

        hres = compile_expression(ctx, expr->expression, TRUE);
        if(FAILED(hres))
            return hres;

        return push_instr_uint_str(ctx, OP_throw_type, JS_E_INVALID_DELETE, fixmeW);
    }
    }

    return S_OK;
}

Referenced by compile_expression().

compile_expression()

static HRESULT compile_expression ( compiler_ctx_t *  ctx, expression_t *  expr, BOOL  emit_ret  )

static

Definition at line 923 of file compile.c.

{
    HRESULT hres;

    switch(expr->type) {
    case EXPR_ADD:
        hres = compile_binary_expression(ctx, (binary_expression_t*)expr, OP_add);
        break;
    case EXPR_AND:
        hres = compile_logical_expression(ctx, (binary_expression_t*)expr, OP_cnd_z);
        break;
    case EXPR_ARRAY:
        hres = compile_binary_expression(ctx, (binary_expression_t*)expr, OP_array);
        break;
    case EXPR_ARRAYLIT:
        hres = compile_array_literal(ctx, (array_literal_expression_t*)expr);
        break;
    case EXPR_ASSIGN:
        hres = compile_assign_expression(ctx, (binary_expression_t*)expr, OP_LAST);
        break;
    case EXPR_ASSIGNADD:
        hres = compile_assign_expression(ctx, (binary_expression_t*)expr, OP_add);
        break;
    case EXPR_ASSIGNAND:
        hres = compile_assign_expression(ctx, (binary_expression_t*)expr, OP_and);
        break;
    case EXPR_ASSIGNSUB:
        hres = compile_assign_expression(ctx, (binary_expression_t*)expr, OP_sub);
        break;
    case EXPR_ASSIGNMUL:
        hres = compile_assign_expression(ctx, (binary_expression_t*)expr, OP_mul);
        break;
    case EXPR_ASSIGNDIV:
        hres = compile_assign_expression(ctx, (binary_expression_t*)expr, OP_div);
        break;
    case EXPR_ASSIGNMOD:
        hres = compile_assign_expression(ctx, (binary_expression_t*)expr, OP_mod);
        break;
    case EXPR_ASSIGNOR:
        hres = compile_assign_expression(ctx, (binary_expression_t*)expr, OP_or);
        break;
    case EXPR_ASSIGNLSHIFT:
        hres = compile_assign_expression(ctx, (binary_expression_t*)expr, OP_lshift);
        break;
    case EXPR_ASSIGNRSHIFT:
        hres = compile_assign_expression(ctx, (binary_expression_t*)expr, OP_rshift);
        break;
    case EXPR_ASSIGNRRSHIFT:
        hres = compile_assign_expression(ctx, (binary_expression_t*)expr, OP_rshift2);
        break;
    case EXPR_ASSIGNXOR:
        hres = compile_assign_expression(ctx, (binary_expression_t*)expr, OP_xor);
        break;
    case EXPR_BAND:
        hres = compile_binary_expression(ctx, (binary_expression_t*)expr, OP_and);
        break;
    case EXPR_BITNEG:
        hres = compile_unary_expression(ctx, (unary_expression_t*)expr, OP_bneg);
        break;
    case EXPR_BOR:
        hres = compile_binary_expression(ctx, (binary_expression_t*)expr, OP_or);
        break;
    case EXPR_CALL:
        return compile_call_expression(ctx, (call_expression_t*)expr, emit_ret);
    case EXPR_COMMA:
        return compile_comma_expression(ctx, (binary_expression_t*)expr, emit_ret);
    case EXPR_COND:
        hres = compile_conditional_expression(ctx, (conditional_expression_t*)expr);
        break;
    case EXPR_DELETE:
        hres = compile_delete_expression(ctx, (unary_expression_t*)expr);
        break;
    case EXPR_DIV:
        hres = compile_binary_expression(ctx, (binary_expression_t*)expr, OP_div);
        break;
    case EXPR_EQ:
        hres = compile_binary_expression(ctx, (binary_expression_t*)expr, OP_eq);
        break;
    case EXPR_EQEQ:
        hres = compile_binary_expression(ctx, (binary_expression_t*)expr, OP_eq2);
        break;
    case EXPR_FUNC:
        return compile_function_expression(ctx, (function_expression_t*)expr, emit_ret);
    case EXPR_GREATER:
        hres = compile_binary_expression(ctx, (binary_expression_t*)expr, OP_gt);
        break;
    case EXPR_GREATEREQ:
        hres = compile_binary_expression(ctx, (binary_expression_t*)expr, OP_gteq);
        break;
    case EXPR_IDENT:
        hres = emit_identifier(ctx, ((identifier_expression_t*)expr)->identifier);
        break;
    case EXPR_IN:
        hres = compile_binary_expression(ctx, (binary_expression_t*)expr, OP_in);
        break;
    case EXPR_INSTANCEOF:
        hres = compile_binary_expression(ctx, (binary_expression_t*)expr, OP_instanceof);
        break;
    case EXPR_LESS:
        hres = compile_binary_expression(ctx, (binary_expression_t*)expr, OP_lt);
        break;
    case EXPR_LESSEQ:
        hres = compile_binary_expression(ctx, (binary_expression_t*)expr, OP_lteq);
        break;
    case EXPR_LITERAL:
        hres = compile_literal(ctx, ((literal_expression_t*)expr)->literal);
        break;
    case EXPR_LOGNEG:
        hres = compile_unary_expression(ctx, (unary_expression_t*)expr, OP_neg);
        break;
    case EXPR_LSHIFT:
        hres = compile_binary_expression(ctx, (binary_expression_t*)expr, OP_lshift);
        break;
    case EXPR_MEMBER:
        hres = compile_member_expression(ctx, (member_expression_t*)expr);
        break;
    case EXPR_MINUS:
        hres = compile_unary_expression(ctx, (unary_expression_t*)expr, OP_minus);
        break;
    case EXPR_MOD:
        hres = compile_binary_expression(ctx, (binary_expression_t*)expr, OP_mod);
        break;
    case EXPR_MUL:
        hres = compile_binary_expression(ctx, (binary_expression_t*)expr, OP_mul);
        break;
    case EXPR_NEW:
        hres = compile_new_expression(ctx, (call_expression_t*)expr);
        break;
    case EXPR_NOTEQ:
        hres = compile_binary_expression(ctx, (binary_expression_t*)expr, OP_neq);
        break;
    case EXPR_NOTEQEQ:
        hres = compile_binary_expression(ctx, (binary_expression_t*)expr, OP_neq2);
        break;
    case EXPR_OR:
        hres = compile_logical_expression(ctx, (binary_expression_t*)expr, OP_cnd_nz);
        break;
    case EXPR_PLUS:
        hres = compile_unary_expression(ctx, (unary_expression_t*)expr, OP_tonum);
        break;
    case EXPR_POSTDEC:
        hres = compile_increment_expression(ctx, (unary_expression_t*)expr, OP_postinc, -1);
        break;
    case EXPR_POSTINC:
        hres = compile_increment_expression(ctx, (unary_expression_t*)expr, OP_postinc, 1);
        break;
    case EXPR_PREDEC:
        hres = compile_increment_expression(ctx, (unary_expression_t*)expr, OP_preinc, -1);
        break;
    case EXPR_PREINC:
        hres = compile_increment_expression(ctx, (unary_expression_t*)expr, OP_preinc, 1);
        break;
    case EXPR_PROPVAL:
        hres = compile_object_literal(ctx, (property_value_expression_t*)expr);
        break;
    case EXPR_RSHIFT:
        hres = compile_binary_expression(ctx, (binary_expression_t*)expr, OP_rshift);
        break;
    case EXPR_RRSHIFT:
        hres = compile_binary_expression(ctx, (binary_expression_t*)expr, OP_rshift2);
        break;
    case EXPR_SUB:
        hres = compile_binary_expression(ctx, (binary_expression_t*)expr, OP_sub);
        break;
    case EXPR_THIS:
        return !emit_ret || push_instr(ctx, OP_this) ? S_OK : E_OUTOFMEMORY;
    case EXPR_TYPEOF:
        hres = compile_typeof_expression(ctx, (unary_expression_t*)expr);
        break;
    case EXPR_VOID:
        hres = compile_unary_expression(ctx, (unary_expression_t*)expr, OP_void);
        break;
    case EXPR_BXOR:
        hres = compile_binary_expression(ctx, (binary_expression_t*)expr, OP_xor);
        break;
    DEFAULT_UNREACHABLE;
    }

    if(FAILED(hres))
        return hres;

    return emit_ret ? S_OK : push_instr_uint(ctx, OP_pop, 1);
}

Referenced by compile_array_literal(), compile_assign_expression(), compile_binary_expression(), compile_call_expression(), compile_comma_expression(), compile_conditional_expression(), compile_delete_expression(), compile_expression_statement(), compile_for_statement(), compile_forin_statement(), compile_if_statement(), compile_increment_expression(), compile_logical_expression(), compile_member_expression(), compile_memberid_expression(), compile_new_expression(), compile_object_literal(), compile_return_statement(), compile_switch_statement(), compile_throw_statement(), compile_typeof_expression(), compile_unary_expression(), compile_variable_list(), compile_while_statement(), and compile_with_statement().

compile_expression_statement()

static HRESULT compile_expression_statement ( compiler_ctx_t *  ctx, expression_statement_t *  stat  )

static

Definition at line 1166 of file compile.c.

{
    HRESULT hres;

    hres = compile_expression(ctx, stat->expr, ctx->from_eval);
    if(FAILED(hres))
        return hres;

    return !ctx->from_eval || push_instr(ctx, OP_setret) ? S_OK : E_OUTOFMEMORY;
}

Referenced by compile_statement().

compile_for_statement()

static HRESULT compile_for_statement ( compiler_ctx_t *  ctx, for_statement_t *  stat  )

static

Definition at line 1268 of file compile.c.

{
    statement_ctx_t stat_ctx = {0, FALSE, FALSE};
    unsigned expr_off;
    HRESULT hres;

    if(stat->variable_list) {
        hres = compile_variable_list(ctx, stat->variable_list);
        if(FAILED(hres))
            return hres;
    }else if(stat->begin_expr) {
        hres = compile_expression(ctx, stat->begin_expr, FALSE);
        if(FAILED(hres))
            return hres;
    }

    stat_ctx.break_label = alloc_label(ctx);
    if(!stat_ctx.break_label)
        return E_OUTOFMEMORY;

    stat_ctx.continue_label = alloc_label(ctx);
    if(!stat_ctx.continue_label)
        return E_OUTOFMEMORY;

    expr_off = ctx->code_off;

    if(stat->expr) {
        hres = compile_expression(ctx, stat->expr, TRUE);
        if(FAILED(hres))
            return hres;

        hres = push_instr_uint(ctx, OP_jmp_z, stat_ctx.break_label);
        if(FAILED(hres))
            return hres;
    }

    hres = compile_statement(ctx, &stat_ctx, stat->statement);
    if(FAILED(hres))
        return hres;

    label_set_addr(ctx, stat_ctx.continue_label);

    if(stat->end_expr) {
        hres = compile_expression(ctx, stat->end_expr, FALSE);
        if(FAILED(hres))
            return hres;
    }

    hres = push_instr_uint(ctx, OP_jmp, expr_off);
    if(FAILED(hres))
        return hres;

    label_set_addr(ctx, stat_ctx.break_label);
    return S_OK;
}

Referenced by compile_statement().

compile_forin_statement()

static HRESULT compile_forin_statement ( compiler_ctx_t *  ctx, forin_statement_t *  stat  )

static

Definition at line 1325 of file compile.c.

{
    statement_ctx_t stat_ctx = {4, FALSE, FALSE};
    HRESULT hres;

    if(stat->variable) {
        hres = compile_variable_list(ctx, stat->variable);
        if(FAILED(hres))
            return hres;
    }

    stat_ctx.break_label = alloc_label(ctx);
    if(!stat_ctx.break_label)
        return E_OUTOFMEMORY;

    stat_ctx.continue_label = alloc_label(ctx);
    if(!stat_ctx.continue_label)
        return E_OUTOFMEMORY;

    hres = compile_expression(ctx, stat->in_expr, TRUE);
    if(FAILED(hres))
        return hres;

    if(stat->variable) {
        hres = emit_identifier_ref(ctx, stat->variable->identifier, fdexNameEnsure);
        if(FAILED(hres))
            return hres;
    }else if(is_memberid_expr(stat->expr->type)) {
        hres = compile_memberid_expression(ctx, stat->expr, fdexNameEnsure);
        if(FAILED(hres))
            return hres;
    }else {
        hres = push_instr_uint(ctx, OP_throw_ref, JS_E_ILLEGAL_ASSIGN);
        if(FAILED(hres))
            return hres;

        /* FIXME: compile statement anyways when we depend on compiler to check errors */
        return S_OK;
    }

    hres = push_instr_int(ctx, OP_int, DISPID_STARTENUM);
    if(FAILED(hres))
        return hres;

    label_set_addr(ctx, stat_ctx.continue_label);
    hres = push_instr_uint(ctx, OP_forin, stat_ctx.break_label);
    if(FAILED(hres))
        return E_OUTOFMEMORY;

    hres = compile_statement(ctx, &stat_ctx, stat->statement);
    if(FAILED(hres))
        return hres;

    hres = push_instr_uint(ctx, OP_jmp, stat_ctx.continue_label);
    if(FAILED(hres))
        return hres;

    label_set_addr(ctx, stat_ctx.break_label);
    return S_OK;
}

Referenced by compile_statement().

compile_function()

static HRESULT compile_function ( compiler_ctx_t *  ctx, source_elements_t *  source, function_expression_t *  func_expr, BOOL  from_eval, function_code_t *  func  )

static

Definition at line 2272 of file compile.c.

{
    function_expression_t *iter;
    function_local_t *local;
    unsigned off, i;
    HRESULT hres;

    TRACE("\n");

    ctx->func_head = ctx->func_tail = NULL;
    ctx->from_eval = from_eval;
    ctx->func = func;
    ctx->locals_cnt = 0;
    wine_rb_init(&ctx->locals, function_local_cmp);

    if(func_expr) {
        parameter_t *param_iter;

        if(func_expr->identifier) {
            func->name = compiler_alloc_bstr(ctx, func_expr->identifier);
            if(!func->name)
                return E_OUTOFMEMORY;
        }

        if(func_expr->event_target) {
            func->event_target = compiler_alloc_bstr(ctx, func_expr->event_target);
            if(!func->event_target)
                return E_OUTOFMEMORY;
        }

        func->source = func_expr->src_str;
        func->source_len = func_expr->src_len;

        for(param_iter = func_expr->parameter_list; param_iter; param_iter = param_iter->next)
            func->param_cnt++;

        func->params = compiler_alloc(ctx->code, func->param_cnt * sizeof(*func->params));
        if(!func->params)
            return E_OUTOFMEMORY;

        for(param_iter = func_expr->parameter_list, i=0; param_iter; param_iter = param_iter->next, i++) {
            func->params[i] = compiler_alloc_bstr(ctx, param_iter->identifier);
            if(!func->params[i])
                return E_OUTOFMEMORY;
        }
    }

    for(i = 0; i < func->param_cnt; i++) {
        if(!find_local(ctx, func->params[i]) && !alloc_local(ctx, func->params[i], -i-1))
            return E_OUTOFMEMORY;
    }

    hres = visit_block_statement(ctx, source->statement);
    if(FAILED(hres))
        return hres;

    func->locals = compiler_alloc(ctx->code, ctx->locals_cnt * sizeof(*func->locals));
    if(!func->locals)
        return E_OUTOFMEMORY;
    func->locals_cnt = ctx->locals_cnt;

    func->variables = compiler_alloc(ctx->code, func->var_cnt * sizeof(*func->variables));
    if(!func->variables)
        return E_OUTOFMEMORY;

    i = 0;
    WINE_RB_FOR_EACH_ENTRY(local, &ctx->locals, function_local_t, entry) {
        func->locals[i].name = local->name;
        func->locals[i].ref = local->ref;
        if(local->ref >= 0) {
            func->variables[local->ref].name = local->name;
            func->variables[local->ref].func_id = -1;
        }
        i++;
    }
    assert(i == ctx->locals_cnt);

    func->funcs = compiler_alloc(ctx->code, func->func_cnt * sizeof(*func->funcs));
    if(!func->funcs)
        return E_OUTOFMEMORY;
    memset(func->funcs, 0, func->func_cnt * sizeof(*func->funcs));

    off = ctx->code_off;
    hres = compile_block_statement(ctx, source->statement);
    if(FAILED(hres))
        return hres;

    resolve_labels(ctx, off);

    hres = push_instr_uint(ctx, OP_ret, !from_eval);
    if(FAILED(hres))
        return hres;

    if(TRACE_ON(jscript_disas))
        dump_code(ctx, off);

    func->instr_off = off;

    for(iter = ctx->func_head, i=0; iter; iter = iter->next, i++) {
        hres = compile_function(ctx, iter->source_elements, iter, FALSE, func->funcs+i);
        if(FAILED(hres))
            return hres;

        TRACE("[%d] func %s\n", i, debugstr_w(func->funcs[i].name));
        if(func->funcs[i].name && !func->funcs[i].event_target) {
            local_ref_t *local_ref = lookup_local(func, func->funcs[i].name);
            func->funcs[i].local_ref = local_ref->ref;
            TRACE("found ref %s %d for %s\n", debugstr_w(local_ref->name), local_ref->ref, debugstr_w(func->funcs[i].name));
            if(local_ref->ref >= 0)
                func->variables[local_ref->ref].func_id = i;
        }
    }

    assert(i == func->func_cnt);

    return S_OK;
}

Referenced by compile_script().

compile_function_expression()

static HRESULT compile_function_expression ( compiler_ctx_t *  ctx, function_expression_t *  expr, BOOL  emit_ret  )

static

Definition at line 918 of file compile.c.

{
    return emit_ret ? push_instr_uint(ctx, OP_func, expr->func_id) : S_OK;
}

Referenced by compile_expression().

compile_if_statement()

static HRESULT compile_if_statement ( compiler_ctx_t *  ctx, if_statement_t *  stat  )

static

Definition at line 1178 of file compile.c.

{
    unsigned jmp_else;
    HRESULT hres;

    hres = compile_expression(ctx, stat->expr, TRUE);
    if(FAILED(hres))
        return hres;

    jmp_else = push_instr(ctx, OP_jmp_z);
    if(!jmp_else)
        return E_OUTOFMEMORY;

    hres = compile_statement(ctx, NULL, stat->if_stat);
    if(FAILED(hres))
        return hres;

    if(stat->else_stat) {
        unsigned jmp_end;

        jmp_end = push_instr(ctx, OP_jmp);
        if(!jmp_end)
            return E_OUTOFMEMORY;

        set_arg_uint(ctx, jmp_else, ctx->code_off);

        hres = compile_statement(ctx, NULL, stat->else_stat);
        if(FAILED(hres))
            return hres;

        set_arg_uint(ctx, jmp_end, ctx->code_off);
    }else {
        set_arg_uint(ctx, jmp_else, ctx->code_off);
    }

    return S_OK;
}

Referenced by compile_statement().

compile_increment_expression()

static HRESULT compile_increment_expression ( compiler_ctx_t *  ctx, unary_expression_t *  expr, jsop_t  op, int  n  )

static

Definition at line 512 of file compile.c.

{
    HRESULT hres;

    if(!is_memberid_expr(expr->expression->type)) {
        hres = compile_expression(ctx, expr->expression, TRUE);
        if(FAILED(hres))
            return hres;

        return push_instr_uint(ctx, OP_throw_ref, JS_E_ILLEGAL_ASSIGN);
    }

    hres = compile_memberid_expression(ctx, expr->expression, fdexNameEnsure);
    if(FAILED(hres))
        return hres;

    return push_instr_int(ctx, op, n);
}

Referenced by compile_expression().

compile_labelled_statement()

static HRESULT compile_labelled_statement ( compiler_ctx_t *  ctx, labelled_statement_t *  stat  )

static

Definition at line 1557 of file compile.c.

{
    statement_ctx_t stat_ctx = {0, FALSE, FALSE, 0, 0, stat}, *iter;
    HRESULT hres;

    for(iter = ctx->stat_ctx; iter; iter = iter->next) {
        if(iter->labelled_stat && !wcscmp(iter->labelled_stat->identifier, stat->identifier)) {
            WARN("Label %s redefined\n", debugstr_w(stat->identifier));
            return JS_E_LABEL_REDEFINED;
        }
    }

    /* Labelled breaks are allowed for any labelled statements, not only loops (violating spec) */
    stat_ctx.break_label = alloc_label(ctx);
    if(!stat_ctx.break_label)
        return E_OUTOFMEMORY;

    hres = compile_statement(ctx, &stat_ctx, stat->statement);
    if(FAILED(hres))
        return hres;

    label_set_addr(ctx, stat_ctx.break_label);
    return S_OK;
}

Referenced by compile_statement().

compile_literal()

static HRESULT compile_literal ( compiler_ctx_t *  ctx, literal_t *  literal  )

static

Definition at line 833 of file compile.c.

{
    switch(literal->type) {
    case LT_BOOL:
        return push_instr_int(ctx, OP_bool, literal->u.bval);
    case LT_DOUBLE:
        return push_instr_double(ctx, OP_double, literal->u.dval);
    case LT_NULL:
        return push_instr(ctx, OP_null) ? S_OK : E_OUTOFMEMORY;
    case LT_STRING:
        return push_instr_str(ctx, OP_str, literal->u.str);
    case LT_REGEXP:
        return push_instr_str_uint(ctx, OP_regexp, literal->u.regexp.str, literal->u.regexp.flags);
    DEFAULT_UNREACHABLE;
    }
    return E_FAIL;
}

Referenced by compile_expression().

compile_logical_expression()

static HRESULT compile_logical_expression ( compiler_ctx_t *  ctx, binary_expression_t *  expr, jsop_t  op  )

static

Definition at line 544 of file compile.c.

{
    unsigned instr;
    HRESULT hres;

    hres = compile_expression(ctx, expr->expression1, TRUE);
    if(FAILED(hres))
        return hres;

    instr = push_instr(ctx, op);
    if(!instr)
        return E_OUTOFMEMORY;

    hres = compile_expression(ctx, expr->expression2, TRUE);
    if(FAILED(hres))
        return hres;

    set_arg_uint(ctx, instr, ctx->code_off);
    return S_OK;
}

Referenced by compile_expression().

compile_member_expression()

static HRESULT compile_member_expression ( compiler_ctx_t *  ctx, member_expression_t *  expr  )

static

Definition at line 382 of file compile.c.

{
    HRESULT hres;

    hres = compile_expression(ctx, expr->expression, TRUE);
    if(FAILED(hres))
        return hres;

    return push_instr_bstr(ctx, OP_member, expr->identifier);
}

Referenced by compile_expression().

compile_memberid_expression()

static HRESULT compile_memberid_expression ( compiler_ctx_t *  ctx, expression_t *  expr, unsigned  flags  )

static

Definition at line 461 of file compile.c.

{
    HRESULT hres = S_OK;

    switch(expr->type) {
    case EXPR_IDENT: {
        identifier_expression_t *ident_expr = (identifier_expression_t*)expr;

        hres = emit_identifier_ref(ctx, ident_expr->identifier, flags);
        break;
    }
    case EXPR_ARRAY: {
        binary_expression_t *array_expr = (binary_expression_t*)expr;

        hres = compile_expression(ctx, array_expr->expression1, TRUE);
        if(FAILED(hres))
            return hres;

        hres = compile_expression(ctx, array_expr->expression2, TRUE);
        if(FAILED(hres))
            return hres;

        hres = push_instr_uint(ctx, OP_memberid, flags);
        break;
    }
    case EXPR_MEMBER: {
        member_expression_t *member_expr = (member_expression_t*)expr;
        jsstr_t *jsstr;

        hres = compile_expression(ctx, member_expr->expression, TRUE);
        if(FAILED(hres))
            return hres;

        /* FIXME: Potential optimization */
        jsstr = compiler_alloc_string(ctx, member_expr->identifier);
        if(!jsstr)
            return E_OUTOFMEMORY;

        hres = push_instr_str(ctx, OP_str, jsstr);
        if(FAILED(hres))
            return hres;

        hres = push_instr_uint(ctx, OP_memberid, flags);
        break;
    }
    DEFAULT_UNREACHABLE;
    }

    return hres;
}

Referenced by compile_assign_expression(), compile_call_expression(), compile_forin_statement(), compile_increment_expression(), and compile_typeof_expression().

compile_new_expression()

static HRESULT compile_new_expression ( compiler_ctx_t *  ctx, call_expression_t *  expr  )

static

Definition at line 600 of file compile.c.

{
    unsigned arg_cnt = 0;
    argument_t *arg;
    HRESULT hres;

    hres = compile_expression(ctx, expr->expression, TRUE);
    if(FAILED(hres))
        return hres;

    for(arg = expr->argument_list; arg; arg = arg->next) {
        hres = compile_expression(ctx, arg->expr, TRUE);
        if(FAILED(hres))
            return hres;
        arg_cnt++;
    }

    hres = push_instr_uint(ctx, OP_new, arg_cnt);
    if(FAILED(hres))
        return hres;

    hres = push_instr_uint(ctx, OP_pop, arg_cnt+1);
    if(FAILED(hres))
        return hres;

    return push_instr(ctx, OP_push_acc) ? S_OK : E_OUTOFMEMORY;
}

Referenced by compile_expression().

compile_object_literal()

static HRESULT compile_object_literal ( compiler_ctx_t *  ctx, property_value_expression_t *  expr  )

static

Definition at line 892 of file compile.c.

{
    property_definition_t *iter;
    jsstr_t *name;
    HRESULT hres;

    if(!push_instr(ctx, OP_new_obj))
        return E_OUTOFMEMORY;

    for(iter = expr->property_list; iter; iter = iter->next) {
        hres = literal_as_string(ctx, iter->name, &name);
        if(FAILED(hres))
            return hres;

        hres = compile_expression(ctx, iter->value, TRUE);
        if(FAILED(hres))
            return hres;

        hres = push_instr_str_uint(ctx, OP_obj_prop, name, iter->type);
        if(FAILED(hres))
            return hres;
    }

    return S_OK;
}

Referenced by compile_expression().

compile_return_statement()

static HRESULT compile_return_statement ( compiler_ctx_t *  ctx, expression_statement_t *  stat  )

static

Definition at line 1509 of file compile.c.

{
    HRESULT hres;

    if(ctx->from_eval) {
        WARN("misplaced return statement\n");
        return JS_E_MISPLACED_RETURN;
    }

    if(stat->expr) {
        hres = compile_expression(ctx, stat->expr, TRUE);
        if(FAILED(hres))
            return hres;
        if(!push_instr(ctx, OP_setret))
            return E_OUTOFMEMORY;
    }

    hres = pop_to_stat(ctx, NULL);
    if(FAILED(hres))
        return hres;

    return push_instr_uint(ctx, OP_ret, !stat->expr);
}

Referenced by compile_statement().

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().

compile_statement()

static HRESULT compile_statement ( compiler_ctx_t *  ctx, statement_ctx_t *  stat_ctx, statement_t *  stat  )

static

Definition at line 1766 of file compile.c.

{
    HRESULT hres;

    if(stat_ctx) {
        stat_ctx->next = ctx->stat_ctx;
        ctx->stat_ctx = stat_ctx;
    }

    switch(stat->type) {
    case STAT_BLOCK:
        hres = compile_block_statement(ctx, ((block_statement_t*)stat)->stat_list);
        break;
    case STAT_BREAK:
        hres = compile_break_statement(ctx, (branch_statement_t*)stat);
        break;
    case STAT_CONTINUE:
        hres = compile_continue_statement(ctx, (branch_statement_t*)stat);
        break;
    case STAT_EMPTY:
        /* nothing to do */
        hres = S_OK;
        break;
    case STAT_EXPR:
        hres = compile_expression_statement(ctx, (expression_statement_t*)stat);
        break;
    case STAT_FOR:
        hres = compile_for_statement(ctx, (for_statement_t*)stat);
        break;
    case STAT_FORIN:
        hres = compile_forin_statement(ctx, (forin_statement_t*)stat);
        break;
    case STAT_IF:
        hres = compile_if_statement(ctx, (if_statement_t*)stat);
        break;
    case STAT_LABEL:
        hres = compile_labelled_statement(ctx, (labelled_statement_t*)stat);
        break;
    case STAT_RETURN:
        hres = compile_return_statement(ctx, (expression_statement_t*)stat);
        break;
    case STAT_SWITCH:
        hres = compile_switch_statement(ctx, (switch_statement_t*)stat);
        break;
    case STAT_THROW:
        hres = compile_throw_statement(ctx, (expression_statement_t*)stat);
        break;
    case STAT_TRY:
        hres = compile_try_statement(ctx, (try_statement_t*)stat);
        break;
    case STAT_VAR:
        hres = compile_var_statement(ctx, (var_statement_t*)stat);
        break;
    case STAT_WHILE:
        hres = compile_while_statement(ctx, (while_statement_t*)stat);
        break;
    case STAT_WITH:
        hres = compile_with_statement(ctx, (with_statement_t*)stat);
        break;
    DEFAULT_UNREACHABLE;
    }

    if(stat_ctx) {
        assert(ctx->stat_ctx == stat_ctx);
        ctx->stat_ctx = stat_ctx->next;
    }

    return hres;
}

Referenced by compile_block_statement(), compile_for_statement(), compile_forin_statement(), compile_if_statement(), compile_labelled_statement(), compile_switch_statement(), compile_try_statement(), compile_while_statement(), and compile_with_statement().

compile_switch_statement()

static HRESULT compile_switch_statement ( compiler_ctx_t *  ctx, switch_statement_t *  stat  )

static

Definition at line 1583 of file compile.c.

{
    statement_ctx_t stat_ctx = {0, FALSE, FALSE};
    unsigned case_cnt = 0, *case_jmps, i, default_jmp;
    BOOL have_default = FALSE;
    statement_t *stat_iter;
    case_clausule_t *iter;
    HRESULT hres;

    hres = compile_expression(ctx, stat->expr, TRUE);
    if(FAILED(hres))
        return hres;

    stat_ctx.break_label = alloc_label(ctx);
    if(!stat_ctx.break_label)
        return E_OUTOFMEMORY;

    for(iter = stat->case_list; iter; iter = iter->next) {
        if(iter->expr)
            case_cnt++;
    }

    case_jmps = heap_alloc(case_cnt * sizeof(*case_jmps));
    if(!case_jmps)
        return E_OUTOFMEMORY;

    i = 0;
    for(iter = stat->case_list; iter; iter = iter->next) {
        if(!iter->expr) {
            have_default = TRUE;
            continue;
        }

        hres = compile_expression(ctx, iter->expr, TRUE);
        if(FAILED(hres))
            break;

        case_jmps[i] = push_instr(ctx, OP_case);
        if(!case_jmps[i]) {
            hres = E_OUTOFMEMORY;
            break;
        }
        i++;
    }

    if(SUCCEEDED(hres)) {
        hres = push_instr_uint(ctx, OP_pop, 1);
        if(SUCCEEDED(hres)) {
            default_jmp = push_instr(ctx, OP_jmp);
            if(!default_jmp)
                hres = E_OUTOFMEMORY;
        }
    }

    if(FAILED(hres)) {
        heap_free(case_jmps);
        return hres;
    }

    i = 0;
    for(iter = stat->case_list; iter; iter = iter->next) {
        while(iter->next && iter->next->stat == iter->stat) {
            set_arg_uint(ctx, iter->expr ? case_jmps[i++] : default_jmp, ctx->code_off);
            iter = iter->next;
        }

        set_arg_uint(ctx, iter->expr ? case_jmps[i++] : default_jmp, ctx->code_off);

        for(stat_iter = iter->stat; stat_iter && (!iter->next || iter->next->stat != stat_iter);
            stat_iter = stat_iter->next) {
            hres = compile_statement(ctx, &stat_ctx, stat_iter);
            if(FAILED(hres))
                break;
        }
        if(FAILED(hres))
            break;
    }

    heap_free(case_jmps);
    if(FAILED(hres))
        return hres;
    assert(i == case_cnt);

    if(!have_default) {
        hres = push_instr_uint(ctx, OP_jmp, stat_ctx.break_label);
        if(FAILED(hres))
            return hres;
        set_arg_uint(ctx, default_jmp, ctx->code_off);
    }

    label_set_addr(ctx, stat_ctx.break_label);
    return S_OK;
}

Referenced by compile_statement().

compile_throw_statement()

static HRESULT compile_throw_statement ( compiler_ctx_t *  ctx, expression_statement_t *  stat  )

static

Definition at line 1678 of file compile.c.

{
    HRESULT hres;

    hres = compile_expression(ctx, stat->expr, TRUE);
    if(FAILED(hres))
        return hres;

    return push_instr(ctx, OP_throw) ? S_OK : E_OUTOFMEMORY;
}

Referenced by compile_statement().

compile_try_statement()

static HRESULT compile_try_statement ( compiler_ctx_t *  ctx, try_statement_t *  stat  )

static

Definition at line 1690 of file compile.c.

{
    statement_ctx_t try_ctx = {0, FALSE, TRUE}, finally_ctx = {2, FALSE, FALSE};
    unsigned push_except, finally_off = 0, catch_off = 0, pop_except, catch_pop_except = 0;
    BSTR ident;
    HRESULT hres;

    push_except = push_instr(ctx, OP_push_except);
    if(!push_except)
        return E_OUTOFMEMORY;

    if(stat->catch_block) {
        ident = compiler_alloc_bstr(ctx, stat->catch_block->identifier);
        if(!ident)
            return E_OUTOFMEMORY;
    }else {
        ident = NULL;
    }

    hres = compile_statement(ctx, &try_ctx, stat->try_statement);
    if(FAILED(hres))
        return hres;

    pop_except = push_instr(ctx, OP_pop_except);
    if(!pop_except)
        return E_OUTOFMEMORY;

    if(stat->catch_block) {
        statement_ctx_t catch_ctx = {0, TRUE, stat->finally_statement != NULL};

        if(stat->finally_statement)
            catch_ctx.using_except = TRUE;

        catch_off = ctx->code_off;

        hres = push_instr_bstr(ctx, OP_enter_catch, ident);
        if(FAILED(hres))
            return hres;

        hres = compile_statement(ctx, &catch_ctx, stat->catch_block->statement);
        if(FAILED(hres))
            return hres;

        if(!push_instr(ctx, OP_pop_scope))
            return E_OUTOFMEMORY;

        if(stat->finally_statement) {
            catch_pop_except = push_instr(ctx, OP_pop_except);
            if(!catch_pop_except)
                return E_OUTOFMEMORY;
        }
    }

    if(stat->finally_statement) {
        /*
         * finally block expects two elements on the stack, which may be:
         * - (true, return_addr) set by OP_pop_except, OP_end_finally jumps back to passed address
         * - (false, exception_value) set when unwinding an exception, which OP_end_finally rethrows
         */
        finally_off = ctx->code_off;
        hres = compile_statement(ctx, &finally_ctx, stat->finally_statement);
        if(FAILED(hres))
            return hres;

        if(!push_instr(ctx, OP_end_finally))
            return E_OUTOFMEMORY;
    }

    instr_ptr(ctx, pop_except)->u.arg[0].uint = ctx->code_off;
    if(catch_pop_except)
        instr_ptr(ctx, catch_pop_except)->u.arg[0].uint = ctx->code_off;
    instr_ptr(ctx, push_except)->u.arg[0].uint = catch_off;
    instr_ptr(ctx, push_except)->u.arg[1].uint = finally_off;
    return S_OK;
}

Referenced by compile_statement().

compile_typeof_expression()

static HRESULT compile_typeof_expression ( compiler_ctx_t *  ctx, unary_expression_t *  expr  )

static

Definition at line 812 of file compile.c.

{
    jsop_t op;
    HRESULT hres;

    if(is_memberid_expr(expr->expression->type)) {
        if(expr->expression->type == EXPR_IDENT)
            return push_instr_bstr(ctx, OP_typeofident, ((identifier_expression_t*)expr->expression)->identifier);

        op = OP_typeofid;
        hres = compile_memberid_expression(ctx, expr->expression, 0);
    }else {
        op = OP_typeof;
        hres = compile_expression(ctx, expr->expression, TRUE);
    }
    if(FAILED(hres))
        return hres;

    return push_instr(ctx, op) ? S_OK : E_OUTOFMEMORY;
}

Referenced by compile_expression().

compile_unary_expression()

static HRESULT compile_unary_expression ( compiler_ctx_t *  ctx, unary_expression_t *  expr, jsop_t  op  )

static

Definition at line 370 of file compile.c.

{
    HRESULT hres;

    hres = compile_expression(ctx, expr->expression, TRUE);
    if(FAILED(hres))
        return hres;

    return push_instr(ctx, op) ? S_OK : E_OUTOFMEMORY;
}

Referenced by compile_expression().

compile_var_statement()

static HRESULT compile_var_statement ( compiler_ctx_t *  ctx, var_statement_t *  stat  )

static

Definition at line 1160 of file compile.c.

{
    return compile_variable_list(ctx, stat->variable_list);
}

Referenced by compile_statement().

compile_variable_list()

static HRESULT compile_variable_list ( compiler_ctx_t *  ctx, variable_declaration_t *  list  )

static

Definition at line 1129 of file compile.c.

{
    variable_declaration_t *iter;
    HRESULT hres;

    assert(list != NULL);

    for(iter = list; iter; iter = iter->next) {
        if(!iter->expr)
            continue;

        hres = emit_identifier_ref(ctx, iter->identifier, 0);
        if(FAILED(hres))
            return hres;

        hres = compile_expression(ctx, iter->expr, TRUE);
        if(FAILED(hres))
            return hres;

        if(!push_instr(ctx, OP_assign))
            return E_OUTOFMEMORY;

        hres = push_instr_uint(ctx, OP_pop, 1);
        if(FAILED(hres))
            return hres;
    }

    return S_OK;
}

Referenced by compile_for_statement(), compile_forin_statement(), and compile_var_statement().

compile_while_statement()

static HRESULT compile_while_statement ( compiler_ctx_t *  ctx, while_statement_t *  stat  )

static

Definition at line 1217 of file compile.c.

{
    statement_ctx_t stat_ctx = {0, FALSE, FALSE};
    unsigned jmp_off;
    HRESULT hres;

    stat_ctx.break_label = alloc_label(ctx);
    if(!stat_ctx.break_label)
        return E_OUTOFMEMORY;

    stat_ctx.continue_label = alloc_label(ctx);
    if(!stat_ctx.continue_label)
        return E_OUTOFMEMORY;

    jmp_off = ctx->code_off;

    if(!stat->do_while) {
        label_set_addr(ctx, stat_ctx.continue_label);
        hres = compile_expression(ctx, stat->expr, TRUE);
        if(FAILED(hres))
            return hres;

        hres = push_instr_uint(ctx, OP_jmp_z, stat_ctx.break_label);
        if(FAILED(hres))
            return hres;
    }

    hres = compile_statement(ctx, &stat_ctx, stat->statement);
    if(FAILED(hres))
        return hres;

    if(stat->do_while) {
        label_set_addr(ctx, stat_ctx.continue_label);
        hres = compile_expression(ctx, stat->expr, TRUE);
        if(FAILED(hres))
            return hres;

        hres = push_instr_uint(ctx, OP_jmp_z, stat_ctx.break_label);
        if(FAILED(hres))
            return hres;
    }

    hres = push_instr_uint(ctx, OP_jmp, jmp_off);
    if(FAILED(hres))
        return hres;

    label_set_addr(ctx, stat_ctx.break_label);
    return S_OK;
}

Referenced by compile_statement().

compile_with_statement()

static HRESULT compile_with_statement ( compiler_ctx_t *  ctx, with_statement_t *  stat  )

static

Definition at line 1534 of file compile.c.

{
    statement_ctx_t stat_ctx = {0, TRUE, FALSE};
    HRESULT hres;

    hres = compile_expression(ctx, stat->expr, TRUE);
    if(FAILED(hres))
        return hres;

    if(!push_instr(ctx, OP_push_scope))
        return E_OUTOFMEMORY;

    hres = compile_statement(ctx, &stat_ctx, stat->statement);
    if(FAILED(hres))
        return hres;

    if(!push_instr(ctx, OP_pop_scope))
        return E_OUTOFMEMORY;

    return S_OK;
}

Referenced by compile_statement().

compiler_alloc()

static void* compiler_alloc ( bytecode_t *  code, size_t  size  )

inlinestatic

Definition at line 128 of file compile.c.

{
    return heap_pool_alloc(&code->heap, size);
}

Referenced by compile_arguments(), and compile_function().

compiler_alloc_bstr()

static BSTR compiler_alloc_bstr ( compiler_ctx_t *  ctx, const WCHAR *  str  )

static

Definition at line 187 of file compile.c.

{
    if(!ensure_bstr_slot(ctx))
        return NULL;

    ctx->code->bstr_pool[ctx->code->bstr_cnt] = SysAllocString(str);
    if(!ctx->code->bstr_pool[ctx->code->bstr_cnt])
        return NULL;

    return ctx->code->bstr_pool[ctx->code->bstr_cnt++];
}

Referenced by alloc_variable(), compile_function(), compile_try_statement(), push_instr_bstr(), and push_instr_bstr_uint().

compiler_alloc_bstr_len()

static BSTR compiler_alloc_bstr_len ( compiler_ctx_t *  ctx, const WCHAR *  str, size_t  len  )

static

Definition at line 199 of file compile.c.

{
    if(!ensure_bstr_slot(ctx))
        return NULL;

    ctx->code->bstr_pool[ctx->code->bstr_cnt] = SysAllocStringLen(str, len);
    if(!ctx->code->bstr_pool[ctx->code->bstr_cnt])
        return NULL;

    return ctx->code->bstr_pool[ctx->code->bstr_cnt++];
}

Referenced by parse_arguments().

compiler_alloc_string()

static jsstr_t* compiler_alloc_string ( compiler_ctx_t *  ctx, const WCHAR *  str  )

static

Definition at line 161 of file compile.c.

{
    return compiler_alloc_string_len(ctx, str, lstrlenW(str));
}

Referenced by compile_delete_expression(), compile_memberid_expression(), and push_instr_uint_str().

compiler_alloc_string_len()

jsstr_t* compiler_alloc_string_len	(	compiler_ctx_t *	ctx,
		const WCHAR *	str,
		unsigned	len
	)

Definition at line 133 of file compile.c.

{
    jsstr_t *new_str;

    if(!ctx->code->str_pool_size) {
        ctx->code->str_pool = heap_alloc(8 * sizeof(jsstr_t*));
        if(!ctx->code->str_pool)
            return NULL;
        ctx->code->str_pool_size = 8;
    }else if(ctx->code->str_pool_size == ctx->code->str_cnt) {
        jsstr_t **new_pool;

        new_pool = heap_realloc(ctx->code->str_pool, ctx->code->str_pool_size*2*sizeof(jsstr_t*));
        if(!new_pool)
            return NULL;

        ctx->code->str_pool = new_pool;
        ctx->code->str_pool_size *= 2;
    }

    new_str = jsstr_alloc_len(str, len);
    if(!new_str)
        return NULL;

    ctx->code->str_pool[ctx->code->str_cnt++] = new_str;
    return new_str;
}

Referenced by compiler_alloc_string(), parse_regexp(), and parse_string_literal().

dump_code()

static void dump_code ( compiler_ctx_t *  ctx, unsigned  off  )

static

Definition at line 109 of file compile.c.

{
    instr_t *instr;

    for(instr = ctx->code->instrs+off; instr < ctx->code->instrs+ctx->code_off; instr++) {
        TRACE_(jscript_disas)("%d:\t%s", (int)(instr-ctx->code->instrs), instr_info[instr->op].op_str);
        if(instr_info[instr->op].arg1_type == ARG_DBL) {
            TRACE_(jscript_disas)("\t%lf", instr->u.dbl);
        }else {
            dump_instr_arg(instr_info[instr->op].arg1_type, instr->u.arg);
            dump_instr_arg(instr_info[instr->op].arg2_type, instr->u.arg+1);
        }
        TRACE_(jscript_disas)("\n");
    }
}

Referenced by compile_function().

dump_instr_arg()

static void dump_instr_arg ( instr_arg_type_t  type, instr_arg_t *  arg  )

static

Definition at line 86 of file compile.c.

{
    switch(type) {
    case ARG_STR:
        TRACE_(jscript_disas)("\t%s", debugstr_jsstr(arg->str));
        break;
    case ARG_BSTR:
        TRACE_(jscript_disas)("\t%s", debugstr_wn(arg->bstr, SysStringLen(arg->bstr)));
        break;
    case ARG_INT:
        TRACE_(jscript_disas)("\t%d", arg->uint);
        break;
    case ARG_UINT:
    case ARG_ADDR:
        TRACE_(jscript_disas)("\t%u", arg->uint);
        break;
    case ARG_FUNC:
    case ARG_NONE:
        break;
    DEFAULT_UNREACHABLE;
    }
}

Referenced by dump_code().

emit_identifier()

static HRESULT emit_identifier ( compiler_ctx_t *  ctx, const WCHAR *  identifier  )

static

Definition at line 453 of file compile.c.

{
    int local_ref;
    if(bind_local(ctx, identifier, &local_ref))
        return push_instr_int(ctx, OP_local, local_ref);
    return push_instr_bstr(ctx, OP_ident, identifier);
}

Referenced by compile_expression().

emit_identifier_ref()

static HRESULT emit_identifier_ref ( compiler_ctx_t *  ctx, const WCHAR *  identifier, unsigned  flags  )

static

Definition at line 445 of file compile.c.

{
    int local_ref;
    if(bind_local(ctx, identifier, &local_ref))
        return push_instr_int(ctx, OP_local_ref, local_ref);
    return push_instr_bstr_uint(ctx, OP_identid, identifier, flags);
}

Referenced by compile_forin_statement(), compile_memberid_expression(), and compile_variable_list().

ensure_bstr_slot()

static BOOL ensure_bstr_slot ( compiler_ctx_t *  ctx )

static

Definition at line 166 of file compile.c.

{
    if(!ctx->code->bstr_pool_size) {
        ctx->code->bstr_pool = heap_alloc(8 * sizeof(BSTR));
        if(!ctx->code->bstr_pool)
            return FALSE;
        ctx->code->bstr_pool_size = 8;
    }else if(ctx->code->bstr_pool_size == ctx->code->bstr_cnt) {
        BSTR *new_pool;

        new_pool = heap_realloc(ctx->code->bstr_pool, ctx->code->bstr_pool_size*2*sizeof(BSTR));
        if(!new_pool)
            return FALSE;

        ctx->code->bstr_pool = new_pool;
        ctx->code->bstr_pool_size *= 2;
    }

    return TRUE;
}

Referenced by compiler_alloc_bstr(), and compiler_alloc_bstr_len().

find_local()

static function_local_t* find_local ( compiler_ctx_t *  ctx, const WCHAR *  name  )

inlinestatic

Definition at line 1842 of file compile.c.

{
    struct wine_rb_entry *entry = wine_rb_get(&ctx->locals, name);
    return entry ? WINE_RB_ENTRY_VALUE(entry, function_local_t, entry) : NULL;
}

Referenced by alloc_variable(), and compile_function().

function_local_cmp()

static int function_local_cmp ( const void *  key, const struct wine_rb_entry *  entry  )

static

Definition at line 1836 of file compile.c.

{
    function_local_t *local = WINE_RB_ENTRY_VALUE(entry, function_local_t, entry);
    return wcscmp(key, local->name);
}

Referenced by compile_function().

init_code()

static HRESULT init_code ( compiler_ctx_t *  compiler, const WCHAR *  source  )

static

Definition at line 2246 of file compile.c.

{
    compiler->code = heap_alloc_zero(sizeof(bytecode_t));
    if(!compiler->code)
        return E_OUTOFMEMORY;

    compiler->code->ref = 1;
    heap_pool_init(&compiler->code->heap);

    compiler->code->source = heap_strdupW(source);
    if(!compiler->code->source) {
        release_bytecode(compiler->code);
        return E_OUTOFMEMORY;
    }

    compiler->code->instrs = heap_alloc(64 * sizeof(instr_t));
    if(!compiler->code->instrs) {
        release_bytecode(compiler->code);
        return E_OUTOFMEMORY;
    }

    compiler->code_size = 64;
    compiler->code_off = 1;
    return S_OK;
}

Referenced by compile_script().

instr_ptr()

static instr_t* instr_ptr ( compiler_ctx_t *  ctx, unsigned  off  )

inlinestatic

Definition at line 230 of file compile.c.

{
    assert(off < ctx->code_off);
    return ctx->code->instrs + off;
}

Referenced by compile_array_literal(), compile_assign_expression(), compile_call_expression(), compile_try_statement(), push_instr_bstr(), push_instr_bstr_uint(), push_instr_double(), push_instr_int(), push_instr_str(), push_instr_str_uint(), push_instr_uint_str(), and set_arg_uint().

is_loop_statement()

static BOOL is_loop_statement ( statement_type_t  type )

inlinestatic

Definition at line 1107 of file compile.c.

{
    return type == STAT_FOR || type == STAT_FORIN || type == STAT_WHILE;
}

Referenced by compile_continue_statement().

is_memberid_expr()

static BOOL is_memberid_expr ( expression_type_t  type )

inlinestatic

Definition at line 422 of file compile.c.

{
    return type == EXPR_IDENT || type == EXPR_MEMBER || type == EXPR_ARRAY;
}

Referenced by compile_assign_expression(), compile_call_expression(), compile_forin_statement(), compile_increment_expression(), and compile_typeof_expression().

label_set_addr()

static void label_set_addr ( compiler_ctx_t *  ctx, unsigned  label  )

static

Definition at line 416 of file compile.c.

{
    assert(label & LABEL_FLAG);
    ctx->labels[label & ~LABEL_FLAG] = ctx->code_off;
}

Referenced by compile_for_statement(), compile_forin_statement(), compile_labelled_statement(), compile_switch_statement(), and compile_while_statement().

literal_as_string()

static HRESULT literal_as_string ( compiler_ctx_t *  ctx, literal_t *  literal, jsstr_t **  str  )

static

Definition at line 851 of file compile.c.

{
    switch(literal->type) {
    case LT_STRING:
        *str = literal->u.str;
        break;
    case LT_DOUBLE:
        return double_to_string(literal->u.dval, str);
    DEFAULT_UNREACHABLE;
    }

    return *str ? S_OK : E_OUTOFMEMORY;
}

Referenced by compile_object_literal().

parse_arguments()

static HRESULT parse_arguments ( compiler_ctx_t *  ctx, const WCHAR *  args, BSTR *  arg_array, unsigned *  args_size  )

static

Definition at line 2391 of file compile.c.

{
    const WCHAR *ptr = args, *ptr2;
    unsigned arg_cnt = 0;

    while(iswspace(*ptr))
        ptr++;
    if(!*ptr) {
        if(args_size)
            *args_size = 0;
        return S_OK;
    }

    while(1) {
        if(!iswalpha(*ptr) && *ptr != '_') {
            FIXME("expected alpha or '_': %s\n", debugstr_w(ptr));
            return E_FAIL;
        }

        ptr2 = ptr;
        while(iswalnum(*ptr) || *ptr == '_')
            ptr++;

        if(*ptr && *ptr != ',' && !iswspace(*ptr)) {
            FIXME("unexpected har %s\n", debugstr_w(ptr));
            return E_FAIL;
        }

        if(arg_array) {
            arg_array[arg_cnt] = compiler_alloc_bstr_len(ctx, ptr2, ptr-ptr2);
            if(!arg_array[arg_cnt])
                return E_OUTOFMEMORY;
        }
        arg_cnt++;

        while(iswspace(*ptr))
            ptr++;
        if(!*ptr)
            break;
        if(*ptr != ',') {
            FIXME("expected ',': %s\n", debugstr_w(ptr));
            return E_FAIL;
        }

        ptr++;
        while(iswspace(*ptr))
            ptr++;
    }

    if(args_size)
        *args_size = arg_cnt;
    return S_OK;
}

Referenced by compile_arguments().

pop_to_stat()

static HRESULT pop_to_stat ( compiler_ctx_t *  ctx, statement_ctx_t *  stat_ctx  )

static

Definition at line 1386 of file compile.c.

{
    unsigned stack_pop = 0;
    statement_ctx_t *iter;
    HRESULT hres;

    for(iter = ctx->stat_ctx; iter != stat_ctx; iter = iter->next) {
        if(iter->using_scope && !push_instr(ctx, OP_pop_scope))
            return E_OUTOFMEMORY;
        if(iter->using_except) {
            if(stack_pop) {
                hres = push_instr_uint(ctx, OP_pop, stack_pop);
                if(FAILED(hres))
                    return hres;
                stack_pop = 0;
            }
            hres = push_instr_uint(ctx, OP_pop_except, ctx->code_off+1);
            if(FAILED(hres))
                return hres;
        }
        stack_pop += iter->stack_use;
    }

    if(stack_pop) {
        hres = push_instr_uint(ctx, OP_pop, stack_pop);
        if(FAILED(hres))
            return hres;
    }

    return S_OK;
}

Referenced by compile_break_statement(), compile_continue_statement(), and compile_return_statement().