duk_api_compile.c File Reference

#include "duk_internal.h"

Go to the source code of this file.

Data Structures
struct	duk__compile_raw_args

Typedefs
typedef struct duk__compile_raw_args	duk__compile_raw_args

Functions
DUK_EXTERNAL duk_int_t	duk_eval_raw (duk_context *ctx, const char *src_buffer, duk_size_t src_length, duk_uint_t flags)
DUK_LOCAL duk_ret_t	duk__do_compile (duk_context *ctx)
DUK_EXTERNAL duk_int_t	duk_compile_raw (duk_context *ctx, const char *src_buffer, duk_size_t src_length, duk_uint_t flags)

Typedef Documentation

duk__compile_raw_args

typedef struct duk__compile_raw_args duk__compile_raw_args

Definition at line 7 of file duktape-1.5.2/src-separate/duk_api_compile.c.

Function Documentation

duk__do_compile()

DUK_LOCAL duk_ret_t duk__do_compile

(

duk_context *

ctx

)

Definition at line 61 of file duktape-1.5.2/src-separate/duk_api_compile.c.

                                                      {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk__compile_raw_args *comp_args;
    duk_uint_t flags;
    duk_small_uint_t comp_flags;
    duk_hcompiledfunction *h_templ;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    /* Note: strictness is not inherited from the current Duktape/C
     * context.  Otherwise it would not be possible to compile
     * non-strict code inside a Duktape/C activation (which is
     * always strict now).  See tests/api/test-eval-strictness.c
     * for discussion.
     */
 
    /* [ ... source? filename? &comp_args ] (depends on flags) */
 
    comp_args = (duk__compile_raw_args *) duk_require_pointer(ctx, -1);
    flags = comp_args->flags;
    duk_pop(ctx);
 
    /* [ ... source? filename? ] */
 
    if (flags & DUK_COMPILE_NOFILENAME) {
        /* Automatic filename: 'eval' or 'input'. */
        duk_push_hstring_stridx(ctx, (flags & DUK_COMPILE_EVAL) ? DUK_STRIDX_EVAL : DUK_STRIDX_INPUT);
    }
 
    /* [ ... source? filename ] */
 
    if (!comp_args->src_buffer) {
        duk_hstring *h_sourcecode;
 
        h_sourcecode = duk_get_hstring(ctx, -2);
        if ((flags & DUK_COMPILE_NOSOURCE) ||  /* args incorrect */
            (h_sourcecode == NULL)) {          /* e.g. duk_push_string_file_raw() pushed undefined */
            /* XXX: when this error is caused by a nonexistent
             * file given to duk_peval_file() or similar, the
             * error message is not the best possible.
             */
            DUK_ERROR_API(thr, DUK_STR_NO_SOURCECODE);
        }
        DUK_ASSERT(h_sourcecode != NULL);
        comp_args->src_buffer = (const duk_uint8_t *) DUK_HSTRING_GET_DATA(h_sourcecode);
        comp_args->src_length = (duk_size_t) DUK_HSTRING_GET_BYTELEN(h_sourcecode);
    }
    DUK_ASSERT(comp_args->src_buffer != NULL);
 
    /* XXX: unnecessary translation of flags */
    comp_flags = 0;
    if (flags & DUK_COMPILE_EVAL) {
        comp_flags |= DUK_JS_COMPILE_FLAG_EVAL;
    }
    if (flags & DUK_COMPILE_FUNCTION) {
        comp_flags |= DUK_JS_COMPILE_FLAG_EVAL |
                      DUK_JS_COMPILE_FLAG_FUNCEXPR;
    }
    if (flags & DUK_COMPILE_STRICT) {
        comp_flags |= DUK_JS_COMPILE_FLAG_STRICT;
    }
 
    /* [ ... source? filename ] */
 
    duk_js_compile(thr, comp_args->src_buffer, comp_args->src_length, comp_flags);
 
    /* [ ... source? func_template ] */
 
    if (flags & DUK_COMPILE_NOSOURCE) {
        ;
    } else {
        duk_remove(ctx, -2);
    }
 
    /* [ ... func_template ] */
 
    h_templ = (duk_hcompiledfunction *) duk_get_hobject(ctx, -1);
    DUK_ASSERT(h_templ != NULL);
    duk_js_push_closure(thr,
                       h_templ,
                       thr->builtins[DUK_BIDX_GLOBAL_ENV],
                       thr->builtins[DUK_BIDX_GLOBAL_ENV],
                       1 /*add_auto_proto*/);
    duk_remove(ctx, -2);   /* -> [ ... closure ] */
 
    /* [ ... closure ] */
 
    return 1;
}

