Avoid variable name "new", use more concrete name instead
Also confusing for syntax highlighter/indexer of some editors/IDEs
git-svn-id: svn://svn.valgrind.org/valgrind/trunk@10320 a5019735-40e9-0310-863c-91ae7b9d1cf9
diff --git a/callgrind/bb.c b/callgrind/bb.c
index a14b11e..3b8d1e8 100644
--- a/callgrind/bb.c
+++ b/callgrind/bb.c
@@ -121,8 +121,8 @@
static BB* new_bb(obj_node* obj, PtrdiffT offset,
UInt instr_count, UInt cjmp_count, Bool cjmp_inverted)
{
- BB* new;
- UInt new_idx, size;
+ BB* bb;
+ UInt idx, size;
/* check fill degree of bb hash table and resize if needed (>80%) */
bbs.entries++;
@@ -131,29 +131,29 @@
size = sizeof(BB) + instr_count * sizeof(InstrInfo)
+ (cjmp_count+1) * sizeof(CJmpInfo);
- new = (BB*) CLG_MALLOC("cl.bb.nb.1", size);
- VG_(memset)(new, 0, size);
+ bb = (BB*) CLG_MALLOC("cl.bb.nb.1", size);
+ VG_(memset)(bb, 0, size);
- new->obj = obj;
- new->offset = offset;
+ bb->obj = obj;
+ bb->offset = offset;
- new->instr_count = instr_count;
- new->cjmp_count = cjmp_count;
- new->cjmp_inverted = cjmp_inverted;
- new->jmp = (CJmpInfo*) &(new->instr[instr_count]);
- new->instr_len = 0;
- new->cost_count = 0;
- new->sect_kind = VG_(seginfo_sect_kind)(NULL, 0, offset + obj->offset);
- new->fn = 0;
- new->line = 0;
- new->is_entry = 0;
- new->bbcc_list = 0;
- new->last_bbcc = 0;
+ bb->instr_count = instr_count;
+ bb->cjmp_count = cjmp_count;
+ bb->cjmp_inverted = cjmp_inverted;
+ bb->jmp = (CJmpInfo*) &(bb->instr[instr_count]);
+ bb->instr_len = 0;
+ bb->cost_count = 0;
+ bb->sect_kind = VG_(seginfo_sect_kind)(NULL, 0, offset + obj->offset);
+ bb->fn = 0;
+ bb->line = 0;
+ bb->is_entry = 0;
+ bb->bbcc_list = 0;
+ bb->last_bbcc = 0;
/* insert into BB hash table */
- new_idx = bb_hash_idx(obj, offset, bbs.size);
- new->next = bbs.table[new_idx];
- bbs.table[new_idx] = new;
+ idx = bb_hash_idx(obj, offset, bbs.size);
+ bb->next = bbs.table[idx];
+ bbs.table[idx] = bb;
CLG_(stat).distinct_bbs++;
@@ -163,14 +163,14 @@
instr_count, cjmp_count,
cjmp_inverted ? "yes":"no",
CLG_(stat).distinct_bbs);
- CLG_(print_bb)(0, new);
+ CLG_(print_bb)(0, bb);
VG_(printf)("\n");
}
#endif
- CLG_(get_fn_node)(new);
+ CLG_(get_fn_node)(bb);
- return new;
+ return bb;
}
diff --git a/callgrind/bbcc.c b/callgrind/bbcc.c
index c1eaab3..dfe737b 100644
--- a/callgrind/bbcc.c
+++ b/callgrind/bbcc.c
@@ -247,13 +247,13 @@
{
BBCC** bbccs;
int i;
-
+
bbccs = (BBCC**) CLG_MALLOC("cl.bbcc.nr.1", sizeof(BBCC*) * size);
for(i=0;i<size;i++)
bbccs[i] = 0;
CLG_DEBUG(3," new_recursion(size %d): %p\n", size, bbccs);
-
+
return bbccs;
}
@@ -267,40 +267,40 @@
static __inline__
BBCC* new_bbcc(BB* bb)
{
- BBCC* new;
+ BBCC* bbcc;
Int i;
/* We need cjmp_count+1 JmpData structs:
* the last is for the unconditional jump/call/ret at end of BB
*/
- new = (BBCC*)CLG_MALLOC("cl.bbcc.nb.1",
- sizeof(BBCC) +
- (bb->cjmp_count+1) * sizeof(JmpData));
- new->bb = bb;
- new->tid = CLG_(current_tid);
+ bbcc = (BBCC*)CLG_MALLOC("cl.bbcc.nb.1",
+ sizeof(BBCC) +
+ (bb->cjmp_count+1) * sizeof(JmpData));
+ bbcc->bb = bb;
+ bbcc->tid = CLG_(current_tid);
- new->ret_counter = 0;
- new->skipped = 0;
- new->cost = CLG_(get_costarray)(bb->cost_count);
+ bbcc->ret_counter = 0;
+ bbcc->skipped = 0;
+ bbcc->cost = CLG_(get_costarray)(bb->cost_count);
for(i=0;i<bb->cost_count;i++)
- new->cost[i] = 0;
+ bbcc->cost[i] = 0;
for(i=0; i<=bb->cjmp_count; i++) {
- new->jmp[i].ecounter = 0;
- new->jmp[i].jcc_list = 0;
+ bbcc->jmp[i].ecounter = 0;
+ bbcc->jmp[i].jcc_list = 0;
}
- new->ecounter_sum = 0;
+ bbcc->ecounter_sum = 0;
/* Init pointer caches (LRU) */
- new->lru_next_bbcc = 0;
- new->lru_from_jcc = 0;
- new->lru_to_jcc = 0;
+ bbcc->lru_next_bbcc = 0;
+ bbcc->lru_from_jcc = 0;
+ bbcc->lru_to_jcc = 0;
CLG_(stat).distinct_bbccs++;
CLG_DEBUG(3, " new_bbcc(BB %#lx): %p (now %d)\n",
- bb_addr(bb), new, CLG_(stat).distinct_bbccs);
+ bb_addr(bb), bbcc, CLG_(stat).distinct_bbccs);
- return new;
+ return bbcc;
}
@@ -369,12 +369,12 @@
*/
static BBCC* clone_bbcc(BBCC* orig, Context* cxt, Int rec_index)
{
- BBCC* new;
+ BBCC* bbcc;
CLG_DEBUG(3,"+ clone_bbcc(BB %#lx, rec %d, fn %s)\n",
bb_addr(orig->bb), rec_index, cxt->fn[0]->name);
- new = new_bbcc(orig->bb);
+ bbcc = new_bbcc(orig->bb);
if (rec_index == 0) {
@@ -382,12 +382,12 @@
CLG_ASSERT((orig->tid != CLG_(current_tid)) ||
(orig->cxt != cxt));
- new->rec_index = 0;
- new->cxt = cxt;
- new->rec_array = new_recursion(cxt->fn[0]->separate_recursions);
- new->rec_array[0] = new;
+ bbcc->rec_index = 0;
+ bbcc->cxt = cxt;
+ bbcc->rec_array = new_recursion(cxt->fn[0]->separate_recursions);
+ bbcc->rec_array[0] = bbcc;
- insert_bbcc_into_hash(new);
+ insert_bbcc_into_hash(bbcc);
}
else {
if (CLG_(clo).separate_threads)
@@ -399,30 +399,30 @@
CLG_ASSERT(orig->rec_array[rec_index] ==0);
/* new BBCC will only have differing recursion level */
- new->rec_index = rec_index;
- new->cxt = cxt;
- new->rec_array = orig->rec_array;
- new->rec_array[rec_index] = new;
+ bbcc->rec_index = rec_index;
+ bbcc->cxt = cxt;
+ bbcc->rec_array = orig->rec_array;
+ bbcc->rec_array[rec_index] = bbcc;
}
/* update list of BBCCs for same BB */
- new->next_bbcc = orig->bb->bbcc_list;
- orig->bb->bbcc_list = new;
+ bbcc->next_bbcc = orig->bb->bbcc_list;
+ orig->bb->bbcc_list = bbcc;
CLG_DEBUGIF(3)
- CLG_(print_bbcc)(-2, new);
+ CLG_(print_bbcc)(-2, bbcc);
CLG_DEBUG(2,"- clone_BBCC(%p, %d) for BB %#lx\n"
" orig %s\n"
" new %s\n",
orig, rec_index, bb_addr(orig->bb),
mangled_cxt(orig->cxt, orig->rec_index),
- mangled_cxt(new->cxt, new->rec_index));
+ mangled_cxt(bbcc->cxt, bbcc->rec_index));
CLG_(stat).bbcc_clones++;
- return new;
+ return bbcc;
};
diff --git a/callgrind/clo.c b/callgrind/clo.c
index b532483..881f3ea 100644
--- a/callgrind/clo.c
+++ b/callgrind/clo.c
@@ -98,24 +98,24 @@
static __inline__
fn_config* new_fnc(void)
{
- fn_config* new = (fn_config*) CLG_MALLOC("cl.clo.nf.1",
+ fn_config* fnc = (fn_config*) CLG_MALLOC("cl.clo.nf.1",
sizeof(fn_config));
- new->dump_before = CONFIG_DEFAULT;
- new->dump_after = CONFIG_DEFAULT;
- new->zero_before = CONFIG_DEFAULT;
- new->toggle_collect = CONFIG_DEFAULT;
- new->skip = CONFIG_DEFAULT;
- new->pop_on_jump = CONFIG_DEFAULT;
- new->group = CONFIG_DEFAULT;
- new->separate_callers = CONFIG_DEFAULT;
- new->separate_recursions = CONFIG_DEFAULT;
+ fnc->dump_before = CONFIG_DEFAULT;
+ fnc->dump_after = CONFIG_DEFAULT;
+ fnc->zero_before = CONFIG_DEFAULT;
+ fnc->toggle_collect = CONFIG_DEFAULT;
+ fnc->skip = CONFIG_DEFAULT;
+ fnc->pop_on_jump = CONFIG_DEFAULT;
+ fnc->group = CONFIG_DEFAULT;
+ fnc->separate_callers = CONFIG_DEFAULT;
+ fnc->separate_recursions = CONFIG_DEFAULT;
#if CLG_ENABLE_DEBUG
- new->verbosity = CONFIG_DEFAULT;
+ fnc->verbosity = CONFIG_DEFAULT;
#endif
- return new;
+ return fnc;
}
diff --git a/callgrind/context.c b/callgrind/context.c
index 3e326cb..9abe6d1 100644
--- a/callgrind/context.c
+++ b/callgrind/context.c
@@ -174,7 +174,7 @@
*/
static Context* new_cxt(fn_node** fn)
{
- Context* new;
+ Context* cxt;
UInt idx, offset;
UWord hash;
int size, recs;
@@ -193,7 +193,7 @@
if (10 * cxts.entries / cxts.size > 8)
resize_cxt_table();
- new = (Context*) CLG_MALLOC("cl.context.nc.1",
+ cxt = (Context*) CLG_MALLOC("cl.context.nc.1",
sizeof(Context)+sizeof(fn_node*)*size);
// hash value calculation similar to cxt_hash_val(), but additionally
@@ -202,33 +202,33 @@
offset = 0;
while(*fn != 0) {
hash = (hash<<7) + (hash>>25) + (UWord)(*fn);
- new->fn[offset] = *fn;
+ cxt->fn[offset] = *fn;
offset++;
fn--;
if (offset >= size) break;
}
if (offset < size) size = offset;
- new->size = size;
- new->base_number = CLG_(stat).context_counter;
- new->hash = hash;
+ cxt->size = size;
+ cxt->base_number = CLG_(stat).context_counter;
+ cxt->hash = hash;
CLG_(stat).context_counter += recs;
CLG_(stat).distinct_contexts++;
/* insert into Context hash table */
idx = (UInt) (hash % cxts.size);
- new->next = cxts.table[idx];
- cxts.table[idx] = new;
+ cxt->next = cxts.table[idx];
+ cxts.table[idx] = cxt;
#if CLG_ENABLE_DEBUG
CLG_DEBUGIF(3) {
- VG_(printf)(" new_cxt ox%p: ", new);
- CLG_(print_cxt)(12, new, 0);
+ VG_(printf)(" new_cxt ox%p: ", cxt);
+ CLG_(print_cxt)(12, cxt, 0);
}
#endif
- return new;
+ return cxt;
}
/* get the Context structure for current context */
@@ -302,14 +302,14 @@
fn_entries = CLG_(current_fn_stack).top - CLG_(current_fn_stack).bottom;
if (fn_entries == CLG_(current_fn_stack).size-1) {
int new_size = CLG_(current_fn_stack).size *2;
- fn_node** new = (fn_node**) CLG_MALLOC("cl.context.pc.1",
- new_size * sizeof(fn_node*));
+ fn_node** new_array = (fn_node**) CLG_MALLOC("cl.context.pc.1",
+ new_size * sizeof(fn_node*));
int i;
for(i=0;i<CLG_(current_fn_stack).size;i++)
- new[i] = CLG_(current_fn_stack).bottom[i];
+ new_array[i] = CLG_(current_fn_stack).bottom[i];
VG_(free)(CLG_(current_fn_stack).bottom);
- CLG_(current_fn_stack).top = new + fn_entries;
- CLG_(current_fn_stack).bottom = new;
+ CLG_(current_fn_stack).top = new_array + fn_entries;
+ CLG_(current_fn_stack).bottom = new_array;
CLG_DEBUG(0, "Resize Context Stack: %d => %d (pushing '%s')\n",
CLG_(current_fn_stack).size, new_size,
diff --git a/callgrind/events.c b/callgrind/events.c
index ccf21a8..e0595c2 100644
--- a/callgrind/events.c
+++ b/callgrind/events.c
@@ -401,16 +401,16 @@
/* Adds difference of new and old to dst, and set old to new.
* Returns false if nothing changed */
-Bool CLG_(add_diff_cost)(EventSet* es, ULong* dst, ULong* old, ULong* new)
+Bool CLG_(add_diff_cost)(EventSet* es, ULong* dst, ULong* old, ULong* new_cost)
{
Int i = 0, j = 0;
while(i<es->size) {
- if (new[i] == old[i])
+ if (new_cost[i] == old[i])
i = es->e[i].nextTop;
else {
- dst[i] += new[i] - old[i];
- old[i] = new[i];
+ dst[i] += new_cost[i] - old[i];
+ old[i] = new_cost[i];
i++;
j++;
}
@@ -422,18 +422,18 @@
/* Adds difference of new and old to dst, and set old to new.
* Returns false if nothing changed */
Bool CLG_(add_diff_cost_lz)(EventSet* es, ULong** pdst,
- ULong* old, ULong* new)
+ ULong* old, ULong* new_cost)
{
Int i;
ULong* dst;
- if (!old && !new) return False;
- CLG_ASSERT(old && new);
+ if (!old && !new_cost) return False;
+ CLG_ASSERT(old && new_cost);
i = 0;
while(1) {
if (i >= es->size) return False;
- if (old[i] != new[i]) break;
+ if (old[i] != new_cost[i]) break;
i = es->e[i].nextTop;
}
@@ -444,16 +444,16 @@
CLG_(zero_cost)(es,dst);
}
- dst[i] += new[i] - old[i];
- old[i] = new[i];
+ dst[i] += new_cost[i] - old[i];
+ old[i] = new_cost[i];
i++;
while(i<es->size) {
- if (new[i] == old[i])
+ if (new_cost[i] == old[i])
i = es->e[i].nextTop;
else {
- dst[i] += new[i] - old[i];
- old[i] = new[i];
+ dst[i] += new_cost[i] - old[i];
+ old[i] = new_cost[i];
i++;
}
}
diff --git a/callgrind/events.h b/callgrind/events.h
index d2cad1e..c3ddbe3 100644
--- a/callgrind/events.h
+++ b/callgrind/events.h
@@ -97,8 +97,8 @@
Bool CLG_(add_and_zero_cost_lz)(EventSet*,ULong** pdst, ULong* src);
/* Adds difference of new and old to to dst, and set old to new.
* Returns false if nothing changed */
-Bool CLG_(add_diff_cost)(EventSet*,ULong* dst, ULong* old, ULong* new);
-Bool CLG_(add_diff_cost_lz)(EventSet*,ULong** pdst, ULong* old, ULong* new);
+Bool CLG_(add_diff_cost)(EventSet*,ULong* dst, ULong* old, ULong* new_cost);
+Bool CLG_(add_diff_cost_lz)(EventSet*,ULong** pdst, ULong* old, ULong* new_cost);
/* Returns number of characters written */
Int CLG_(sprint_cost)(Char* buf, EventSet*, ULong*);
diff --git a/callgrind/fn.c b/callgrind/fn.c
index 79ae029..58a69c8 100644
--- a/callgrind/fn.c
+++ b/callgrind/fn.c
@@ -227,35 +227,35 @@
obj_node* new_obj_node(DebugInfo* di, obj_node* next)
{
Int i;
- obj_node* new;
+ obj_node* obj;
- new = (obj_node*) CLG_MALLOC("cl.fn.non.1", sizeof(obj_node));
- new->name = di ? VG_(strdup)( "cl.fn.non.2",VG_(seginfo_filename)(di) )
+ obj = (obj_node*) CLG_MALLOC("cl.fn.non.1", sizeof(obj_node));
+ obj->name = di ? VG_(strdup)( "cl.fn.non.2",VG_(seginfo_filename)(di) )
: anonymous_obj;
for (i = 0; i < N_FILE_ENTRIES; i++) {
- new->files[i] = NULL;
+ obj->files[i] = NULL;
}
CLG_(stat).distinct_objs ++;
- new->number = CLG_(stat).distinct_objs;
+ obj->number = CLG_(stat).distinct_objs;
/* JRS 2008 Feb 19: maybe rename .start/.size/.offset to
.text_avma/.text_size/.test_bias to make it clearer what these
fields really mean */
- new->start = di ? VG_(seginfo_get_text_avma)(di) : 0;
- new->size = di ? VG_(seginfo_get_text_size)(di) : 0;
- new->offset = di ? VG_(seginfo_get_text_bias)(di) : 0;
- new->next = next;
+ obj->start = di ? VG_(seginfo_get_text_avma)(di) : 0;
+ obj->size = di ? VG_(seginfo_get_text_size)(di) : 0;
+ obj->offset = di ? VG_(seginfo_get_text_bias)(di) : 0;
+ obj->next = next;
// not only used for debug output (see static.c)
- new->last_slash_pos = 0;
+ obj->last_slash_pos = 0;
i = 0;
- while(new->name[i]) {
- if (new->name[i]=='/') new->last_slash_pos = i+1;
+ while(obj->name[i]) {
+ if (obj->name[i]=='/') obj->last_slash_pos = i+1;
i++;
}
- if (runtime_resolve_addr == 0) search_runtime_resolve(new);
-
- return new;
+ if (runtime_resolve_addr == 0) search_runtime_resolve(obj);
+
+ return obj;
}
obj_node* CLG_(get_obj_node)(DebugInfo* di)
@@ -287,17 +287,17 @@
obj_node* obj, file_node* next)
{
Int i;
- file_node* new = (file_node*) CLG_MALLOC("cl.fn.nfn.1",
+ file_node* file = (file_node*) CLG_MALLOC("cl.fn.nfn.1",
sizeof(file_node));
- new->name = VG_(strdup)("cl.fn.nfn.2", filename);
+ file->name = VG_(strdup)("cl.fn.nfn.2", filename);
for (i = 0; i < N_FN_ENTRIES; i++) {
- new->fns[i] = NULL;
+ file->fns[i] = NULL;
}
CLG_(stat).distinct_files++;
- new->number = CLG_(stat).distinct_files;
- new->obj = obj;
- new->next = next;
- return new;
+ file->number = CLG_(stat).distinct_files;
+ file->obj = obj;
+ file->next = next;
+ return file;
}
@@ -330,39 +330,39 @@
fn_node* new_fn_node(Char fnname[FILENAME_LEN],
file_node* file, fn_node* next)
{
- fn_node* new = (fn_node*) CLG_MALLOC("cl.fn.nfnnd.1",
+ fn_node* fn = (fn_node*) CLG_MALLOC("cl.fn.nfnnd.1",
sizeof(fn_node));
- new->name = VG_(strdup)("cl.fn.nfnnd.2", fnname);
+ fn->name = VG_(strdup)("cl.fn.nfnnd.2", fnname);
CLG_(stat).distinct_fns++;
- new->number = CLG_(stat).distinct_fns;
- new->last_cxt = 0;
- new->pure_cxt = 0;
- new->file = file;
- new->next = next;
+ fn->number = CLG_(stat).distinct_fns;
+ fn->last_cxt = 0;
+ fn->pure_cxt = 0;
+ fn->file = file;
+ fn->next = next;
- new->dump_before = False;
- new->dump_after = False;
- new->zero_before = False;
- new->toggle_collect = False;
- new->skip = False;
- new->pop_on_jump = CLG_(clo).pop_on_jump;
- new->is_malloc = False;
- new->is_realloc = False;
- new->is_free = False;
+ fn->dump_before = False;
+ fn->dump_after = False;
+ fn->zero_before = False;
+ fn->toggle_collect = False;
+ fn->skip = False;
+ fn->pop_on_jump = CLG_(clo).pop_on_jump;
+ fn->is_malloc = False;
+ fn->is_realloc = False;
+ fn->is_free = False;
- new->group = 0;
- new->separate_callers = CLG_(clo).separate_callers;
- new->separate_recursions = CLG_(clo).separate_recursions;
+ fn->group = 0;
+ fn->separate_callers = CLG_(clo).separate_callers;
+ fn->separate_recursions = CLG_(clo).separate_recursions;
#if CLG_ENABLE_DEBUG
- new->verbosity = -1;
+ fn->verbosity = -1;
#endif
if (CLG_(stat).distinct_fns >= current_fn_active.size)
resize_fn_array();
- return new;
+ return fn;
}
@@ -654,7 +654,7 @@
*/
static void resize_fn_array(void)
{
- UInt* new;
+ UInt* new_array;
Int i, newsize;
newsize = current_fn_active.size;
@@ -663,15 +663,15 @@
CLG_DEBUG(0, "Resize fn_active_array: %d => %d\n",
current_fn_active.size, newsize);
- new = (UInt*) CLG_MALLOC("cl.fn.rfa.1", newsize * sizeof(UInt));
+ new_array = (UInt*) CLG_MALLOC("cl.fn.rfa.1", newsize * sizeof(UInt));
for(i=0;i<current_fn_active.size;i++)
- new[i] = current_fn_active.array[i];
+ new_array[i] = current_fn_active.array[i];
while(i<newsize)
- new[i++] = 0;
+ new_array[i++] = 0;
VG_(free)(current_fn_active.array);
current_fn_active.size = newsize;
- current_fn_active.array = new;
+ current_fn_active.array = new_array;
CLG_(stat).fn_array_resizes++;
}
diff --git a/callgrind/jumps.c b/callgrind/jumps.c
index 1caa7cc..668eda8 100644
--- a/callgrind/jumps.c
+++ b/callgrind/jumps.c
@@ -139,7 +139,7 @@
*/
static jCC* new_jcc(BBCC* from, UInt jmp, BBCC* to)
{
- jCC* new;
+ jCC* jcc;
UInt new_idx;
/* check fill degree of jcc hash table and resize if needed (>80%) */
@@ -147,40 +147,40 @@
if (10 * current_jccs.entries / current_jccs.size > 8)
resize_jcc_table();
- new = (jCC*) CLG_MALLOC("cl.jumps.nj.1", sizeof(jCC));
+ jcc = (jCC*) CLG_MALLOC("cl.jumps.nj.1", sizeof(jCC));
- new->from = from;
- new->jmp = jmp;
- new->to = to;
- new->jmpkind = Ijk_Call;
- new->call_counter = 0;
- new->cost = 0;
+ jcc->from = from;
+ jcc->jmp = jmp;
+ jcc->to = to;
+ jcc->jmpkind = Ijk_Call;
+ jcc->call_counter = 0;
+ jcc->cost = 0;
/* insert into JCC chain of calling BBCC.
* This list is only used at dumping time */
if (from) {
- new->next_from = from->jmp[jmp].jcc_list;
- from->jmp[jmp].jcc_list = new;
+ jcc->next_from = from->jmp[jmp].jcc_list;
+ from->jmp[jmp].jcc_list = jcc;
}
else {
- new->next_from = current_jccs.spontaneous;
- current_jccs.spontaneous = new;
+ jcc->next_from = current_jccs.spontaneous;
+ current_jccs.spontaneous = jcc;
}
/* insert into JCC hash table */
new_idx = jcc_hash_idx(from, jmp, to, current_jccs.size);
- new->next_hash = current_jccs.table[new_idx];
- current_jccs.table[new_idx] = new;
+ jcc->next_hash = current_jccs.table[new_idx];
+ current_jccs.table[new_idx] = jcc;
CLG_(stat).distinct_jccs++;
CLG_DEBUGIF(3) {
VG_(printf)(" new_jcc (now %d): %p\n",
- CLG_(stat).distinct_jccs, new);
+ CLG_(stat).distinct_jccs, jcc);
}
- return new;
+ return jcc;
}