#include "std.h"
#include "dumpstat.h"
#include "comm.h"
#include "file.h"
/*
* Write statistics about objects on file.
*/
static int sumSizes PROT((mapping_t *, mapping_node_t *, void *));
static int svalue_size PROT((svalue_t *));
static int sumSizes P3(mapping_t *, m, mapping_node_t *, elt, void *, tp)
{
int *t = (int *)tp;
*t += (svalue_size(&elt->values[0]) + svalue_size(&elt->values[1]));
*t += sizeof(mapping_node_t);
return 0;
}
int depth = 0;
static int svalue_size P1(svalue_t *, v)
{
int i, total;
switch (v->type) {
case T_OBJECT:
case T_REAL:
case T_NUMBER:
return 0;
case T_STRING:
return (int) (strlen(v->u.string) + 1);
case T_ARRAY:
case T_CLASS:
if (++depth > 100)
return 0;
/* first svalue is stored inside the array struct */
total = sizeof(array_t) - sizeof(svalue_t);
for (i = 0; i < v->u.arr->size; i++) {
total += svalue_size(&v->u.arr->item[i]) + sizeof(svalue_t);
}
depth--;
return total;
case T_MAPPING:
if (++depth > 100)
return 0;
total = sizeof(mapping_t);
mapTraverse(v->u.map, sumSizes, &total);
depth--;
return total;
case T_FUNCTION:
{
svalue_t tmp;
tmp.type = T_ARRAY;
tmp.u.arr = v->u.fp->hdr.args;
if (++depth > 100)
return 0;
if (tmp.u.arr)
total = (int)(sizeof(funptr_hdr_t) + svalue_size(&tmp));
else
total = (int)(sizeof(funptr_hdr_t));
switch (v->u.fp->hdr.type) {
case FP_EFUN:
total += sizeof(efun_ptr_t);
break;
case FP_LOCAL | FP_NOT_BINDABLE:
total += sizeof(local_ptr_t);
break;
case FP_SIMUL:
total += sizeof(simul_ptr_t);
break;
case FP_FUNCTIONAL:
case FP_FUNCTIONAL | FP_NOT_BINDABLE:
total += sizeof(functional_t);
break;
}
depth--;
return total;
}
#ifndef NO_BUFFER_TYPE
case T_BUFFER:
/* first byte is stored inside the buffer struct */
return (int) (sizeof(buffer_t) + v->u.buf->size - 1);
#endif
default:
fatal("Illegal type: %d\n", v->type);
}
/* NOTREACHED */
return 0;
}
int data_size P1(object_t *, ob)
{
int total = 0, i;
if (ob->prog) {
for (i = 0; i < (int) ob->prog->num_variables_total; i++) {
depth = 0;
total += svalue_size(&ob->variables[i]) + sizeof(svalue_t);
}
}
return total;
}
void dumpstat P1(char *, tfn)
{
FILE *f;
object_t *ob;
char *fn;
#ifdef F_SET_HIDE
int display_hidden;
#endif
fn = check_valid_path(tfn, current_object, "dumpallobj", 1);
if (!fn) {
error("Invalid path '/%s' for writing.\n", tfn);
return;
}
f = fopen(fn, "w");
if (!f) {
error("Unable to open '/%s' for writing.\n", fn);
return;
}
#ifdef F_SET_HIDE
display_hidden = -1;
#endif
for (ob = obj_list; ob; ob = ob->next_all) {
int tmp;
#ifdef F_SET_HIDE
if (ob->flags & O_HIDDEN) {
if (display_hidden == -1)
display_hidden = valid_hide(current_object);
if (!display_hidden)
continue;
}
#endif
/* FIXME */
if (ob->prog && (ob->prog->ref == 1 || !(ob->flags & O_CLONE)))
tmp = ob->prog->total_size;
else
tmp = 0;
fprintf(f, "%-20s %i ref %2d %s %s (%d) %s\n", ob->name,
tmp + data_size(ob) + sizeof(object_t), ob->ref,
ob->flags & O_HEART_BEAT ? "HB" : " ",
#ifndef NO_ENVIRONMENT
ob->super ? ob->super->name : "--",
#else
"--",
#endif
/* ob->cpu */ 0,
(ob->swap_num >= 0) ? ((ob->flags & O_SWAPPED) ?
"SWAPPED(out)" : "SWAPPED(in)") : "");
}
fclose(f);
}
