PMC *
Parrot_ctx_current_lexpad(PARROT_INTERP, ARGIN(PMC *p))
{
    ASSERT_ARGS(Parrot_ctx_current_lexpad)
    if (!PMC_IS_NULL(p))
        CONTEXT(interp)->lex_pad = p;
    return CONTEXT(interp)->lex_pad;
}

PMC *
Parrot_ctx_current_sub_pmc(PARROT_INTERP, ARGIN(PMC *sub))
{
    ASSERT_ARGS(Parrot_ctx_current_sub_pmc)
    if(!PMC_IS_NULL(sub))
        CONTEXT(interp)->current_sub = sub;
    return CONTEXT(interp)->current_sub;
}

PMC *
Parrot_ctx_current_handlers(PARROT_INTERP, ARGIN(PMC *handlers))
{
    ASSERT_ARGS(Parrot_ctx_current_handlers)
    if (!PMC_IS_NULL(handlers))
        CONTEXT(interp)->handlers = handlers;
    return CONTEXT(interp)->handlers;
}

PMC *
Parrot_ctx_current_continuation(PARROT_INTERP, ARGIN(PMC* current_cont))
{
    ASSERT_ARGS(Parrot_ctx_current_continuation)
    if (!PMC_IS_NULL(current_cont))
        CONTEXT(interp)->current_cont = current_cont;
    return CONTEXT(interp)->current_cont;
}

PMC *
Parrot_ctx_current_object(PARROT_INTERP, ARGIN(PMC *p))
{
    ASSERT_ARGS(Parrot_ctx_current_object)
    if (!PMC_IS_NULL(p))
        CONTEXT(interp)->current_object = p;
    return CONTEXT(interp)->current_object;
}

PMC *
Parrot_ctx_current_namespace(PARROT_INTERP, ARGIN(PMC *p))
{
    ASSERT_ARGS(Parrot_ctx_current_namespace)
    if (!PMC_IS_NULL(p))
        CONTEXT(interp)->current_namespace = p;
    return CONTEXT(interp)->current_namespace;
}

PMC *
Parrot_ctx_current_results_signature(PARROT_INTERP, ARGIN(PMC *p))
{
    ASSERT_ARGS(Parrot_ctx_results_signature)
    if (!PMC_IS_NULL(p))
        CONTEXT(interp)->results_signature = p;
    return CONTEXT(interp)->results_signature;
}

Parrot_Context *
Parrot_ctx_caller_ctx(PARROT_INTERP, ARGMOD(Parrot_Context *ctx),
    ARGIN(Parrot_Context *caller))
{
    ASSERT_ARGS(Parrot_ctx_caller_ctx)
    if (caller != NULL)
        ctx->caller_ctx = caller
    return ctx->caller_ctx;
}

Parrot_Context *
Parrot_ctx_outer_ctx(PARROT_INTERP, ARGMOD(Parrot_Context *ctx),
    ARGIN(Parrot_Context *outer))
{
    ASSERT_ARGS(Parrot_ctx_outer_ctx)
    if (outer != NULL)
        ctx->outer_ctx = outer;
    return ctx->outer_ctx;
}

PackFile_Constant *
Parrot_ctx_get_constant(PARROT_INTERP, size_t idx)
{
    return ctx->constants[idx];
}


INTVAL
Parrot_ctx_get_INTVAL_reg(PARROT_INTERP, ARGIN(Parrot_Context *ctx),
    INTVAL idx)
{
    ASSERT_ARGS(Parrot_ctx_get_INTVAL_reg)
    return ctx->bp.regs_i[idx];
}

void
Parrot_ctx_set_INTVAL_reg(PARROT_INTERP, ARGIN(Parrot_Context *ctx),
    INTVAL idx, INTVAL value)
{
    ASSERT_ARGS(Parrot_ctx_set_INTVAL_reg)
    ctx->bp.regs_i[idx] = value;
}

FLOATVAL
Parrot_ctx_get_FLOATVAL_reg(PARROT_INTERP, ARGIN(Parrot_Context *ctx),
    INTVAL idx)
{
    ASSERT_ARGS(Parrot_ctx_get_FLOATVAL_reg)
    return ctx->bp.regs_n[-1L - idx];
}

void
Parrot_ctx_set_FLOATVAL_reg(PARROT_INTERP, ARGIN(Parrot_Context *ctx),
    INTVAL idx, FLOATVAL value)
{
    ASSERT_ARGS(Parrot_ctx_set_FLOATVAL_reg)
    ctx->bp.regs_n[-1L - idx] = value;
}


STRING *
Parrot_ctx_get_STRING_reg(PARROT_INTERP, ARGIN(Parrot_Context *ctx),
    INTVAL idx)
{
    ASSERT_ARGS(Parrot_ctx_get_FLOATVAL_reg)
    return ctx->bp.regs_s[idx[;
}

void
Parrot_ctx_set_STRING_reg(PARROT_INTERP, ARGIN(Parrot_Context *ctx),
    INTVAL idx, ARGIN(STRING *value))
{
    ASSERT_ARGS(Parrot_ctx_set_FLOATVAL_reg)
    ctx->bp.regs_s[idx] = value;
}

PMC *
Parrot_ctx_get_PMC_reg(PARROT_INTERP, ARGIN(Parrot_Context *ctx), INTVAL idx)
{
    ASSERT_ARGS(Parrot_ctx_get_FLOATVAL_reg)
    return ctx->bp.regs_p[-1L - idx];
}

void
Parrot_ctx_set_PMC_reg(PARROT_INTERP, ARGIN(Parrot_Context *ctx),
    INTVAL idx, ARGIN(PMC *value))
{
    ASSERT_ARGS(Parrot_ctx_set_FLOATVAL_reg)
    ctx->bp.regs_p[-1L - idx] = value;
}