References duk_hthread::builtins, DUK_ASSERT, DUK_ASSERT_CTX_VALID, DUK_BIDX_GLOBAL_ENV, DUK_COMPILE_EVAL, DUK_COMPILE_FUNCTION, DUK_COMPILE_NOFILENAME, DUK_COMPILE_NOSOURCE, DUK_COMPILE_STRICT, DUK_ERROR_API, duk_get_hobject(), duk_get_hstring(), DUK_HSTRING_GET_BYTELEN, DUK_HSTRING_GET_DATA, duk_js_compile(), DUK_JS_COMPILE_FLAG_EVAL, DUK_JS_COMPILE_FLAG_FUNCEXPR, DUK_JS_COMPILE_FLAG_STRICT, duk_js_push_closure(), duk_pop(), duk_push_hstring_stridx(), duk_remove(), duk_require_pointer(), DUK_STR_NO_SOURCECODE, DUK_STRIDX_EVAL, DUK_STRIDX_INPUT, duk__compile_raw_args::flags, NULL, duk__compile_raw_args::src_buffer, and duk__compile_raw_args::src_length.

Referenced by duk_compile_raw().

duk_compile_raw()

DUK_EXTERNAL duk_int_t duk_compile_raw	(	duk_context *	ctx,
		const char *	src_buffer,
		duk_size_t	src_length,
		duk_uint_t	flags )

Definition at line 151 of file duktape-1.5.2/src-separate/duk_api_compile.c.

                                                                                                                          {
    duk__compile_raw_args comp_args_alloc;
    duk__compile_raw_args *comp_args = &comp_args_alloc;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    if ((flags & DUK_COMPILE_STRLEN) && (src_buffer != NULL)) {
        /* String length is computed here to avoid multiple evaluation
         * of a macro argument in the calling side.
         */
        src_length = DUK_STRLEN(src_buffer);
    }
 
    comp_args->src_buffer = (const duk_uint8_t *) src_buffer;
    comp_args->src_length = src_length;
    comp_args->flags = flags;
    duk_push_pointer(ctx, (void *) comp_args);
 
    /* [ ... source? filename? &comp_args ] (depends on flags) */
 
    if (flags & DUK_COMPILE_SAFE) {
        duk_int_t rc;
        duk_int_t nargs;
        duk_int_t nrets = 1;
 
        /* Arguments can be: [ source? filename? &comp_args] so that
         * nargs is 1 to 3.  Call site encodes the correct nargs count
         * directly into flags.
         */
        nargs = flags & 0x07;
        DUK_ASSERT(nargs == (1 +
                             ((flags & DUK_COMPILE_NOSOURCE) ? 0 : 1) +
                             ((flags & DUK_COMPILE_NOFILENAME) ? 0 : 1)));
        rc = duk_safe_call(ctx, duk__do_compile, nargs, nrets);
 
        /* [ ... closure ] */
        return rc;
    }
 
    (void) duk__do_compile(ctx);
 
    /* [ ... closure ] */
    return DUK_EXEC_SUCCESS;
}

References duk__do_compile(), DUK_ASSERT, DUK_ASSERT_CTX_VALID, DUK_COMPILE_NOFILENAME, DUK_COMPILE_NOSOURCE, DUK_COMPILE_SAFE, DUK_COMPILE_STRLEN, DUK_EXEC_SUCCESS, duk_push_pointer(), duk_safe_call(), DUK_STRLEN, duk__compile_raw_args::flags, NULL, duk__compile_raw_args::src_buffer, and duk__compile_raw_args::src_length.

Referenced by duk_eval_raw().

duk_eval_raw()

DUK_EXTERNAL duk_int_t duk_eval_raw	(	duk_context *	ctx,
		const char *	src_buffer,
		duk_size_t	src_length,
		duk_uint_t	flags )

Definition at line 15 of file duktape-1.5.2/src-separate/duk_api_compile.c.

                                                                                                                       {
    duk_uint_t comp_flags;
    duk_int_t rc;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    /* Note: strictness is *not* inherited from the current Duktape/C.
     * This would be confusing because the current strictness state
     * depends on whether we're running inside a Duktape/C activation
     * (= strict mode) or outside of any activation (= non-strict mode).
     * See tests/api/test-eval-strictness.c for more discussion.
     */
 
    /* [ ... source? filename? ] (depends on flags) */
 
    comp_flags = flags;
    comp_flags |= DUK_COMPILE_EVAL;
    rc = duk_compile_raw(ctx, src_buffer, src_length, comp_flags);  /* may be safe, or non-safe depending on flags */
 
    /* [ ... closure/error ] */
 
    if (rc != DUK_EXEC_SUCCESS) {
        rc = DUK_EXEC_ERROR;
        goto got_rc;
    }
 
    duk_push_global_object(ctx);  /* explicit 'this' binding, see GH-164 */
 
    if (flags & DUK_COMPILE_SAFE) {
        rc = duk_pcall_method(ctx, 0);
    } else {
        duk_call_method(ctx, 0);
        rc = DUK_EXEC_SUCCESS;
    }
 
    /* [ ... result/error ] */
 
 got_rc:
    if (flags & DUK_COMPILE_NORESULT) {
        duk_pop(ctx);
    }
 
    return rc;
}

References DUK_ASSERT_CTX_VALID, duk_call_method(), DUK_COMPILE_EVAL, DUK_COMPILE_NORESULT, duk_compile_raw(), DUK_COMPILE_SAFE, DUK_EXEC_ERROR, DUK_EXEC_SUCCESS, duk_pcall_method(), duk_pop(), and duk_push_global_object().