[svn:parrot] r44111 - in branches/sys_mem_reduce: include/parrot src src/call src/packfile src/pmc
bacek at svn.parrot.org
bacek at svn.parrot.org
Wed Feb 17 20:41:50 UTC 2010
Author: bacek
Date: Wed Feb 17 20:41:48 2010
New Revision: 44111
URL: https://trac.parrot.org/parrot/changeset/44111
Log:
Rename gc_mem macros to mem_gc macros
Modified:
branches/sys_mem_reduce/include/parrot/memory.h
branches/sys_mem_reduce/src/call/args.c
branches/sys_mem_reduce/src/debug.c
branches/sys_mem_reduce/src/embed.c
branches/sys_mem_reduce/src/packfile.c
branches/sys_mem_reduce/src/packfile/pf_items.c
branches/sys_mem_reduce/src/pmc/bigint.pmc
branches/sys_mem_reduce/src/pmc/bignum.pmc
branches/sys_mem_reduce/src/pmc/callcontext.pmc
branches/sys_mem_reduce/src/pmc/fixedbooleanarray.pmc
branches/sys_mem_reduce/src/pmc/fixedfloatarray.pmc
branches/sys_mem_reduce/src/pmc/fixedintegerarray.pmc
branches/sys_mem_reduce/src/pmc/fixedpmcarray.pmc
branches/sys_mem_reduce/src/pmc/fixedstringarray.pmc
branches/sys_mem_reduce/src/pmc/resizablebooleanarray.pmc
branches/sys_mem_reduce/src/pmc/resizablefloatarray.pmc
branches/sys_mem_reduce/src/pmc/resizablestringarray.pmc
Modified: branches/sys_mem_reduce/include/parrot/memory.h
==============================================================================
--- branches/sys_mem_reduce/include/parrot/memory.h Wed Feb 17 20:41:10 2010 (r44110)
+++ branches/sys_mem_reduce/include/parrot/memory.h Wed Feb 17 20:41:48 2010 (r44111)
@@ -40,19 +40,19 @@
#define mem_allocate_n_zeroed_typed(n, type) (type *)mem_sys_allocate_zeroed((n) * sizeof(type))
#define mem_realloc_n_typed(p, n, type) (p) = (type *)mem_sys_realloc((p), (n)*sizeof(type))
-#define gc_mem_allocate_typed(i, type) \
+#define mem_gc_allocate_typed(i, type) \
(type *)Parrot_gc_allocate_memory_chunk((i), sizeof (type))
-#define gc_mem_allocate_n_typed(i, n, type) \
+#define mem_gc_allocate_n_typed(i, n, type) \
(type *)Parrot_gc_allocate_memory_chunk((i), (n) * sizeof(type))
-#define gc_mem_realloc_n_typed(i, p, n, type) \
+#define mem_gc_realloc_n_typed(i, p, n, type) \
(p) = (type *)Parrot_gc_reallocate_memory_chunk((i), (p), (n)*sizeof(type))
-#define gc_mem_allocate_zeroed_typed(i, type) \
+#define mem_gc_allocate_zeroed_typed(i, type) \
(type *)Parrot_gc_allocate_memory_chunk_with_interior_pointers((i), sizeof (type))
-#define gc_mem_allocate_n_zeroed_typed(i, n, type) \
+#define mem_gc_allocate_n_zeroed_typed(i, n, type) \
(type *)Parrot_gc_allocate_memory_chunk_with_interior_pointers((i), (n) * sizeof(type))
-#define gc_mem_realloc_n_typed_zeroed(i, p, n, type) \
+#define mem_gc_realloc_n_typed_zeroed(i, p, n, type) \
(p) = (type *)Parrot_gc_reallocate_memory_chunk_with_interior_pointers((i), (p), (n)*sizeof(type))
-#define gc_mem_free(i, p) \
+#define mem_gc_free(i, p) \
Parrot_gc_free_memory_chunk((i), (p))
#define mem_copy_n_typed(dest, src, n, type) memcpy((dest), (src), (n)*sizeof(type))
Modified: branches/sys_mem_reduce/src/call/args.c
==============================================================================
--- branches/sys_mem_reduce/src/call/args.c Wed Feb 17 20:41:10 2010 (r44110)
+++ branches/sys_mem_reduce/src/call/args.c Wed Feb 17 20:41:48 2010 (r44111)
@@ -2860,7 +2860,7 @@
if (cur == 8) {
void * const old_values = values;
- values = gc_mem_allocate_n_typed(interp, 8, void *);
+ values = mem_gc_allocate_n_typed(interp, 8, void *);
memcpy(values, old_values, 8 * sizeof (void *));
Parrot_gc_free_fixed_size_storage(interp,
8 * sizeof (void *), old_values);
Modified: branches/sys_mem_reduce/src/debug.c
==============================================================================
--- branches/sys_mem_reduce/src/debug.c Wed Feb 17 20:41:10 2010 (r44110)
+++ branches/sys_mem_reduce/src/debug.c Wed Feb 17 20:41:48 2010 (r44111)
@@ -1001,7 +1001,7 @@
TRACEDEB_MSG("Parrot_debugger_init");
if (! interp->pdb) {
- PDB_t *pdb = gc_mem_allocate_zeroed_typed(interp, PDB_t);
+ PDB_t *pdb = mem_gc_allocate_zeroed_typed(interp, PDB_t);
Parrot_Interp debugger = Parrot_new(interp);
interp->pdb = pdb;
debugger->pdb = pdb;
@@ -1009,8 +1009,8 @@
pdb->debugger = debugger;
/* Allocate space for command line buffers, NUL terminated c strings */
- pdb->cur_command = gc_mem_allocate_n_typed(interp, DEBUG_CMD_BUFFER_LENGTH + 1, char);
- pdb->last_command = gc_mem_allocate_n_typed(interp, DEBUG_CMD_BUFFER_LENGTH + 1, char);
+ pdb->cur_command = mem_gc_allocate_n_typed(interp, DEBUG_CMD_BUFFER_LENGTH + 1, char);
+ pdb->last_command = mem_gc_allocate_n_typed(interp, DEBUG_CMD_BUFFER_LENGTH + 1, char);
pdb->file = mem_allocate_zeroed_typed(PDB_file_t);
}
@@ -1044,10 +1044,10 @@
PARROT_ASSERT(pdb);
PARROT_ASSERT(pdb->debugee == interp);
- gc_mem_free(interp, pdb->last_command);
- gc_mem_free(interp, pdb->cur_command);
+ mem_gc_free(interp, pdb->last_command);
+ mem_gc_free(interp, pdb->cur_command);
- gc_mem_free(interp, pdb);
+ mem_gc_free(interp, pdb);
interp->pdb = NULL;
}
@@ -1627,7 +1627,7 @@
}
/* Allocate new condition */
- condition = gc_mem_allocate_zeroed_typed(interp, PDB_condition_t);
+ condition = mem_gc_allocate_zeroed_typed(interp, PDB_condition_t);
condition->type = cond_argleft | cond_type;
@@ -1640,7 +1640,7 @@
if (cond_argright != cond_argleft) {
Parrot_io_eprintf(interp->pdb->debugger, "Register types don't agree\n");
- gc_mem_free(interp, condition);
+ mem_gc_free(interp, condition);
return NULL;
}
@@ -1649,28 +1649,28 @@
reg_number = (int)get_uint(&command, 0);
if (auxcmd == command) {
Parrot_io_eprintf(interp->pdb->debugger, "Invalid register\n");
- gc_mem_free(interp, condition);
+ mem_gc_free(interp, condition);
return NULL;
}
if (reg_number < 0) {
Parrot_io_eprintf(interp->pdb->debugger, "Out-of-bounds register\n");
- gc_mem_free(interp, condition);
+ mem_gc_free(interp, condition);
return NULL;
}
- condition->value = gc_mem_allocate_typed(interp, int);
+ condition->value = mem_gc_allocate_typed(interp, int);
*(int *)condition->value = reg_number;
}
/* If the first argument was an integer */
else if (condition->type & PDB_cond_int) {
/* This must be either an integer constant or register */
- condition->value = gc_mem_allocate_typed(interp, INTVAL);
+ condition->value = mem_gc_allocate_typed(interp, INTVAL);
*(INTVAL *)condition->value = (INTVAL)atoi(command);
condition->type |= PDB_cond_const;
}
else if (condition->type & PDB_cond_num) {
- condition->value = gc_mem_allocate_typed(interp, FLOATVAL);
+ condition->value = mem_gc_allocate_typed(interp, FLOATVAL);
*(FLOATVAL *)condition->value = (FLOATVAL)atof(command);
condition->type |= PDB_cond_const;
}
@@ -1690,7 +1690,7 @@
/* TT #1259: Need to figure out what to do in this case.
* For the time being, we just bail. */
Parrot_io_eprintf(interp->pdb->debugger, "Can't compare PMC with constant\n");
- gc_mem_free(interp, condition);
+ mem_gc_free(interp, condition);
return NULL;
}
@@ -1813,7 +1813,7 @@
TRACEDEB_MSG("PDB_set_break allocate breakpoint");
/* Allocate the new break point */
- newbreak = gc_mem_allocate_zeroed_typed(interp, PDB_breakpoint_t);
+ newbreak = mem_gc_allocate_zeroed_typed(interp, PDB_breakpoint_t);
if (command) {
/*command = skip_command(command);*/
@@ -2104,7 +2104,7 @@
}
bp_id = breakpoint->id;
/* Kill the breakpoint */
- gc_mem_free(interp, breakpoint);
+ mem_gc_free(interp, breakpoint);
Parrot_io_eprintf(interp->pdb->debugger, "Breakpoint %li deleted\n", bp_id);
}
@@ -2134,12 +2134,12 @@
}
else {
/* 'value' is a float or an int, so we can just free it */
- gc_mem_free(interp, breakpoint->condition->value);
+ mem_gc_free(interp, breakpoint->condition->value);
breakpoint->condition->value = NULL;
}
}
- gc_mem_free(interp, breakpoint->condition);
+ mem_gc_free(interp, breakpoint->condition);
breakpoint->condition = NULL;
}
@@ -2424,7 +2424,7 @@
if (!string)
return NULL;
- fill = _new = gc_mem_allocate_n_typed(interp, length * 2 + 1, char);
+ fill = _new = mem_gc_allocate_n_typed(interp, length * 2 + 1, char);
for (; string < end; string++) {
switch (*string) {
@@ -2629,7 +2629,7 @@
if (escaped) {
strcpy(&dest[size], escaped);
size += strlen(escaped);
- gc_mem_free(interp, escaped);
+ mem_gc_free(interp, escaped);
}
Parrot_str_free_cstring(unescaped);
}
@@ -2855,8 +2855,8 @@
TRACEDEB_MSG("PDB_disassemble");
- pfile = gc_mem_allocate_zeroed_typed(interp, PDB_file_t);
- pline = gc_mem_allocate_zeroed_typed(interp, PDB_line_t);
+ pfile = mem_gc_allocate_zeroed_typed(interp, PDB_file_t);
+ pline = mem_gc_allocate_zeroed_typed(interp, PDB_line_t);
/* If we already got a source, free it */
if (pdb->file) {
@@ -2866,7 +2866,7 @@
pfile->line = pline;
pline->number = 1;
- pfile->source = gc_mem_allocate_n_typed(interp, default_size, char);
+ pfile->source = mem_gc_allocate_n_typed(interp, default_size, char);
alloced = space = default_size;
code_end = pc + interp->code->base.size;
@@ -2876,7 +2876,7 @@
if (space < default_size) {
alloced += default_size;
space += default_size;
- pfile->source = gc_mem_realloc_n_typed(interp, pfile->source, alloced, char);
+ pfile->source = mem_gc_realloc_n_typed(interp, pfile->source, alloced, char);
}
size = PDB_disassemble_op(interp, pfile->source + pfile->size,
@@ -2893,7 +2893,7 @@
pc += n;
/* Prepare for next line */
- newline = gc_mem_allocate_zeroed_typed(interp, PDB_line_t);
+ newline = mem_gc_allocate_zeroed_typed(interp, PDB_line_t);
newline->label = NULL;
newline->next = NULL;
newline->number = pline->number + 1;
@@ -2958,7 +2958,7 @@
/* Allocate a new label */
label = file->label;
- _new = gc_mem_allocate_zeroed_typed(interp, PDB_label_t);
+ _new = mem_gc_allocate_zeroed_typed(interp, PDB_label_t);
_new->opcode = cur_opcode + offset;
_new->next = NULL;
@@ -2999,7 +2999,7 @@
while (line) {
PDB_line_t * const nline = line->next;
- gc_mem_free(interp, line);
+ mem_gc_free(interp, line);
line = nline;
}
@@ -3009,19 +3009,19 @@
while (label) {
PDB_label_t * const nlabel = label->next;
- gc_mem_free(interp, label);
+ mem_gc_free(interp, label);
label = nlabel;
}
/* Free the remaining allocated portions of the file structure */
if (file->sourcefilename)
- gc_mem_free(interp, file->sourcefilename);
+ mem_gc_free(interp, file->sourcefilename);
if (file->source)
- gc_mem_free(interp, file->source);
+ mem_gc_free(interp, file->source);
nfile = file->next;
- gc_mem_free(interp, file);
+ mem_gc_free(interp, file);
file = nfile;
}
}
@@ -3077,10 +3077,10 @@
return;
}
- pfile = gc_mem_allocate_zeroed_typed(interp, PDB_file_t);
- pline = gc_mem_allocate_zeroed_typed(interp, PDB_line_t);
+ pfile = mem_gc_allocate_zeroed_typed(interp, PDB_file_t);
+ pline = mem_gc_allocate_zeroed_typed(interp, PDB_line_t);
- pfile->source = gc_mem_allocate_n_typed(interp, 1024, char);
+ pfile->source = mem_gc_allocate_n_typed(interp, 1024, char);
pfile->line = pline;
pline->number = 1;
@@ -3090,7 +3090,7 @@
while ((c = fgetc(file)) != EOF) {
/* Grow it */
if (++size == 1024) {
- pfile->source = gc_mem_realloc_n_typed(interp, pfile->source,
+ pfile->source = mem_gc_realloc_n_typed(interp, pfile->source,
(size_t)pfile->size + 1024, char);
size = 0;
}
@@ -3101,7 +3101,7 @@
if (c == '\n') {
/* If the line has an opcode move to the next one,
otherwise leave it with NULL to skip it. */
- PDB_line_t *newline = gc_mem_allocate_zeroed_typed(interp, PDB_line_t);
+ PDB_line_t *newline = mem_gc_allocate_zeroed_typed(interp, PDB_line_t);
if (PDB_hasinstruction(pfile->source + pline->source_offset)) {
size_t n = interp->op_info_table[*pc].op_count;
Modified: branches/sys_mem_reduce/src/embed.c
==============================================================================
--- branches/sys_mem_reduce/src/embed.c Wed Feb 17 20:41:10 2010 (r44110)
+++ branches/sys_mem_reduce/src/embed.c Wed Feb 17 20:41:48 2010 (r44111)
@@ -463,7 +463,7 @@
INTVAL wanted = program_size;
size_t read_result;
- program_code = gc_mem_allocate_n_typed(interp, chunk_size, char);
+ program_code = mem_gc_allocate_n_typed(interp, chunk_size, char);
cursor = program_code;
program_size = 0;
@@ -474,7 +474,7 @@
break;
chunk_size = 1024;
- gc_mem_realloc_n_typed(interp, program_code, program_size + chunk_size, char);
+ mem_gc_realloc_n_typed(interp, program_code, program_size + chunk_size, char);
if (!program_code) {
Parrot_io_eprintf(interp,
@@ -492,7 +492,7 @@
"Parrot VM: Problem reading packfile from PIO: code %d.\n",
ferror(io));
fclose(io);
- gc_mem_free(interp, program_code);
+ mem_gc_free(interp, program_code);
return NULL;
}
@@ -980,7 +980,7 @@
Parrot_disassemble(PARROT_INTERP, SHIM(const char *outfile), Parrot_disassemble_options options)
{
PDB_line_t *line;
- PDB_t * const pdb = gc_mem_allocate_typed(interp, PDB_t);
+ PDB_t * const pdb = mem_gc_allocate_typed(interp, PDB_t);
int num_mappings = 0;
int curr_mapping = 0;
int op_code_seq_num = 0;
Modified: branches/sys_mem_reduce/src/packfile.c
==============================================================================
--- branches/sys_mem_reduce/src/packfile.c Wed Feb 17 20:41:10 2010 (r44110)
+++ branches/sys_mem_reduce/src/packfile.c Wed Feb 17 20:41:48 2010 (r44111)
@@ -552,9 +552,9 @@
}
#endif
- gc_mem_free(interp, pf->header);
+ mem_gc_free(interp, pf->header);
pf->header = NULL;
- gc_mem_free(interp, pf->dirp);
+ mem_gc_free(interp, pf->dirp);
pf->dirp = NULL;
PackFile_Segment_destroy(interp, &pf->directory.base);
return;
@@ -1078,7 +1078,7 @@
/* Read in the UUID. We'll put it in a NULL-terminated string, just in
* case people use it that way. */
- header->uuid_data = gc_mem_allocate_n_typed(interp,
+ header->uuid_data = mem_gc_allocate_n_typed(interp,
header->uuid_size + 1, unsigned char);
memcpy(header->uuid_data, packed + PACKFILE_HEADER_BYTES,
@@ -1400,8 +1400,8 @@
PackFile_new(PARROT_INTERP, INTVAL is_mapped)
{
ASSERT_ARGS(PackFile_new)
- PackFile * const pf = gc_mem_allocate_zeroed_typed(interp, PackFile);
- pf->header = gc_mem_allocate_zeroed_typed(interp, PackFile_Header);
+ PackFile * const pf = mem_gc_allocate_zeroed_typed(interp, PackFile);
+ pf->header = mem_gc_allocate_zeroed_typed(interp, PackFile_Header);
pf->is_mmap_ped = is_mapped;
pf->options = PFOPT_NONE;
@@ -1519,7 +1519,7 @@
}
/* else allocate mem */
- self->data = gc_mem_allocate_n_typed(interp, self->size, opcode_t);
+ self->data = mem_gc_allocate_n_typed(interp, self->size, opcode_t);
if (!self->data) {
Parrot_io_eprintf(NULL, "PackFile_unpack: Unable to allocate data memory!\n");
@@ -2000,7 +2000,7 @@
{
ASSERT_ARGS(directory_new)
- return (PackFile_Segment *)gc_mem_allocate_zeroed_typed(interp, PackFile_Directory);
+ return (PackFile_Segment *)mem_gc_allocate_zeroed_typed(interp, PackFile_Directory);
}
@@ -2093,7 +2093,7 @@
/* create it */
name = Parrot_str_new(interp, buf, strlen(buf));
seg = PackFile_Segment_new_seg(interp, dir, type, name, 0);
- gc_mem_free(interp, buf);
+ mem_gc_free(interp, buf);
seg->file_offset = PF_fetch_opcode(pf, &cursor);
TRACE_PRINTF_VAL(("Segment file_offset %ld.\n", seg->file_offset));
@@ -2235,7 +2235,7 @@
}
if (dir->segments) {
- gc_mem_free(interp, dir->segments);
+ mem_gc_free(interp, dir->segments);
dir->segments = NULL;
dir->num_segments = 0;
}
@@ -2477,7 +2477,7 @@
PackFile_Segment_new(PARROT_INTERP, SHIM(PackFile *pf), SHIM(STRING *name), SHIM(int add))
{
ASSERT_ARGS(PackFile_Segment_new)
- PackFile_Segment * const seg = gc_mem_allocate_zeroed_typed(interp, PackFile_Segment);
+ PackFile_Segment * const seg = mem_gc_allocate_zeroed_typed(interp, PackFile_Segment);
return seg;
}
@@ -2507,11 +2507,11 @@
{
ASSERT_ARGS(default_destroy)
if (!self->pf->is_mmap_ped && self->data) {
- gc_mem_free(interp, self->data);
+ mem_gc_free(interp, self->data);
self->data = NULL;
}
- gc_mem_free(interp, self);
+ mem_gc_free(interp, self);
}
@@ -2592,7 +2592,7 @@
byte_code->prederef.code = NULL;
if (byte_code->prederef.branches) {
- gc_mem_free(interp, byte_code->prederef.branches);
+ mem_gc_free(interp, byte_code->prederef.branches);
byte_code->prederef.branches = NULL;
}
}
@@ -2620,7 +2620,7 @@
byte_code_new(PARROT_INTERP, SHIM(PackFile *pf), SHIM(STRING *name), SHIM(int add))
{
ASSERT_ARGS(byte_code_new)
- PackFile_ByteCode * const byte_code = gc_mem_allocate_zeroed_typed(interp, PackFile_ByteCode);
+ PackFile_ByteCode * const byte_code = mem_gc_allocate_zeroed_typed(interp, PackFile_ByteCode);
return (PackFile_Segment *) byte_code;
}
@@ -2651,10 +2651,10 @@
/* Free each mapping. */
for (i = 0; i < debug->num_mappings; i++)
- gc_mem_free(interp, debug->mappings[i]);
+ mem_gc_free(interp, debug->mappings[i]);
/* Free mappings pointer array. */
- gc_mem_free(interp, debug->mappings);
+ mem_gc_free(interp, debug->mappings);
debug->mappings = NULL;
debug->num_mappings = 0;
}
@@ -2678,9 +2678,9 @@
pf_debug_new(PARROT_INTERP, SHIM(PackFile *pf), SHIM(STRING *name), SHIM(int add))
{
ASSERT_ARGS(pf_debug_new)
- PackFile_Debug * const debug = gc_mem_allocate_zeroed_typed(interp, PackFile_Debug);
+ PackFile_Debug * const debug = mem_gc_allocate_zeroed_typed(interp, PackFile_Debug);
- debug->mappings = gc_mem_allocate_zeroed_typed(interp,
+ debug->mappings = mem_gc_allocate_zeroed_typed(interp,
PackFile_DebugFilenameMapping *);
debug->mappings[0] = NULL;
@@ -2784,7 +2784,7 @@
for (i = 0; i < debug->num_mappings; i++) {
/* Allocate struct and get offset and filename type. */
debug->mappings[i] =
- gc_mem_allocate_zeroed_typed(interp, PackFile_DebugFilenameMapping);
+ mem_gc_allocate_zeroed_typed(interp, PackFile_DebugFilenameMapping);
debug->mappings[i]->offset = PF_fetch_opcode(self->pf, &cursor);
debug->mappings[i]->filename = PF_fetch_opcode(self->pf, &cursor);
}
@@ -2882,7 +2882,7 @@
debug = (PackFile_Debug *)PackFile_Segment_new_seg(interp, dir,
PF_DEBUG_SEG, name, add);
- debug->base.data = gc_mem_allocate_n_zeroed_typed(interp, size, opcode_t);
+ debug->base.data = mem_gc_allocate_n_zeroed_typed(interp, size, opcode_t);
debug->code = cs;
cs->debugs = debug;
}
@@ -2952,7 +2952,7 @@
{
/* Set up new entry and insert it. */
PackFile_DebugFilenameMapping *mapping =
- gc_mem_allocate_zeroed_typed(interp, PackFile_DebugFilenameMapping);
+ mem_gc_allocate_zeroed_typed(interp, PackFile_DebugFilenameMapping);
STRING *namestr = Parrot_str_new_init(interp, filename, strlen(filename),
PARROT_DEFAULT_ENCODING, PARROT_DEFAULT_CHARSET, 0);
size_t count = ct->const_count;
@@ -3140,7 +3140,7 @@
&& VTABLE_isa(interp, old_const->u.key, _sub)) {
PMC *old_sub_pmc, *new_sub_pmc;
Parrot_Sub_attributes *old_sub, *new_sub;
- PackFile_Constant * const ret = gc_mem_allocate_zeroed_typed(interp,
+ PackFile_Constant * const ret = mem_gc_allocate_zeroed_typed(interp,
PackFile_Constant);
ret->type = old_const->type;
@@ -3207,7 +3207,7 @@
INTVAL const num_consts = ct->const_count;
INTVAL i;
- new_consts = gc_mem_allocate_n_zeroed_typed(interp,
+ new_consts = mem_gc_allocate_n_zeroed_typed(interp,
num_consts, PackFile_Constant *);
for (i = 0; i < num_consts; ++i)
@@ -3260,10 +3260,10 @@
for (j = 0; j < table->const_count; ++j) {
if (consts[j] != orig_consts[j])
- gc_mem_free(interp, consts[j]);
+ mem_gc_free(interp, consts[j]);
}
- gc_mem_free(interp, consts);
+ mem_gc_free(interp, consts);
bucket = bucket->next;
}
}
@@ -3302,15 +3302,15 @@
}
for (i = 0; i < self->fixup_count; i++) {
- gc_mem_free(interp, self->fixups[i]->name);
+ mem_gc_free(interp, self->fixups[i]->name);
self->fixups[i]->name = NULL;
- gc_mem_free(interp, self->fixups[i]);
+ mem_gc_free(interp, self->fixups[i]);
self->fixups[i] = NULL;
}
if (self->fixup_count) {
- gc_mem_free(interp, self->fixups);
+ mem_gc_free(interp, self->fixups);
self->fixups = NULL;
}
@@ -3438,7 +3438,7 @@
fixup_new(PARROT_INTERP, SHIM(PackFile *pf), SHIM(STRING *name), SHIM(int add))
{
ASSERT_ARGS(fixup_new)
- PackFile_FixupTable * const fixup = gc_mem_allocate_zeroed_typed(interp,
+ PackFile_FixupTable * const fixup = mem_gc_allocate_zeroed_typed(interp,
PackFile_FixupTable);
return (PackFile_Segment *) fixup;
@@ -3483,7 +3483,7 @@
self->fixup_count));
if (self->fixup_count) {
- self->fixups = gc_mem_allocate_n_zeroed_typed(interp,
+ self->fixups = mem_gc_allocate_n_zeroed_typed(interp,
self->fixup_count, PackFile_FixupEntry *);
if (!self->fixups) {
@@ -3658,7 +3658,7 @@
/* TODO make a hash of all fixups */
PackFile_Directory * const dir = interp->code->base.dir;
- PackFile_FixupEntry * const ep = gc_mem_allocate_zeroed_typed(interp, PackFile_FixupEntry);
+ PackFile_FixupEntry * const ep = mem_gc_allocate_zeroed_typed(interp, PackFile_FixupEntry);
ep->type = type;
ep->name = name;
@@ -3700,7 +3700,7 @@
}
if (self->constants) {
- gc_mem_free(interp, self->constants);
+ mem_gc_free(interp, self->constants);
self->constants = NULL;
}
@@ -3748,7 +3748,7 @@
if (self->const_count == 0)
return cursor;
- self->constants = gc_mem_allocate_n_zeroed_typed(interp, self->const_count,
+ self->constants = mem_gc_allocate_n_zeroed_typed(interp, self->const_count,
PackFile_Constant *);
if (!self->constants) {
@@ -3789,7 +3789,7 @@
{
ASSERT_ARGS(const_new)
PackFile_ConstTable * const const_table =
- gc_mem_allocate_zeroed_typed(interp, PackFile_ConstTable);
+ mem_gc_allocate_zeroed_typed(interp, PackFile_ConstTable);
return (PackFile_Segment *)const_table;
}
@@ -3839,7 +3839,7 @@
PackFile_Constant_new(PARROT_INTERP)
{
ASSERT_ARGS(PackFile_Constant_new)
- PackFile_Constant * const self = gc_mem_allocate_zeroed_typed(interp,
+ PackFile_Constant * const self = mem_gc_allocate_zeroed_typed(interp,
PackFile_Constant);
self->type = PFC_NONE;
@@ -3865,7 +3865,7 @@
PackFile_Constant_destroy(PARROT_INTERP, ARGMOD_NULLOK(PackFile_Constant *self))
{
ASSERT_ARGS(PackFile_Constant_destroy)
- gc_mem_free(interp, self);
+ mem_gc_free(interp, self);
}
@@ -4144,7 +4144,7 @@
/* Allocate annotations structure; create it all zeroed, and we will
* allocate memory for each of the arrays on demand. */
- PackFile_Annotations * const seg = gc_mem_allocate_zeroed_typed(interp,
+ PackFile_Annotations * const seg = mem_gc_allocate_zeroed_typed(interp,
PackFile_Annotations);
return (PackFile_Segment *) seg;
}
@@ -4170,23 +4170,23 @@
/* Free any keys. */
if (self->keys) {
for (i = 0; i < self->num_keys; i++)
- gc_mem_free(interp, self->keys[i]);
+ mem_gc_free(interp, self->keys[i]);
- gc_mem_free(interp, self->keys);
+ mem_gc_free(interp, self->keys);
}
/* Free any groups. */
if (self->groups) {
for (i = 0; i < self->num_groups; i++)
- gc_mem_free(interp, self->groups[i]);
- gc_mem_free(interp, self->groups);
+ mem_gc_free(interp, self->groups[i]);
+ mem_gc_free(interp, self->groups);
}
/* Free any entries. */
if (self->entries) {
for (i = 0; i < self->num_entries; i++)
- gc_mem_free(interp, self->entries[i]);
- gc_mem_free(interp, self->entries);
+ mem_gc_free(interp, self->entries[i]);
+ mem_gc_free(interp, self->entries);
}
}
@@ -4300,12 +4300,12 @@
TRACE_PRINTF(("PackFile_Annotations_unpack: Unpacking %ld keys\n",
self->num_keys));
- self->keys = gc_mem_allocate_n_zeroed_typed(interp,
+ self->keys = mem_gc_allocate_n_zeroed_typed(interp,
self->num_keys, PackFile_Annotations_Key *);
for (i = 0; i < self->num_keys; i++) {
PackFile_Annotations_Key * const key = self->keys[i] =
- gc_mem_allocate_zeroed_typed(interp, PackFile_Annotations_Key);
+ mem_gc_allocate_zeroed_typed(interp, PackFile_Annotations_Key);
key->name = PF_fetch_opcode(seg->pf, &cursor);
key->type = PF_fetch_opcode(seg->pf, &cursor);
TRACE_PRINTF_VAL(("PackFile_Annotations_unpack: key[%d]/%d name=%s type=%d\n",
@@ -4314,12 +4314,12 @@
/* Unpack groups. */
self->num_groups = PF_fetch_opcode(seg->pf, &cursor);
- self->groups = gc_mem_allocate_n_zeroed_typed(interp,
+ self->groups = mem_gc_allocate_n_zeroed_typed(interp,
self->num_groups, PackFile_Annotations_Group *);
for (i = 0; i < self->num_groups; i++) {
PackFile_Annotations_Group * const group =
- self->groups[i] = gc_mem_allocate_zeroed_typed(interp,
+ self->groups[i] = mem_gc_allocate_zeroed_typed(interp,
PackFile_Annotations_Group);
group->bytecode_offset = PF_fetch_opcode(seg->pf, &cursor);
group->entries_offset = PF_fetch_opcode(seg->pf, &cursor);
@@ -4331,11 +4331,11 @@
/* Unpack entries. */
self->num_entries = PF_fetch_opcode(seg->pf, &cursor);
- self->entries = gc_mem_allocate_n_zeroed_typed(interp,
+ self->entries = mem_gc_allocate_n_zeroed_typed(interp,
self->num_entries, PackFile_Annotations_Entry *);
for (i = 0; i < self->num_entries; i++) {
PackFile_Annotations_Entry * const entry =
- self->entries[i] = gc_mem_allocate_zeroed_typed(interp,
+ self->entries[i] = mem_gc_allocate_zeroed_typed(interp,
PackFile_Annotations_Entry);
entry->bytecode_offset = PF_fetch_opcode(seg->pf, &cursor);
entry->key = PF_fetch_opcode(seg->pf, &cursor);
@@ -4453,15 +4453,15 @@
/* Allocate extra space for the group in the groups array. */
if (self->groups)
self->groups =
- gc_mem_realloc_n_typed_zeroed(interp, self->groups,
+ mem_gc_realloc_n_typed_zeroed(interp, self->groups,
1 + self->num_groups, PackFile_Annotations_Group *);
else
- self->groups = gc_mem_allocate_n_typed(interp,
+ self->groups = mem_gc_allocate_n_typed(interp,
1 + self->num_groups, PackFile_Annotations_Group *);
/* Store details. */
self->groups[self->num_groups] =
- gc_mem_allocate_zeroed_typed(interp,
+ mem_gc_allocate_zeroed_typed(interp,
PackFile_Annotations_Group);
self->groups[self->num_groups]->bytecode_offset = offset;
self->groups[self->num_groups]->entries_offset = self->num_entries;
@@ -4510,14 +4510,14 @@
/* We do have it. Add key entry. */
if (self->keys)
self->keys =
- gc_mem_realloc_n_typed_zeroed(interp, self->keys,
+ mem_gc_realloc_n_typed_zeroed(interp, self->keys,
1 + self->num_keys, PackFile_Annotations_Key *);
else
- self->keys = gc_mem_allocate_n_typed(interp,
+ self->keys = mem_gc_allocate_n_typed(interp,
1 + self->num_keys, PackFile_Annotations_Key *);
key_id = self->num_keys;
- self->keys[key_id] = gc_mem_allocate_typed(interp, PackFile_Annotations_Key);
+ self->keys[key_id] = mem_gc_allocate_typed(interp, PackFile_Annotations_Key);
self->num_keys++;
/* Populate it. */
@@ -4535,14 +4535,14 @@
/* Add annotations entry. */
if (self->entries)
- self->entries = gc_mem_realloc_n_typed(interp, self->entries,
+ self->entries = mem_gc_realloc_n_typed(interp, self->entries,
1 + self->num_entries, PackFile_Annotations_Entry *);
else
- self->entries = gc_mem_allocate_n_typed(interp,
+ self->entries = mem_gc_allocate_n_typed(interp,
1 + self->num_entries, PackFile_Annotations_Entry *);
self->entries[self->num_entries] =
- gc_mem_allocate_typed(interp, PackFile_Annotations_Entry);
+ mem_gc_allocate_typed(interp, PackFile_Annotations_Entry);
self->entries[self->num_entries]->bytecode_offset = offset;
self->entries[self->num_entries]->key = key_id;
self->entries[self->num_entries]->value = value;
@@ -4642,9 +4642,9 @@
if (key_id == -1) {
/* Look through entries, storing what we find by key and tracking those
* that we have values for. */
- opcode_t *latest_values = gc_mem_allocate_n_zeroed_typed(interp,
+ opcode_t *latest_values = mem_gc_allocate_n_zeroed_typed(interp,
self->num_keys, opcode_t);
- opcode_t *have_values = gc_mem_allocate_n_zeroed_typed(interp,
+ opcode_t *have_values = mem_gc_allocate_n_zeroed_typed(interp,
self->num_keys, opcode_t);
for (i = start_entry; i < self->num_entries; i++) {
@@ -4667,8 +4667,8 @@
}
}
- gc_mem_free(interp, latest_values);
- gc_mem_free(interp, have_values);
+ mem_gc_free(interp, latest_values);
+ mem_gc_free(interp, have_values);
}
else {
/* Look for latest applicable value of the key. */
@@ -4730,9 +4730,9 @@
Parrot_ex_throw_from_c_args(interp, NULL, 1,
"Unable to append PBC to the current directory");
- gc_mem_free(interp, pf->header);
+ mem_gc_free(interp, pf->header);
pf->header = NULL;
- gc_mem_free(interp, pf->dirp);
+ mem_gc_free(interp, pf->dirp);
pf->dirp = NULL;
}
Modified: branches/sys_mem_reduce/src/packfile/pf_items.c
==============================================================================
--- branches/sys_mem_reduce/src/packfile/pf_items.c Wed Feb 17 20:41:10 2010 (r44110)
+++ branches/sys_mem_reduce/src/packfile/pf_items.c Wed Feb 17 20:41:48 2010 (r44111)
@@ -1443,7 +1443,7 @@
{
ASSERT_ARGS(PF_fetch_cstring)
const size_t str_len = strlen((const char *)(*cursor)) + 1;
- char * const p = gc_mem_allocate_n_typed(interp, str_len, char);
+ char * const p = mem_gc_allocate_n_typed(interp, str_len, char);
const int wordsize = pf->header->wordsize;
TRACE_PRINTF(("PF_fetch_cstring(): size is %ld...\n", str_len));
Modified: branches/sys_mem_reduce/src/pmc/bigint.pmc
==============================================================================
--- branches/sys_mem_reduce/src/pmc/bigint.pmc Wed Feb 17 20:41:10 2010 (r44110)
+++ branches/sys_mem_reduce/src/pmc/bigint.pmc Wed Feb 17 20:41:48 2010 (r44111)
@@ -47,7 +47,7 @@
BIGINT * bi;
GETATTR_BigInt_bi(interp, self, bi);
mpz_clear(bi->b);
- gc_mem_free(interp, bi);
+ mem_gc_free(interp, bi);
}
static void
@@ -123,7 +123,7 @@
GETATTR_BigInt_bi(interp, self, bi);
n = mpz_sizeinbase(bi->b, base) + 2;
- s = gc_mem_allocate_n_typed(interp, n, char);
+ s = mem_gc_allocate_n_typed(interp, n, char);
return mpz_get_str(s, base, bi->b);
}
@@ -679,14 +679,14 @@
VTABLE STRING *get_string() {
char * const s = bigint_get_string(INTERP, SELF, 10);
STRING * const ps = Parrot_str_new(INTERP, s, 0);
- gc_mem_free(INTERP, s);
+ mem_gc_free(INTERP, s);
return ps;
}
VTABLE STRING *get_string_keyed_int(INTVAL base) {
char * const s = bigint_get_string(INTERP, SELF, base);
STRING * const ps = Parrot_str_new(INTERP, s, 0);
- gc_mem_free(INTERP, s);
+ mem_gc_free(INTERP, s);
return ps;
}
Modified: branches/sys_mem_reduce/src/pmc/bignum.pmc
==============================================================================
--- branches/sys_mem_reduce/src/pmc/bignum.pmc Wed Feb 17 20:41:10 2010 (r44110)
+++ branches/sys_mem_reduce/src/pmc/bignum.pmc Wed Feb 17 20:41:48 2010 (r44111)
@@ -170,7 +170,7 @@
BIGNUM *bn;
GETATTR_BigNum_bn(interp, self, bn);
mpf_clear(bn->b);
- gc_mem_free(interp, bn);
+ mem_gc_free(interp, bn);
#endif
}
@@ -282,7 +282,7 @@
GETATTR_BigNum_bn(interp, self, bn);
n = (mpf_get_prec(bn->b)) / log(base) * log(2);
- s = gc_mem_allocate_n_typed(interp, n + 5, char);
+ s = mem_gc_allocate_n_typed(interp, n + 5, char);
return mpf_get_str(s, &exponent, base, 0, bn->b);
}
@@ -294,7 +294,7 @@
mp_exp_t exponent;
GETATTR_BigNum_bn(interp, self, bn);
- s = gc_mem_allocate_n_typed(interp, digits + 5, char);
+ s = mem_gc_allocate_n_typed(interp, digits + 5, char);
return mpf_get_str(s, &exponent, base, digits, bn->b);
}
@@ -987,21 +987,21 @@
VTABLE STRING *get_string() {
char *s = bignum_get_string(INTERP, SELF, 10);
STRING *ps = Parrot_str_new(INTERP, s, 0);
- gc_mem_free(interp, s);
+ mem_gc_free(interp, s);
return ps;
}
VTABLE STRING *get_string_keyed_int(INTVAL base) {
char *s = bignum_get_string(INTERP, SELF, base);
STRING *ps = Parrot_str_new(INTERP, s, 0);
- gc_mem_free(interp, s);
+ mem_gc_free(interp, s);
return ps;
}
VTABLE STRING *get_string_keyed_int_int(INTVAL base, INTVAL digits) {
char *s = bignum_get_string_size(INTERP, SELF, base, digits);
STRING *ps = Parrot_str_new(INTERP, s, 0);
- gc_mem_free(interp, s);
+ mem_gc_free(interp, s);
return ps;
}
Modified: branches/sys_mem_reduce/src/pmc/callcontext.pmc
==============================================================================
--- branches/sys_mem_reduce/src/pmc/callcontext.pmc Wed Feb 17 20:41:10 2010 (r44110)
+++ branches/sys_mem_reduce/src/pmc/callcontext.pmc Wed Feb 17 20:41:48 2010 (r44111)
@@ -595,7 +595,7 @@
Parrot_gc_free_fixed_size_storage(INTERP,
8 * sizeof (void *), returns_values);
else
- gc_mem_free(INTERP, returns_values);
+ mem_gc_free(INTERP, returns_values);
}
Parrot_pcc_free_registers(INTERP, SELF);
Modified: branches/sys_mem_reduce/src/pmc/fixedbooleanarray.pmc
==============================================================================
--- branches/sys_mem_reduce/src/pmc/fixedbooleanarray.pmc Wed Feb 17 20:41:10 2010 (r44110)
+++ branches/sys_mem_reduce/src/pmc/fixedbooleanarray.pmc Wed Feb 17 20:41:48 2010 (r44111)
@@ -74,7 +74,7 @@
unsigned char *bit_array;
GET_ATTR_bit_array(INTERP, SELF, bit_array);
if (bit_array)
- gc_mem_free(INTERP, bit_array);
+ mem_gc_free(INTERP, bit_array);
}
/*
@@ -102,7 +102,7 @@
SET_ATTR_size(INTERP, dest, size);
SET_ATTR_resize_threshold(INTERP, dest, resize_threshold);
- clone_bit_array = gc_mem_allocate_n_typed(INTERP, size_in_bytes, unsigned char);
+ clone_bit_array = mem_gc_allocate_n_typed(INTERP, size_in_bytes, unsigned char);
mem_sys_memcopy(clone_bit_array, my_bit_array, size_in_bytes);
SET_ATTR_bit_array(INTERP, dest, clone_bit_array);
@@ -341,7 +341,7 @@
SET_ATTR_resize_threshold(INTERP, SELF, size_in_bytes * BITS_PER_CHAR);
// FIXME We should clear allocated memory
SET_ATTR_bit_array(INTERP, SELF,
- gc_mem_allocate_n_typed(INTERP, size_in_bytes, unsigned char));
+ mem_gc_allocate_n_typed(INTERP, size_in_bytes, unsigned char));
}
/*
Modified: branches/sys_mem_reduce/src/pmc/fixedfloatarray.pmc
==============================================================================
--- branches/sys_mem_reduce/src/pmc/fixedfloatarray.pmc Wed Feb 17 20:41:10 2010 (r44110)
+++ branches/sys_mem_reduce/src/pmc/fixedfloatarray.pmc Wed Feb 17 20:41:48 2010 (r44111)
@@ -43,7 +43,7 @@
FLOATVAL *float_array;
GET_ATTR_float_array(INTERP, SELF, float_array);
if (float_array)
- gc_mem_free(INTERP, float_array);
+ mem_gc_free(INTERP, float_array);
}
/*
Modified: branches/sys_mem_reduce/src/pmc/fixedintegerarray.pmc
==============================================================================
--- branches/sys_mem_reduce/src/pmc/fixedintegerarray.pmc Wed Feb 17 20:41:10 2010 (r44110)
+++ branches/sys_mem_reduce/src/pmc/fixedintegerarray.pmc Wed Feb 17 20:41:48 2010 (r44111)
@@ -92,7 +92,7 @@
GET_ATTR_size(INTERP, SELF, size);
- dest_int_array = gc_mem_allocate_n_typed(INTERP, size, INTVAL);
+ dest_int_array = mem_gc_allocate_n_typed(INTERP, size, INTVAL);
SET_ATTR_size(INTERP, dest, size);
SET_ATTR_int_array(INTERP, dest, dest_int_array);
Modified: branches/sys_mem_reduce/src/pmc/fixedpmcarray.pmc
==============================================================================
--- branches/sys_mem_reduce/src/pmc/fixedpmcarray.pmc Wed Feb 17 20:41:10 2010 (r44110)
+++ branches/sys_mem_reduce/src/pmc/fixedpmcarray.pmc Wed Feb 17 20:41:48 2010 (r44111)
@@ -88,7 +88,7 @@
VTABLE void destroy() {
if (PMC_array(SELF))
- gc_mem_free(INTERP, PMC_array(SELF));
+ mem_gc_free(INTERP, PMC_array(SELF));
}
/*
@@ -107,7 +107,7 @@
if (size) {
PMC_size(dest) = size;
- PMC_array(dest) = gc_mem_allocate_n_zeroed_typed(INTERP, size, PMC *);
+ PMC_array(dest) = mem_gc_allocate_n_zeroed_typed(INTERP, size, PMC *);
mem_copy_n_typed(PMC_array(dest), PMC_array(SELF), size, PMC *);
PObj_custom_mark_destroy_SETALL(dest);
}
@@ -397,10 +397,10 @@
_("Can't set self from this type"));
if (PMC_array(SELF))
- gc_mem_free(INTERP, PMC_array(SELF));
+ mem_gc_free(INTERP, PMC_array(SELF));
size = PMC_size(SELF) = VTABLE_elements(INTERP, value);
- PMC_array(SELF) = gc_mem_allocate_n_zeroed_typed(INTERP, size, PMC *);
+ PMC_array(SELF) = mem_gc_allocate_n_zeroed_typed(INTERP, size, PMC *);
for (i = 0; i < size; i++)
(PMC_array(SELF))[i] = VTABLE_get_pmc_keyed_int(INTERP, value, i);
Modified: branches/sys_mem_reduce/src/pmc/fixedstringarray.pmc
==============================================================================
--- branches/sys_mem_reduce/src/pmc/fixedstringarray.pmc Wed Feb 17 20:41:10 2010 (r44110)
+++ branches/sys_mem_reduce/src/pmc/fixedstringarray.pmc Wed Feb 17 20:41:48 2010 (r44111)
@@ -60,7 +60,7 @@
GET_ATTR_str_array(INTERP, SELF, str_array);
if (str_array)
- gc_mem_free(INTERP, str_array);
+ mem_gc_free(INTERP, str_array);
}
/*
@@ -87,7 +87,7 @@
GET_ATTR_size(INTERP, SELF, size);
mem_size = size * sizeof (STRING *);
- dest_str_array = gc_mem_allocate_n_zeroed_typed(INTERP, size, STRING *);
+ dest_str_array = mem_gc_allocate_n_zeroed_typed(INTERP, size, STRING *);
mem_sys_memcopy(dest_str_array, my_str_array, mem_size);
SET_ATTR_str_array(INTERP, dest, dest_str_array);
SET_ATTR_size(INTERP, dest, size);
@@ -341,7 +341,7 @@
SET_ATTR_size(INTERP, SELF, new_size);
SET_ATTR_str_array(INTERP, SELF,
- gc_mem_allocate_n_zeroed_typed(INTERP, new_size, STRING*));
+ mem_gc_allocate_n_zeroed_typed(INTERP, new_size, STRING*));
PObj_custom_mark_destroy_SETALL(SELF);
}
Modified: branches/sys_mem_reduce/src/pmc/resizablebooleanarray.pmc
==============================================================================
--- branches/sys_mem_reduce/src/pmc/resizablebooleanarray.pmc Wed Feb 17 20:41:10 2010 (r44110)
+++ branches/sys_mem_reduce/src/pmc/resizablebooleanarray.pmc Wed Feb 17 20:41:48 2010 (r44111)
@@ -166,7 +166,7 @@
SET_ATTR_bit_array(INTERP, SELF,
(unsigned char *)mem_sys_memmove(
new_store, old_store, copy_size));
- gc_mem_free(INTERP, old_store);
+ mem_gc_free(INTERP, old_store);
}
}
@@ -261,7 +261,7 @@
/* Replace old array with new array, and free old array */
SET_ATTR_bit_array(INTERP, SELF, new_bit_array);
- gc_mem_free(INTERP, old_bit_array);
+ mem_gc_free(INTERP, old_bit_array);
/* Added one allocation unit to the head position offset */
SET_ATTR_size(INTERP, SELF, tail_pos + MIN_ALLOC);
@@ -321,7 +321,7 @@
/* Replace old array with new array, and free old array */
SET_ATTR_bit_array(INTERP, SELF, new_bit_array);
- gc_mem_free(INTERP, old_bit_array);
+ mem_gc_free(INTERP, old_bit_array);
/* Removed one allocation unit from the head position offset */
SET_ATTR_size(INTERP, SELF, tail_pos - MIN_ALLOC);
Modified: branches/sys_mem_reduce/src/pmc/resizablefloatarray.pmc
==============================================================================
--- branches/sys_mem_reduce/src/pmc/resizablefloatarray.pmc Wed Feb 17 20:41:10 2010 (r44110)
+++ branches/sys_mem_reduce/src/pmc/resizablefloatarray.pmc Wed Feb 17 20:41:48 2010 (r44111)
@@ -130,7 +130,7 @@
cur &= ~0xfff;
}
SET_ATTR_float_array(INTERP, SELF,
- gc_mem_realloc_n_typed(INTERP, float_array, cur, FLOATVAL));
+ mem_gc_realloc_n_typed(INTERP, float_array, cur, FLOATVAL));
SET_ATTR_size(INTERP, SELF, size);
SET_ATTR_resize_threshold(INTERP, SELF, cur);
}
Modified: branches/sys_mem_reduce/src/pmc/resizablestringarray.pmc
==============================================================================
--- branches/sys_mem_reduce/src/pmc/resizablestringarray.pmc Wed Feb 17 20:41:10 2010 (r44110)
+++ branches/sys_mem_reduce/src/pmc/resizablestringarray.pmc Wed Feb 17 20:41:48 2010 (r44111)
@@ -241,7 +241,7 @@
}
SET_ATTR_str_array(INTERP, SELF,
- gc_mem_realloc_n_typed_zeroed(INTERP, str_array, cur, STRING*));
+ mem_gc_realloc_n_typed_zeroed(INTERP, str_array, cur, STRING*));
GET_ATTR_str_array(INTERP, SELF, str_array);
for (; i < cur; i++)
More information about the parrot-commits
mailing list