mps_res_t mps_fmt_create_fixed(mps_fmt_t *mps_fmt_o,
mps_arena_t arena,
mps_fmt_fixed_s *mps_fmt_fixed)
{
Format format;
Res res;
ArenaEnter(arena);
AVER(mps_fmt_fixed != NULL);
res = FormatCreate(&format,
arena,
(Align)mps_fmt_fixed->align,
FormatVarietyFixed,
mps_fmt_fixed->scan,
NULL,
mps_fmt_fixed->fwd,
mps_fmt_fixed->isfwd,
NULL,
mps_fmt_fixed->pad,
NULL,
(Size)0);
ArenaLeave(arena);
if (res != ResOK) return res;
*mps_fmt_o = (mps_fmt_t)format;
return MPS_RES_OK;
}
mps_res_t mps_fmt_create_B(mps_fmt_t *mps_fmt_o,
mps_arena_t arena,
mps_fmt_B_s *mps_fmt_B)
{
Format format;
Res res;
ArenaEnter(arena);
AVER(mps_fmt_B != NULL);
res = FormatCreate(&format,
arena,
(Align)mps_fmt_B->align,
FormatVarietyB,
mps_fmt_B->scan,
mps_fmt_B->skip,
mps_fmt_B->fwd,
mps_fmt_B->isfwd,
mps_fmt_B->copy,
mps_fmt_B->pad,
mps_fmt_B->mps_class,
(Size)0);
ArenaLeave(arena);
if (res != ResOK) return res;
*mps_fmt_o = (mps_fmt_t)format;
return MPS_RES_OK;
}
mps_res_t mps_fmt_create_auto_header(mps_fmt_t *mps_fmt_o,
mps_arena_t arena,
mps_fmt_auto_header_s *mps_fmt)
{
Format format;
Res res;
ArenaEnter(arena);
AVER(mps_fmt != NULL);
res = FormatCreate(&format,
arena,
(Align)mps_fmt->align,
FormatVarietyAutoHeader,
mps_fmt->scan,
mps_fmt->skip,
mps_fmt->fwd,
mps_fmt->isfwd,
NULL,
mps_fmt->pad,
NULL,
(Size)mps_fmt->mps_headerSize);
ArenaLeave(arena);
if (res != ResOK) return res;
*mps_fmt_o = (mps_fmt_t)format;
return MPS_RES_OK;
}
mps_res_t mps_fmt_create_auto_header(mps_fmt_t *mps_fmt_o,
mps_arena_t arena,
mps_fmt_auto_header_s *mps_fmt)
{
Format format;
Res res;
ArenaEnter(arena);
AVER(mps_fmt_o != NULL);
AVERT(Arena, arena);
AVER(mps_fmt != NULL);
MPS_ARGS_BEGIN(args) {
MPS_ARGS_ADD(args, MPS_KEY_FMT_ALIGN, mps_fmt->align);
MPS_ARGS_ADD(args, MPS_KEY_FMT_HEADER_SIZE, mps_fmt->mps_headerSize);
MPS_ARGS_ADD(args, MPS_KEY_FMT_SCAN, mps_fmt->scan);
MPS_ARGS_ADD(args, MPS_KEY_FMT_SKIP, mps_fmt->skip);
MPS_ARGS_ADD(args, MPS_KEY_FMT_FWD, mps_fmt->fwd);
MPS_ARGS_ADD(args, MPS_KEY_FMT_ISFWD, mps_fmt->isfwd);
MPS_ARGS_ADD(args, MPS_KEY_FMT_PAD, mps_fmt->pad);
res = FormatCreate(&format, arena, args);
} MPS_ARGS_END(args);
ArenaLeave(arena);
if (res != ResOK) return res;
*mps_fmt_o = (mps_fmt_t)format;
return MPS_RES_OK;
}
mps_res_t mps_fmt_create_fixed(mps_fmt_t *mps_fmt_o,
mps_arena_t arena,
mps_fmt_fixed_s *mps_fmt_fixed)
{
Format format;
Res res;
ArenaEnter(arena);
AVER(mps_fmt_o != NULL);
AVERT(Arena, arena);
AVER(mps_fmt_fixed != NULL);
MPS_ARGS_BEGIN(args) {
MPS_ARGS_ADD(args, MPS_KEY_FMT_ALIGN, mps_fmt_fixed->align);
MPS_ARGS_ADD(args, MPS_KEY_FMT_SCAN, mps_fmt_fixed->scan);
MPS_ARGS_ADD(args, MPS_KEY_FMT_FWD, mps_fmt_fixed->fwd);
MPS_ARGS_ADD(args, MPS_KEY_FMT_ISFWD, mps_fmt_fixed->isfwd);
MPS_ARGS_ADD(args, MPS_KEY_FMT_PAD, mps_fmt_fixed->pad);
res = FormatCreate(&format, arena, args);
} MPS_ARGS_END(args);
ArenaLeave(arena);
if (res != ResOK) return res;
*mps_fmt_o = (mps_fmt_t)format;
return MPS_RES_OK;
}
mps_res_t mps_arena_collect(mps_arena_t arena)
{
Res res;
ArenaEnter(arena);
res = ArenaCollect(ArenaGlobals(arena), TraceStartWhyCLIENTFULL_BLOCK);
ArenaLeave(arena);
return res;
}
void mps_arena_spare_commit_limit_set(mps_arena_t arena, size_t limit)
{
ArenaEnter(arena);
ArenaSetSpareCommitLimit(arena, limit);
ArenaLeave(arena);
return;
}
mps_res_t mps_arena_start_collect(mps_arena_t arena)
{
Res res;
ArenaEnter(arena);
res = ArenaStartCollect(ArenaGlobals(arena), TraceStartWhyCLIENTFULL_INCREMENTAL);
ArenaLeave(arena);
return res;
}
mps_res_t mps_arena_commit_limit_set(mps_arena_t arena, size_t limit)
{
Res res;
ArenaEnter(arena);
res = ArenaSetCommitLimit(arena, limit);
ArenaLeave(arena);
return res;
}
size_t mps_arena_commit_limit(mps_arena_t arena)
{
Size size;
ArenaEnter(arena);
size = ArenaCommitLimit(arena);
ArenaLeave(arena);
return size;
}
size_t mps_arena_spare_committed(mps_arena_t arena)
{
Size size;
ArenaEnter(arena);
size = ArenaSpareCommitted(arena);
ArenaLeave(arena);
return (size_t)size;
}
size_t mps_arena_reserved(mps_arena_t arena)
{
Size size;
ArenaEnter(arena);
size = ArenaReserved(arena);
ArenaLeave(arena);
return (size_t)size;
}
mps_bool_t mps_arena_step(mps_arena_t arena,
double interval,
double multiplier)
{
Bool b;
ArenaEnter(arena);
b = ArenaStep(ArenaGlobals(arena), interval, multiplier);
ArenaLeave(arena);
return b;
}
size_t mps_arena_spare_commit_limit(mps_arena_t arena)
{
size_t limit;
ArenaEnter(arena);
limit = ArenaSpareCommitLimit(arena);
ArenaLeave(arena);
return limit;
}
mps_res_t mps_arena_extend(mps_arena_t arena,
mps_addr_t base, size_t size)
{
Res res;
ArenaEnter(arena);
AVER(size > 0);
res = ArenaExtend(arena, (Addr)base, (Size)size);
ArenaLeave(arena);
return (mps_res_t)res;
}
void mps_fmt_destroy(mps_fmt_t format)
{
Arena arena;
AVER(TESTT(Format, format));
arena = FormatArena(format);
ArenaEnter(arena);
FormatDestroy(format);
ArenaLeave(arena);
}
void mps_pool_check_fenceposts(mps_pool_t mps_pool)
{
Pool pool = (Pool)mps_pool;
Arena arena;
/* TESTT not AVERT, see <design/interface-c/#check.space */
AVER(TESTT(Pool, pool));
arena = PoolArena(pool);
ArenaEnter(arena);
AVERT(Pool, pool);
DebugPoolCheckFences(pool);
ArenaLeave(arena);
}
void mps_pool_check_free_space(mps_pool_t mps_pool)
{
Pool pool = (Pool)mps_pool;
Arena arena;
/* TESTT not AVERT, see <design/interface-c#.check.space */
AVER(TESTT(Pool, pool));
arena = PoolArena(pool);
ArenaEnter(arena);
AVERT(Pool, pool);
DebugPoolCheckFreeSpace(pool);
ArenaLeave(arena);
}
void mps_arena_roots_walk(mps_arena_t mps_arena, mps_roots_stepper_t f,
void *p, size_t s)
{
Arena arena = (Arena)mps_arena;
Res res;
ArenaEnter(arena);
AVER(FUNCHECK(f));
/* p and s are arbitrary closures, hence can't be checked */
AVER(ArenaGlobals(arena)->clamped); /* .assume.parked */
AVER(arena->busyTraces == TraceSetEMPTY); /* .assume.parked */
res = ArenaRootsWalk(ArenaGlobals(arena), f, p, s);
AVER(res == ResOK);
ArenaLeave(arena);
}
void mps_arena_formatted_objects_walk(mps_arena_t mps_arena,
mps_formatted_objects_stepper_t f,
void *p, size_t s)
{
Arena arena = (Arena)mps_arena;
FormattedObjectsStepClosureStruct c;
ArenaEnter(arena);
AVERT(Arena, arena);
AVER(FUNCHECK(f));
/* p and s are arbitrary closures, hence can't be checked */
c.sig = FormattedObjectsStepClosureSig;
c.f = f;
c.p = p;
c.s = s;
ArenaFormattedObjectsWalk(arena, ArenaFormattedObjectsStep, &c, 0);
ArenaLeave(arena);
}
mps_res_t mps_arena_create_v(mps_arena_t *mps_arena_o,
mps_arena_class_t arena_class, va_list args)
{
Arena arena;
Res res;
/* This is the first real call that the client will have to make, */
/* so check static consistency here. */
AVER(mpsi_check());
AVER(mps_arena_o != NULL);
res = ArenaCreateV(&arena, arena_class, args);
if (res != ResOK)
return res;
ArenaLeave(arena);
*mps_arena_o = (mps_arena_t)arena;
return MPS_RES_OK;
}
mps_res_t mps_fmt_create_k(mps_fmt_t *mps_fmt_o,
mps_arena_t arena,
mps_arg_s args[])
{
Format format;
Res res;
ArenaEnter(arena);
AVER(mps_fmt_o != NULL);
AVERT(Arena, arena);
AVER(ArgListCheck(args));
res = FormatCreate(&format, arena, args);
ArenaLeave(arena);
if (res != ResOK) return res;
*mps_fmt_o = (mps_fmt_t)format;
return MPS_RES_OK;
}
void mps_arena_clamp(mps_arena_t arena)
{
ArenaEnter(arena);
ArenaClamp(ArenaGlobals(arena));
ArenaLeave(arena);
}
void mps_arena_unsafe_restore_protection(mps_arena_t arena)
{
ArenaEnter(arena);
ArenaRestoreProtection(ArenaGlobals(arena));
ArenaLeave(arena);
}
/* Null implementations of remember and restore */
void mps_arena_unsafe_expose_remember_protection(mps_arena_t arena)
{
ArenaEnter(arena);
ArenaExposeRemember(ArenaGlobals(arena), 1);
ArenaLeave(arena);
}
void mps_arena_expose(mps_arena_t arena)
{
ArenaEnter(arena);
ArenaExposeRemember(ArenaGlobals(arena), 0);
ArenaLeave(arena);
}
void mps_arena_park(mps_arena_t arena)
{
ArenaEnter(arena);
ArenaPark(ArenaGlobals(arena));
ArenaLeave(arena);
}
void mps_arena_release(mps_arena_t arena)
{
ArenaEnter(arena);
ArenaRelease(ArenaGlobals(arena));
ArenaLeave(arena);
}
