PARROT_EXPORT
void
PackFile_pack(PARROT_INTERP, ARGMOD(PackFile *self), ARGOUT(opcode_t *cursor))
{
ASSERT_ARGS(PackFile_pack)
opcode_t *ret;
size_t size;
PackFile_Directory * const dir = &self->directory;
PackFile_Segment *seg;
int padding_size;
char *byte_cursor = (char*)cursor;
self->src = cursor;
/* Pack the fixed part of the header */
mem_sys_memcopy(cursor, self->header, PACKFILE_HEADER_BYTES);
byte_cursor += PACKFILE_HEADER_BYTES;
/* Pack the UUID. */
if (self->header->uuid_size > 0)
mem_sys_memcopy(byte_cursor, self->header->uuid_data,
self->header->uuid_size);
/* Padding. */
padding_size = 16 - (PACKFILE_HEADER_BYTES + self->header->uuid_size) % 16;
if (padding_size < 16) {
int i;
for (i = 0; i < padding_size; ++i)
*byte_cursor++ = 0;
}
else {
padding_size = 0;
}
/* Set cursor. */
cursor += (PACKFILE_HEADER_BYTES + self->header->uuid_size + padding_size)
/ sizeof (opcode_t);
/* Directory format and padding. */
*cursor++ = PF_DIR_FORMAT;
*cursor++ = 0;
*cursor++ = 0;
*cursor++ = 0;
/* pack the directory */
seg = (PackFile_Segment *) dir;
/* dir size */
size = seg->op_count;
ret = PackFile_Segment_pack(interp, seg, cursor);
if ((size_t)(ret - cursor) != size) {
Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_MALFORMED_PACKFILE,
"PackFile_pack segment '%Ss' used size %d but reported %d\n",
seg->name, (int)(ret-cursor), (int)size);
}
}
opcode_t*
PF_store_string(opcode_t *cursor, STRING *s)
{
opcode_t padded_size = s->bufused;
char *charcursor;
size_t i;
if (padded_size % sizeof(opcode_t)) {
padded_size += sizeof(opcode_t) - (padded_size % sizeof(opcode_t));
}
*cursor++ = PObj_get_FLAGS(s); /* only constant_FLAG */
*cursor++ = s->encoding->index;
*cursor++ = s->type->index;
*cursor++ = s->bufused;
/* Switch to char * since rest of string is addressed by
* characters to ensure padding. */
charcursor = (char *)cursor;
if (s->strstart) {
mem_sys_memcopy(charcursor, s->strstart, s->bufused);
charcursor += s->bufused;
if (s->bufused % sizeof(opcode_t)) {
for (i = 0; i < (sizeof(opcode_t) -
(s->bufused % sizeof(opcode_t))); i++) {
*charcursor++ = 0;
}
}
}
assert( ((int)charcursor & 3) == 0);
LVALUE_CAST(char *, cursor) = charcursor;
return cursor;
}
opcode_t*
PF_store_number(opcode_t *cursor, FLOATVAL *val)
{
opcode_t padded_size = (sizeof(FLOATVAL) + sizeof(opcode_t) - 1) /
sizeof(opcode_t);
mem_sys_memcopy(cursor, val, sizeof(FLOATVAL));
cursor += padded_size;
return cursor;
}
Buffer *
buffer_unmake_COW(struct Parrot_Interp *interpreter, Buffer *src)
{
if (PObj_COW_TEST(src)) {
Buffer *b = new_buffer_header(interpreter);
Parrot_allocate(interpreter, b, src->buflen);
mem_sys_memcopy(b->bufstart, src->bufstart, src->buflen);
return b;
}
return src;
}
static QUEUE_ENTRY*
dup_entry(QUEUE_ENTRY* entry)
{
parrot_event *event;
QUEUE_ENTRY *new_entry;
new_entry = mem_sys_allocate(sizeof(QUEUE_ENTRY));
new_entry->next = NULL;
new_entry->type = entry->type;
event = new_entry->data = mem_sys_allocate(sizeof(parrot_event));
mem_sys_memcopy(event, entry->data, sizeof(parrot_event));
return new_entry;
}
Buffer *
buffer_copy_if_diff(struct Parrot_Interp *interpreter, Buffer *src, Buffer *dst)
{
Buffer *b;
/* if src and dst point to the same COWed bufstart,
* src hadn't changed yet
*/
if (src->bufstart == dst->bufstart)
return dst;
b = new_buffer_header(interpreter);
Parrot_allocate(interpreter, b, src->buflen);
mem_sys_memcopy(b->bufstart, src->bufstart, src->buflen);
return b;
}
opcode_t *
runops_slow_core(struct Parrot_Interp *interpreter, opcode_t *pc)
{
#ifdef USE_TRACE_INTERP
Interp * trace_i;
struct Parrot_Context *trace_ctx;
#endif
opcode_t *opc, *ostart, *oend;
static size_t dod, gc;
#ifdef code_start
# undef code_start
#endif
#ifdef code_end
# undef code_end
#endif
#define code_start interpreter->code->byte_code
#define code_end (interpreter->code->byte_code + \
interpreter->code->cur_cs->base.size)
#ifdef USE_TRACE_INTERP
if (Interp_flags_TEST(interpreter, PARROT_TRACE_FLAG)) {
trace_i = make_interpreter(interpreter, NO_FLAGS);
Parrot_init(trace_i);
/* remeber old context */
trace_ctx = mem_sys_allocate(sizeof(struct Parrot_Context));
mem_sys_memcopy(trace_ctx, &trace_i->ctx,
sizeof(struct Parrot_Context));
/* copy in current */
mem_sys_memcopy(&trace_i->ctx, &interpreter->ctx,
sizeof(struct Parrot_Context));
trace_i->code = interpreter->code;
Interp_flags_SET(trace_i, PARROT_EXTERN_CODE_FLAG);
}
#endif
dod = interpreter->dod_runs;
gc = interpreter->collect_runs;
while (pc) {/* && pc >= code_start && pc < code_end) {*/
interpreter->cur_pc = pc;
opc = pc;
ostart = code_start;
oend = code_end;
DO_OP(pc, interpreter);
if (Interp_flags_TEST(interpreter, PARROT_TRACE_FLAG)) {
#ifdef USE_TRACE_INTERP
mem_sys_memcopy(&trace_i->ctx, &interpreter->ctx,
sizeof(struct Parrot_Context));
trace_op(trace_i, ostart, oend, opc);
#else
trace_op(interpreter, ostart, oend, opc);
#endif
if (dod != interpreter->dod_runs) {
dod = interpreter->dod_runs;
PIO_printf(interpreter, " DOD\n");
}
if (gc != interpreter->collect_runs) {
gc = interpreter->collect_runs;
PIO_printf(interpreter, " GC\n");
}
}
}
#ifdef USE_TRACE_INTERP
if (Interp_flags_TEST(interpreter, PARROT_TRACE_FLAG)) {
/* restore trace context */
mem_sys_memcopy(&trace_i->ctx, trace_ctx,
sizeof(struct Parrot_Context));
mem_sys_free(trace_ctx);
}
#endif
/* if (pc && (pc < code_start || pc >= code_end)) {
internal_exception(INTERP_ERROR,
"Error: Control left bounds of byte-code block (now at location %d)!\n",
(int)(pc - code_start));
}*/
#undef code_start
#undef code_end
return pc;
}
