* Alex Rønne Petersen (alexrp@xamarin.com)
*
* Copyright 2010 Novell, Inc (http://www.novell.com)
+ * Licensed under the MIT license. See LICENSE file in the project root for full license information.
*/
/*
pstrdup (const char *s)
{
int len = strlen (s) + 1;
- char *p = malloc (len);
+ char *p = (char *)malloc (len);
memcpy (p, s, len);
return p;
}
CounterSection *csection, *s;
CounterList *clist;
- clist = calloc (1, sizeof (CounterList));
+ clist = (CounterList *)calloc (1, sizeof (CounterList));
clist->counter = counter;
for (csection = counters_sections; csection; csection = csection->next) {
}
/* If section does not exist */
- csection = calloc (1, sizeof (CounterSection));
+ csection = (CounterSection *)calloc (1, sizeof (CounterSection));
csection->value = counter->section;
csection->counters = clist;
csection->counters_last = clist;
if (list->counter->index == index)
return;
- counter = calloc (1, sizeof (Counter));
+ counter = (Counter *)calloc (1, sizeof (Counter));
counter->section = section;
counter->name = name;
counter->type = type;
counter->variance = variance;
counter->index = index;
- list = calloc (1, sizeof (CounterList));
+ list = (CounterList *)calloc (1, sizeof (CounterList));
list->counter = counter;
if (!counters) {
CounterSection *csection;
CounterList *clist;
- clist = calloc (1, sizeof (CounterList));
+ clist = (CounterList *)calloc (1, sizeof (CounterList));
clist->counter = counter;
for (ctimestamp = counters_timestamps; ctimestamp; ctimestamp = ctimestamp->next) {
}
/* if timestamp exist and section does not exist */
- csection = calloc (1, sizeof (CounterSection));
+ csection = (CounterSection *)calloc (1, sizeof (CounterSection));
csection->value = counter->section;
csection->counters = clist;
csection->counters_last = clist;
}
/* If timestamp do not exist and section does not exist */
- csection = calloc (1, sizeof (CounterSection));
+ csection = (CounterSection *)calloc (1, sizeof (CounterSection));
csection->value = counter->section;
csection->counters = clist;
csection->counters_last = clist;
- ctimestamp = calloc (1, sizeof (CounterTimestamp));
+ ctimestamp = (CounterTimestamp *)calloc (1, sizeof (CounterTimestamp));
ctimestamp->value = timestamp;
ctimestamp->sections = csection;
ctimestamp->sections_last = csection;
add_image (intptr_t image, char *name)
{
int slot = ((image >> 2) & 0xffff) % SMALL_HASH_SIZE;
- ImageDesc *cd = malloc (sizeof (ImageDesc));
+ ImageDesc *cd = (ImageDesc *)malloc (sizeof (ImageDesc));
cd->image = image;
cd->filename = pstrdup (name);
cd->next = image_hash [slot];
add_assembly (intptr_t assembly, char *name)
{
int slot = ((assembly >> 2) & 0xffff) % SMALL_HASH_SIZE;
- AssemblyDesc *cd = malloc (sizeof (AssemblyDesc));
+ AssemblyDesc *cd = (AssemblyDesc *)malloc (sizeof (AssemblyDesc));
cd->assembly = assembly;
cd->asmname = pstrdup (name);
cd->next = assembly_hash [slot];
cd->name = pstrdup (name);
return cd;
}
- cd = calloc (sizeof (ClassDesc), 1);
+ cd = (ClassDesc *)calloc (sizeof (ClassDesc), 1);
cd->klass = klass;
cd->name = pstrdup (name);
cd->next = class_hash [slot];
cd->name = pstrdup (name);
return cd;
}
- cd = calloc (sizeof (MethodDesc), 1);
+ cd = (MethodDesc *)calloc (sizeof (MethodDesc), 1);
cd->method = method;
cd->name = pstrdup (name);
cd->code = code;
size_stat_samples *= 2;
if (!size_stat_samples)
size_stat_samples = 32;
- stat_samples = realloc (stat_samples, size_stat_samples * sizeof (uintptr_t));
- stat_sample_desc = realloc (stat_sample_desc, size_stat_samples * sizeof (int));
+ stat_samples = (uintptr_t *)realloc (stat_samples, size_stat_samples * sizeof (uintptr_t));
+ stat_sample_desc = (int *)realloc (stat_sample_desc, size_stat_samples * sizeof (int));
}
stat_samples [num_stat_samples] = ip;
stat_sample_desc [num_stat_samples++] = type;
static int
compare_method_samples (const void *a, const void *b)
{
- MethodDesc *const*A = a;
- MethodDesc *const*B = b;
+ MethodDesc *const *A = (MethodDesc *const *)a;
+ MethodDesc *const *B = (MethodDesc *const *)b;
if ((*A)->sample_hits == (*B)->sample_hits)
return 0;
if ((*B)->sample_hits < (*A)->sample_hits)
static int
compare_usymbol_addr (const void *a, const void *b)
{
- UnmanagedSymbol *const*A = a;
- UnmanagedSymbol *const*B = b;
+ UnmanagedSymbol *const *A = (UnmanagedSymbol *const *)a;
+ UnmanagedSymbol *const *B = (UnmanagedSymbol *const *)b;
if ((*B)->addr == (*A)->addr)
return 0;
if ((*B)->addr > (*A)->addr)
static int
compare_usymbol_samples (const void *a, const void *b)
{
- UnmanagedSymbol *const*A = a;
- UnmanagedSymbol *const*B = b;
+ UnmanagedSymbol *const *A = (UnmanagedSymbol *const *)a;
+ UnmanagedSymbol *const *B = (UnmanagedSymbol *const *)b;
if ((*B)->sample_hits == (*A)->sample_hits)
return 0;
if ((*B)->sample_hits < (*A)->sample_hits)
int new_size = usymbols_size * 2;
if (!new_size)
new_size = 16;
- usymbols = realloc (usymbols, sizeof (void*) * new_size);
+ usymbols = (UnmanagedSymbol **)realloc (usymbols, sizeof (void*) * new_size);
usymbols_size = new_size;
}
- sym = calloc (sizeof (UnmanagedSymbol), 1);
+ sym = (UnmanagedSymbol *)calloc (sizeof (UnmanagedSymbol), 1);
sym->addr = addr;
sym->name = name;
sym->size = size;
int new_size = ubinaries_size * 2;
if (!new_size)
new_size = 16;
- ubinaries = realloc (ubinaries, sizeof (void*) * new_size);
+ ubinaries = (UnmanagedSymbol **)realloc (ubinaries, sizeof (void*) * new_size);
ubinaries_size = new_size;
}
- sym = calloc (sizeof (UnmanagedSymbol), 1);
+ sym = (UnmanagedSymbol *)calloc (sizeof (UnmanagedSymbol), 1);
sym->addr = addr;
sym->name = name;
sym->size = size;
msize *= 2;
if (!msize)
msize = 4;
- cachedm = realloc (cachedm, sizeof (void*) * msize);
+ cachedm = (MethodDesc **)realloc (cachedm, sizeof (void*) * msize);
}
cachedm [count++] = m;
}
usize *= 2;
if (!usize)
usize = 4;
- cachedus = realloc (cachedus, sizeof (void*) * usize);
+ cachedus = (UnmanagedSymbol **)realloc (cachedus, sizeof (void*) * usize);
}
cachedus [ucount++] = usym;
}
to->rev_hash_size *= 2;
if (to->rev_hash_size == 0)
to->rev_hash_size = 4;
- n = calloc (sizeof (HeapClassRevRef) * to->rev_hash_size, 1);
+ n = (HeapClassRevRef *)calloc (sizeof (HeapClassRevRef) * to->rev_hash_size, 1);
for (i = 0; i < old_size; ++i) {
if (to->rev_hash [i].klass)
add_rev_class_hashed (n, to->rev_hash_size, to->rev_hash [i].klass, to->rev_hash [i].count);
static HeapShot*
new_heap_shot (uint64_t timestamp)
{
- HeapShot *hs = calloc (sizeof (HeapShot), 1);
+ HeapShot *hs = (HeapShot *)calloc (sizeof (HeapShot), 1);
hs->hash_size = 4;
- hs->class_hash = calloc (sizeof (void*), hs->hash_size);
+ hs->class_hash = (HeapClassDesc **)calloc (sizeof (void*), hs->hash_size);
hs->timestamp = timestamp;
num_heap_shots++;
hs->next = heap_shots;
hash [i] = *retv;
return 1;
}
- hash [i] = calloc (sizeof (HeapClassDesc), 1);
+ hash [i] = (HeapClassDesc *)calloc (sizeof (HeapClassDesc), 1);
hash [i]->klass = klass;
hash [i]->total_size += size;
hash [i]->count += count;
hs->hash_size *= 2;
if (hs->hash_size == 0)
hs->hash_size = 4;
- n = calloc (sizeof (void*) * hs->hash_size, 1);
+ n = (HeapClassDesc **)calloc (sizeof (void*) * hs->hash_size, 1);
for (i = 0; i < old_size; ++i) {
res = hs->class_hash [i];
if (hs->class_hash [i])
static HeapObjectDesc*
alloc_heap_obj (uintptr_t objaddr, HeapClassDesc *hklass, uintptr_t num_refs)
{
- HeapObjectDesc* ho = calloc (sizeof (HeapObjectDesc) + num_refs * sizeof (uintptr_t), 1);
+ HeapObjectDesc* ho = (HeapObjectDesc *)calloc (sizeof (HeapObjectDesc) + num_refs * sizeof (uintptr_t), 1);
ho->objaddr = objaddr;
ho->hklass = hklass;
ho->num_refs = num_refs;
hs->objects_hash_size *= 2;
if (hs->objects_hash_size == 0)
hs->objects_hash_size = 4;
- n = calloc (sizeof (void*) * hs->objects_hash_size, 1);
+ n = (HeapObjectDesc **)calloc (sizeof (void*) * hs->objects_hash_size, 1);
for (i = 0; i < old_size; ++i) {
if (hs->objects_hash [i])
add_heap_hashed_obj (n, hs->objects_hash_size, hs->objects_hash [i]);
if (!debug)
return;
/* consistency checks: it seems not all the objects are walked in the heap in some cases */
- marks = calloc (hs->objects_hash_size, 1);
+ marks = (unsigned char *)calloc (hs->objects_hash_size, 1);
if (!marks)
return;
for (i = 0; i < hs->num_roots; ++i) {
return bt;
bt = bt->next;
}
- bt = malloc (sizeof (BackTrace) + ((count - 1) * sizeof (void*)));
+ bt = (BackTrace *)malloc (sizeof (BackTrace) + ((count - 1) * sizeof (void*)));
bt->next = backtrace_hash [slot];
backtrace_hash [slot] = bt;
if (next_backtrace == num_backtraces) {
num_backtraces *= 2;
if (!num_backtraces)
num_backtraces = 16;
- backtraces = realloc (backtraces, sizeof (void*) * num_backtraces);
+ backtraces = (BackTrace **)realloc (backtraces, sizeof (void*) * num_backtraces);
}
bt->id = next_backtrace++;
backtraces [bt->id] = bt;
ensure_buffer (ProfContext *ctx, int size)
{
if (ctx->size < size) {
- ctx->buf = realloc (ctx->buf, size);
+ ctx->buf = (unsigned char *)realloc (ctx->buf, size);
ctx->size = size;
}
}
}
thread = thread->next;
}
- thread = calloc (sizeof (ThreadContext), 1);
+ thread = (ThreadContext *)calloc (sizeof (ThreadContext), 1);
thread->next = ctx->threads;
ctx->threads = thread;
thread->thread_id = thread_id;
thread->last_time = 0;
thread->stack_id = 0;
thread->stack_size = 32;
- thread->stack = malloc (thread->stack_size * sizeof (void*));
- thread->time_stack = malloc (thread->stack_size * sizeof (uint64_t));
- thread->callee_time_stack = malloc (thread->stack_size * sizeof (uint64_t));
+ thread->stack = (MethodDesc **)malloc (thread->stack_size * sizeof (void*));
+ thread->time_stack = (uint64_t *)malloc (thread->stack_size * sizeof (uint64_t));
+ thread->callee_time_stack = (uint64_t *)malloc (thread->stack_size * sizeof (uint64_t));
return thread;
}
domain = domain->next;
}
- domain = calloc (sizeof (DomainContext), 1);
+ domain = (DomainContext *)calloc (sizeof (DomainContext), 1);
domain->next = ctx->domains;
ctx->domains = domain;
domain->domain_id = domain_id;
remctx = remctx->next;
}
- remctx = calloc (sizeof (RemCtxContext), 1);
+ remctx = (RemCtxContext *)calloc (sizeof (RemCtxContext), 1);
remctx->next = ctx->remctxs;
ctx->remctxs = remctx;
remctx->remctx_id = remctx_id;
{
if (thread->stack_id == thread->stack_size) {
thread->stack_size *= 2;
- thread->stack = realloc (thread->stack, thread->stack_size * sizeof (void*));
- thread->time_stack = realloc (thread->time_stack, thread->stack_size * sizeof (uint64_t));
- thread->callee_time_stack = realloc (thread->callee_time_stack, thread->stack_size * sizeof (uint64_t));
+ thread->stack = (MethodDesc **)realloc (thread->stack, thread->stack_size * sizeof (void*));
+ thread->time_stack = (uint64_t *)realloc (thread->time_stack, thread->stack_size * sizeof (uint64_t));
+ thread->callee_time_stack = (uint64_t *)realloc (thread->callee_time_stack, thread->stack_size * sizeof (uint64_t));
}
}
trace->size *= 2;
if (trace->size == 0)
trace->size = 4;
- n = calloc (sizeof (CallContext) * trace->size, 1);
+ n = (CallContext *)calloc (sizeof (CallContext) * trace->size, 1);
for (i = 0; i < old_size; ++i) {
if (trace->traces [i].bt)
add_trace_hashed (n, trace->size, trace->traces [i].bt, trace->traces [i].count);
int new_size = ctx->size_roots * 2;
if (!new_size)
new_size = 4;
- ctx->roots = realloc (ctx->roots, new_size * sizeof (uintptr_t));
- ctx->roots_extra = realloc (ctx->roots_extra, new_size * sizeof (uintptr_t));
- ctx->roots_types = realloc (ctx->roots_types, new_size * sizeof (int));
+ ctx->roots = (uintptr_t *)realloc (ctx->roots, new_size * sizeof (uintptr_t));
+ ctx->roots_extra = (uintptr_t *)realloc (ctx->roots_extra, new_size * sizeof (uintptr_t));
+ ctx->roots_types = (int *)realloc (ctx->roots_types, new_size * sizeof (int));
ctx->size_roots = new_size;
}
ctx->roots_types [ctx->num_roots] = root_type;
static int
compare_callc (const void *a, const void *b)
{
- const CallContext *A = a;
- const CallContext *B = b;
+ const CallContext *A = (const CallContext *)a;
+ const CallContext *B = (const CallContext *)b;
if (B->count == A->count)
return 0;
if (B->count < A->count)
while (cd && cd->objid != objid)
cd = cd->next;
if (!cd) {
- cd = calloc (sizeof (MonitorDesc), 1);
+ cd = (MonitorDesc *)calloc (sizeof (MonitorDesc), 1);
cd->objid = objid;
cd->next = monitor_hash [slot];
monitor_hash [slot] = cd;
if (flags != 0)
return NULL;
if (count > *size)
- frames = malloc (count * sizeof (void*));
+ frames = (MethodDesc **)malloc (count * sizeof (void*));
else
frames = sframes;
for (i = 0; i < count; ++i) {
found_object (uintptr_t obj)
{
num_tracked_objects ++;
- tracked_objects = realloc (tracked_objects, num_tracked_objects * sizeof (tracked_objects [0]));
+ tracked_objects = (uintptr_t *)realloc (tracked_objects, num_tracked_objects * sizeof (tracked_objects [0]));
tracked_objects [num_tracked_objects - 1] = obj;
}
gather_coverage_statements (void)
{
for (guint i = 0; i < coverage_statements->len; i++) {
- CoverageCoverage *coverage = coverage_statements->pdata[i];
- CoverageMethod *method = g_hash_table_lookup (coverage_methods_hash, GINT_TO_POINTER (coverage->method_id));
+ CoverageCoverage *coverage = (CoverageCoverage *)coverage_statements->pdata[i];
+ CoverageMethod *method = (CoverageMethod *)g_hash_table_lookup (coverage_methods_hash, GINT_TO_POINTER (coverage->method_id));
if (method == NULL) {
fprintf (outfile, "Cannot find method with ID: %d\n", coverage->method_id);
continue;
}
g_ptr_array_add (coverage_classes, klass);
- classes = g_hash_table_lookup (coverage_assembly_classes, klass->assembly_name);
+ classes = (GPtrArray *)g_hash_table_lookup (coverage_assembly_classes, klass->assembly_name);
if (classes == NULL) {
classes = g_ptr_array_new ();
g_hash_table_insert (coverage_assembly_classes, klass->assembly_name, classes);
int codelen = decode_uleb128 (p, &p);
const char *name;
if (type == MONO_PROFILER_CODE_BUFFER_SPECIFIC_TRAMPOLINE) {
- name = (void*)p;
+ name = (const char *)p;
while (*p) p++;
p++;
} else {
type = decode_uleb128 (p, &p);
- value = calloc (1, sizeof (CounterValue));
+ value = (CounterValue *)calloc (1, sizeof (CounterValue));
value->timestamp = timestamp;
switch (type) {
#if SIZEOF_VOID_P == 4
case MONO_COUNTER_WORD:
#endif
- value->buffer = malloc (sizeof (int32_t));
+ value->buffer = (unsigned char *)malloc (sizeof (int32_t));
*(int32_t*)value->buffer = (int32_t)decode_sleb128 (p, &p) + (previous ? (*(int32_t*)previous->buffer) : 0);
break;
case MONO_COUNTER_UINT:
- value->buffer = malloc (sizeof (uint32_t));
+ value->buffer = (unsigned char *)malloc (sizeof (uint32_t));
*(uint32_t*)value->buffer = (uint32_t)decode_uleb128 (p, &p) + (previous ? (*(uint32_t*)previous->buffer) : 0);
break;
case MONO_COUNTER_LONG:
case MONO_COUNTER_WORD:
#endif
case MONO_COUNTER_TIME_INTERVAL:
- value->buffer = malloc (sizeof (int64_t));
+ value->buffer = (unsigned char *)malloc (sizeof (int64_t));
*(int64_t*)value->buffer = (int64_t)decode_sleb128 (p, &p) + (previous ? (*(int64_t*)previous->buffer) : 0);
break;
case MONO_COUNTER_ULONG:
- value->buffer = malloc (sizeof (uint64_t));
+ value->buffer = (unsigned char *)malloc (sizeof (uint64_t));
*(uint64_t*)value->buffer = (uint64_t)decode_uleb128 (p, &p) + (previous ? (*(uint64_t*)previous->buffer) : 0);
break;
case MONO_COUNTER_DOUBLE:
- value->buffer = malloc (sizeof (double));
+ value->buffer = (unsigned char *)malloc (sizeof (double));
#if TARGET_BYTE_ORDER == G_LITTLE_ENDIAN
for (i = 0; i < sizeof (double); i++)
#else
int token, n_offsets, method_id;
p++;
- assembly = (void *)p; while (*p) p++; p++;
- klass = (void *)p; while (*p) p++; p++;
- name = (void *)p; while (*p) p++; p++;
- sig = (void *)p; while (*p) p++; p++;
- filename = (void *)p; while (*p) p++; p++;
+ assembly = (const char *)p; while (*p) p++; p++;
+ klass = (const char *)p; while (*p) p++; p++;
+ name = (const char *)p; while (*p) p++; p++;
+ sig = (const char *)p; while (*p) p++; p++;
+ filename = (const char *)p; while (*p) p++; p++;
token = decode_uleb128 (p, &p);
method_id = decode_uleb128 (p, &p);
int number_of_methods, fully_covered, partially_covered;
p++;
- name = (void *)p; while (*p) p++; p++;
- guid = (void *)p; while (*p) p++; p++;
- filename = (void *)p; while (*p) p++; p++;
+ name = (char *)p; while (*p) p++; p++;
+ guid = (char *)p; while (*p) p++; p++;
+ filename = (char *)p; while (*p) p++; p++;
number_of_methods = decode_uleb128 (p, &p);
fully_covered = decode_uleb128 (p, &p);
partially_covered = decode_uleb128 (p, &p);
int number_of_methods, fully_covered, partially_covered;
p++;
- assembly_name = (void *)p; while (*p) p++; p++;
- class_name = (void *)p; while (*p) p++; p++;
+ assembly_name = (char *)p; while (*p) p++; p++;
+ class_name = (char *)p; while (*p) p++; p++;
number_of_methods = decode_uleb128 (p, &p);
fully_covered = decode_uleb128 (p, &p);
partially_covered = decode_uleb128 (p, &p);
load_file (char *name)
{
unsigned char *p;
- ProfContext *ctx = calloc (sizeof (ProfContext), 1);
+ ProfContext *ctx = (ProfContext *)calloc (sizeof (ProfContext), 1);
if (strcmp (name, "-") == 0)
ctx->file = stdin;
else
static int
compare_class (const void *a, const void *b)
{
- ClassDesc *const*A = a;
- ClassDesc *const*B = b;
+ ClassDesc *const *A = (ClassDesc *const *)a;
+ ClassDesc *const *B = (ClassDesc *const *)b;
uint64_t vala, valb;
if (alloc_sort_mode == ALLOC_SORT_BYTES) {
vala = (*A)->alloc_size;
static int
compare_monitor (const void *a, const void *b)
{
- MonitorDesc *const*A = a;
- MonitorDesc *const*B = b;
+ MonitorDesc *const *A = (MonitorDesc *const *)a;
+ MonitorDesc *const *B = (MonitorDesc *const *)b;
if ((*B)->wait_time == (*A)->wait_time)
return 0;
if ((*B)->wait_time < (*A)->wait_time)
int i, j;
if (!num_monitors)
return;
- monitors = malloc (sizeof (void*) * num_monitors);
+ monitors = (MonitorDesc **)malloc (sizeof (void*) * num_monitors);
for (i = 0, j = 0; i < SMALL_HASH_SIZE; ++i) {
MonitorDesc *mdesc = monitor_hash [i];
while (mdesc) {
intptr_t allocs = 0;
uint64_t size = 0;
int header_done = 0;
- ClassDesc **classes = malloc (num_classes * sizeof (void*));
+ ClassDesc **classes = (ClassDesc **)malloc (num_classes * sizeof (void*));
ClassDesc *cd;
c = 0;
for (i = 0; i < HASH_SIZE; ++i) {
static int
compare_method (const void *a, const void *b)
{
- MethodDesc *const*A = a;
- MethodDesc *const*B = b;
+ MethodDesc *const *A = (MethodDesc *const *)a;
+ MethodDesc *const *B = (MethodDesc *const *)b;
uint64_t vala, valb;
if (method_sort_mode == METHOD_SORT_SELF) {
vala = (*A)->self_time;
int i, c;
uint64_t calls = 0;
int header_done = 0;
- MethodDesc **methods = malloc (num_methods * sizeof (void*));
+ MethodDesc **methods = (MethodDesc **)malloc (num_methods * sizeof (void*));
MethodDesc *cd;
c = 0;
for (i = 0; i < HASH_SIZE; ++i) {
static int
compare_heap_class (const void *a, const void *b)
{
- HeapClassDesc *const*A = a;
- HeapClassDesc *const*B = b;
+ HeapClassDesc *const *A = (HeapClassDesc *const *)a;
+ HeapClassDesc *const *B = (HeapClassDesc *const *)b;
uint64_t vala, valb;
if (alloc_sort_mode == ALLOC_SORT_BYTES) {
vala = (*A)->total_size;
static int
compare_rev_class (const void *a, const void *b)
{
- const HeapClassRevRef *A = a;
- const HeapClassRevRef *B = b;
+ const HeapClassRevRef *A = (const HeapClassRevRef *)a;
+ const HeapClassRevRef *B = (const HeapClassRevRef *)b;
if (B->count == A->count)
return 0;
if (B->count < A->count)
int i;
HeapClassDesc *cd;
HeapClassDesc **sorted;
- sorted = malloc (sizeof (void*) * hs->class_count);
+ sorted = (HeapClassDesc **)malloc (sizeof (void*) * hs->class_count);
for (i = 0; i < hs->hash_size; ++i) {
cd = hs->class_hash [i];
if (!cd)
}
if (!collect_traces)
continue;
- rev_sorted = malloc (cd->rev_count * sizeof (HeapClassRevRef));
+ rev_sorted = (HeapClassRevRef *)malloc (cd->rev_count * sizeof (HeapClassRevRef));
k = 0;
for (j = 0; j < cd->rev_hash_size; ++j) {
if (cd->rev_hash [j].klass)
static int
compare_heap_shots (const void *a, const void *b)
{
- HeapShot *const*A = a;
- HeapShot *const*B = b;
+ HeapShot *const *A = (HeapShot *const *)a;
+ HeapShot *const *B = (HeapShot *const *)b;
if ((*B)->timestamp == (*A)->timestamp)
return 0;
if ((*B)->timestamp > (*A)->timestamp)
int i;
if (!heap_shots)
return;
- hs_sorted = malloc (num_heap_shots * sizeof (void*));
+ hs_sorted = (HeapShot **)malloc (num_heap_shots * sizeof (void*));
fprintf (outfile, "\nHeap shot summary\n");
i = 0;
for (hs = heap_shots; hs; hs = hs->next)
g_ptr_array_sort (coverage_assemblies, sort_assemblies);
for (guint i = 0; i < coverage_assemblies->len; i++) {
- CoverageAssembly *assembly = coverage_assemblies->pdata[i];
+ CoverageAssembly *assembly = (CoverageAssembly *)coverage_assemblies->pdata[i];
GPtrArray *classes;
if (assembly->number_of_methods != 0) {
g_free (escaped_filename);
}
- classes = g_hash_table_lookup (coverage_assembly_classes, assembly->name);
+ classes = (GPtrArray *)g_hash_table_lookup (coverage_assembly_classes, assembly->name);
if (classes) {
for (guint j = 0; j < classes->len; j++) {
- CoverageClass *klass = classes->pdata[j];
+ CoverageClass *klass = (CoverageClass *)classes->pdata [j];
if (klass->number_of_methods > 0) {
int percentage = ((klass->fully_covered + klass->partially_covered) * 100) / klass->number_of_methods;
}
for (guint i = 0; i < coverage_methods->len; i++) {
- CoverageMethod *method = coverage_methods->pdata[i];
+ CoverageMethod *method = (CoverageMethod *)coverage_methods->pdata [i];
if (coverage_outfile) {
char *escaped_assembly, *escaped_class, *escaped_method, *escaped_sig, *escaped_filename;
g_free (escaped_filename);
for (guint j = 0; j < method->coverage->len; j++) {
- CoverageCoverage *coverage = method->coverage->pdata[j];
+ CoverageCoverage *coverage = (CoverageCoverage *)method->coverage->pdata [j];
fprintf (coverage_outfile, "\t\t<statement offset=\"%d\" counter=\"%d\" line=\"%d\" column=\"%d\"/>\n", coverage->offset, coverage->count, coverage->line, coverage->column);
}
fprintf (coverage_outfile, "\t</method>\n");