void print_swap_stats(outbuffer_t * out) { int size, cnt, end; sw_block_t *m; outbuf_add(out, "Swap information:\n"); outbuf_add(out, "-------------------------\n"); outbuf_addv(out, "Progs swapped: %10lu\n", num_swapped); outbuf_addv(out, "Linenum bytes: %10lu\n", line_num_bytes_swapped); outbuf_addv(out, "Total bytes swapped: %10lu\n", total_bytes_swapped); if (!swap_file) { outbuf_add(out, "No swap file\n"); return; } size = cnt = 0; for (m = swap_free; m; size += m->length, cnt++, m = m->next); swap_seek(0, 2); #ifdef SWAP_USE_FD end = tell(swap_file) - last_data; #else end = ftell(swap_file) - last_data; #endif if (end) { size += end; cnt++; } outbuf_addv(out, "Freed bytes: %10lu (%d chunks)\n", size, cnt); }
int add_string_status (outbuffer_t * out, int verbose) { #ifdef STRING_STATS if (verbose == 1) { outbuf_add(out, "All strings:\n"); outbuf_add(out, "-------------------------\t Strings Bytes\n"); } if (verbose != -1) outbuf_addv(out, "All strings:\t\t\t%8d %8d + %d overhead\n", num_distinct_strings, bytes_distinct_strings, overhead_bytes); if (verbose == 1) { outbuf_addv(out, "Total asked for\t\t\t%8d %8d\n", allocd_strings, allocd_bytes); outbuf_addv(out, "Space actually required/total string bytes %d%%\n", (bytes_distinct_strings + overhead_bytes) * 100 / allocd_bytes); outbuf_addv(out, "Searches: %d Average search length: %6.3f\n", num_str_searches, (double) search_len / num_str_searches); } return (bytes_distinct_strings + overhead_bytes); #else if (verbose) outbuf_add(out, "<String statistics disabled, no information available>\n"); return 0; #endif }
void stat_living_objects (outbuffer_t * out) { outbuf_add(out, "Hash table of living objects:\n"); outbuf_add(out, "-----------------------------\n"); outbuf_addv(out, "%d living named objects, average search length: %4.2f\n\n", num_living_names, (double) search_length / num_searches); }
int heart_beat_status (outbuffer_t * ob, int verbose) { char buf[20]; if (verbose == 1) { outbuf_add(ob, "Heart beat information:\n"); outbuf_add(ob, "-----------------------\n"); outbuf_addv(ob, "Number of objects with heart beat: %d, starts: %d\n", num_hb_objs, num_hb_calls); /* passing floats to varargs isn't highly portable so let sprintf handle it */ sprintf(buf, "%.2f", perc_hb_probes); outbuf_addv(ob, "Percentage of HB calls completed last time: %s\n", buf); } return (0); } /* heart_beat_status() */
void dump_malloc_data (outbuffer_t * ob) { int net; net = stats.alloc_calls - stats.free_calls; outbuf_add(ob, "using debug malloc:\n\n"); outbuf_addv(ob, "total malloc'd: %10lu\n", total_malloced); outbuf_addv(ob, "high water mark: %10lu\n", hiwater); outbuf_addv(ob, "overhead: %10lu\n", (MD_TABLE_SIZE * sizeof(md_node_t *)) + (net * MD_OVERHEAD)); outbuf_addv(ob, "#alloc calls: %10lu\n", stats.alloc_calls); outbuf_addv(ob, "#free calls: %10lu\n", stats.free_calls); outbuf_addv(ob, "#alloc - #free: %10lu\n", net); outbuf_addv(ob, "#realloc calls: %10lu\n", stats.realloc_calls); }
void f_db_status (void) { int i; outbuffer_t out; outbuf_zero(&out); for (i = 0; i < dbConnAlloc; i++) { if (dbConnList[i].flags & DB_FLAG_EMPTY) { continue; } outbuf_addv(&out, "Handle: %d (%s)\n", i + 1, dbConnList[i].type->name); if (dbConnList[i].type->status != NULL) { dbConnList[i].type->status(&(dbConnList[i].c), &out); } } outbuf_push(&out); }
void f_debug_info (void) { svalue_t *arg; outbuffer_t out; outbuf_zero(&out); arg = sp - 1; switch (arg[0].u.number) { case 0: { int i, flags; object_t *obj2; ob = arg[1].u.ob; flags = ob->flags; outbuf_addv(&out, "O_HEART_BEAT : %s\n", flags & O_HEART_BEAT ? "TRUE" : "FALSE"); #ifndef NO_WIZARDS outbuf_addv(&out, "O_IS_WIZARD : %s\n", flags & O_IS_WIZARD ? "TRUE" : "FALSE"); #endif #ifdef NO_ADD_ACTION outbuf_addv(&out, "O_LISTENER : %s\n", flags & O_LISTENER ? "TRUE" : "FALSE"); #else outbuf_addv(&out, "O_ENABLE_COMMANDS : %s\n", flags & O_ENABLE_COMMANDS ? "TRUE" : "FALSE"); #endif outbuf_addv(&out, "O_CLONE : %s\n", flags & O_CLONE ? "TRUE" : "FALSE"); outbuf_addv(&out, "O_VIRTUAL : %s\n", flags & O_VIRTUAL ? "TRUE" : "FALSE"); outbuf_addv(&out, "O_DESTRUCTED : %s\n", flags & O_DESTRUCTED ? "TRUE" : "FALSE"); outbuf_addv(&out, "O_ONCE_INTERACTIVE: %s\n", flags & O_ONCE_INTERACTIVE ? "TRUE" : "FALSE"); outbuf_addv(&out, "O_RESET_STATE : %s\n", flags & O_RESET_STATE ? "TRUE" : "FALSE"); outbuf_addv(&out, "O_WILL_CLEAN_UP : %s\n", flags & O_WILL_CLEAN_UP ? "TRUE" : "FALSE"); outbuf_addv(&out, "O_WILL_RESET : %s\n", flags & O_WILL_RESET ? "TRUE" : "FALSE"); #ifdef HAVE_ZLIB if (ob->interactive) { outbuf_addv(&out, "O_COMPRESSED : %s\n", ob->interactive->compressed_stream ? "TRUE" : "FALSE"); outbuf_addv(&out, "O_ZMP : %s\n", ob->interactive->iflags & USING_ZMP ? "TRUE" : "FALSE"); outbuf_addv(&out, "O_GMCP : %s\n", ob->interactive->iflags & USING_GMCP ? "TRUE" : "FALSE"); outbuf_addv(&out, "O_MXP : %s\n", ob->interactive->iflags & USING_MXP ? "TRUE" : "FALSE"); } #endif #ifndef NO_LIGHT outbuf_addv(&out, "total light : %d\n", ob->total_light); #endif #ifndef NO_RESETS outbuf_addv(&out, "next_reset : %d\n", ob->next_reset); #endif outbuf_addv(&out, "time_of_ref : %d\n", ob->time_of_ref); outbuf_addv(&out, "ref : %d\n", ob->ref); #ifdef DEBUG outbuf_addv(&out, "extra_ref : %d\n", ob->extra_ref); #endif outbuf_addv(&out, "name : '/%s'\n", ob->obname); outbuf_addv(&out, "next_all : OBJ(/%s)\n", ob->next_all ? ob->next_all->obname : "NULL"); if (obj_list == ob) outbuf_add(&out, "This object is the head of the object list.\n"); for (obj2 = obj_list, i = 1; obj2; obj2 = obj2->next_all, i++) if (obj2->next_all == ob) { outbuf_addv(&out, "Previous object in object list: OBJ(/%s)\n", obj2->obname); outbuf_addv(&out, "position in object list:%d\n", i); } break; } case 1: ob = arg[1].u.ob; outbuf_addv(&out, "program ref's %d\n", ob->prog->ref); outbuf_addv(&out, "Name /%s\n", ob->prog->filename); outbuf_addv(&out, "program size %d\n", ob->prog->program_size); outbuf_addv(&out, "function flags table %d (%d) \n", ob->prog->last_inherited + ob->prog->num_functions_defined, (ob->prog->last_inherited + ob->prog->num_functions_defined)* sizeof(unsigned short)); outbuf_addv(&out, "compiler function table %d (%d) \n", ob->prog->num_functions_defined, ob->prog->num_functions_defined * sizeof(function_t)); outbuf_addv(&out, "num strings %d\n", ob->prog->num_strings); outbuf_addv(&out, "num vars %d (%d)\n", ob->prog->num_variables_defined, ob->prog->num_variables_defined * (sizeof(char *) + sizeof(short))); outbuf_addv(&out, "num inherits %d (%d)\n", ob->prog->num_inherited, ob->prog->num_inherited * sizeof(inherit_t)); outbuf_addv(&out, "total size %d\n", ob->prog->total_size); break; case 2: { int i; ob = arg[1].u.ob; for (i=0; i<ob->prog->num_variables_total; i++) { /* inefficient, but: */ outbuf_addv(&out, "%s: ", variable_name(ob->prog, i)); svalue_to_string(&ob->variables[i], &out, 2, 0, 0); outbuf_add(&out, "\n"); } break; } default: bad_arg(1, F_DEBUG_INFO); } pop_stack(); pop_stack(); outbuf_push(&out); }
void dump_file_descriptors (outbuffer_t * out) { int i; dev_t dev; struct stat stbuf; outbuf_add(out, "Fd Device Number Inode Mode Uid Gid Size\n"); outbuf_add(out, "-- ------------- ----- ------ ----- ----- ----------\n"); for (i = 0; i < FD_SETSIZE; i++) { /* bug in NeXT OS 2.1, st_mode == 0 for sockets */ if (fstat(i, &stbuf) == -1) continue; #if !defined(WIN32) if (S_ISCHR(stbuf.st_mode) || S_ISBLK(stbuf.st_mode)) dev = stbuf.st_rdev; else #endif dev = stbuf.st_dev; outbuf_addv(out, "%2d", i); outbuf_addv(out, "%13x", dev); outbuf_addv(out, "%9d", stbuf.st_ino); outbuf_add(out, " "); switch (stbuf.st_mode & S_IFMT) { case S_IFDIR: outbuf_add(out, "d"); break; case S_IFCHR: outbuf_add(out, "c"); break; #ifdef S_IFBLK case S_IFBLK: outbuf_add(out, "b"); break; #endif case S_IFREG: outbuf_add(out, "f"); break; #ifdef S_IFIFO case S_IFIFO: outbuf_add(out, "p"); break; #endif #ifdef S_IFLNK case S_IFLNK: outbuf_add(out, "l"); break; #endif #ifdef S_IFSOCK case S_IFSOCK: outbuf_add(out, "s"); break; #endif default: outbuf_add(out, "?"); break; } outbuf_addv(out, "%5o", stbuf.st_mode & ~S_IFMT); outbuf_addv(out, "%7d", stbuf.st_uid); outbuf_addv(out, "%7d", stbuf.st_gid); outbuf_addv(out, "%12d", stbuf.st_size); outbuf_add(out, "\n"); } }
/* * Converts any LPC datatype into an arbitrary string format * and returns a pointer to this string. * Scary number of parameters for a recursive function. */ void svalue_to_string (svalue_t * obj, outbuffer_t * outbuf, int indent, int trailing, int indent2) { int i; /* prevent an infinite recursion on self-referential structures */ if (indent > 20) { outbuf_add(outbuf, "..."); return; } if (!indent2) add_space(outbuf, indent); switch ((obj->type & ~T_FREED)) { case T_INVALID: outbuf_add(outbuf, "T_INVALID"); break; case T_LVALUE: outbuf_add(outbuf, "lvalue: "); svalue_to_string(obj->u.lvalue, outbuf, indent + 2, trailing, 0); break; case T_REF: if(!obj->u.ref->lvalue) kill_ref(obj->u.ref); else { outbuf_add(outbuf, "ref: "); svalue_to_string(obj->u.ref->lvalue, outbuf, indent + 2, trailing, 0); } break; case T_NUMBER: numadd(outbuf, obj->u.number); break; case T_REAL: outbuf_addv(outbuf, "%f", obj->u.real); break; case T_STRING: outbuf_add(outbuf, "\""); outbuf_add(outbuf, obj->u.string); outbuf_add(outbuf, "\""); break; case T_CLASS: { int n = obj->u.arr->size; outbuf_add(outbuf, "CLASS( "); numadd(outbuf, n); outbuf_add(outbuf, n == 1 ? " element\n" : " elements\n"); for (i = 0; i < (obj->u.arr->size) - 1; i++) svalue_to_string(&(obj->u.arr->item[i]), outbuf, indent + 2, 1, 0); if(obj->u.arr->size) svalue_to_string(&(obj->u.arr->item[i]), outbuf, indent + 2, 0, 0); outbuf_add(outbuf, "\n"); add_space(outbuf, indent); outbuf_add(outbuf, " )"); break; } case T_ARRAY: if (!(obj->u.arr->size)) { outbuf_add(outbuf, "({ })"); } else { outbuf_add(outbuf, "({ /* sizeof() == "); numadd(outbuf, obj->u.arr->size); outbuf_add(outbuf, " */\n"); for (i = 0; i < (obj->u.arr->size) - 1; i++) svalue_to_string(&(obj->u.arr->item[i]), outbuf, indent + 2, 1, 0); svalue_to_string(&(obj->u.arr->item[i]), outbuf, indent + 2, 0, 0); outbuf_add(outbuf, "\n"); add_space(outbuf, indent); outbuf_add(outbuf, "})"); } break; #ifndef NO_BUFFER_TYPE case T_BUFFER: outbuf_add(outbuf, "<buffer>"); break; #endif case T_FUNCTION: { svalue_t tmp; object_t *ob; tmp.type = T_ARRAY; outbuf_add(outbuf, "(: "); switch (obj->u.fp->hdr.type) { case FP_LOCAL | FP_NOT_BINDABLE: ob = obj->u.fp->hdr.owner; if (!ob || ob->flags & O_DESTRUCTED) { outbuf_add(outbuf, "0"); break; } outbuf_add(outbuf, function_name(ob->prog, obj->u.fp->f.local.index)); break; case FP_SIMUL: outbuf_add(outbuf, simuls[obj->u.fp->f.simul.index].func->funcname); break; case FP_FUNCTIONAL: case FP_FUNCTIONAL | FP_NOT_BINDABLE: { char buf[10]; int n = obj->u.fp->f.functional.num_arg; outbuf_add(outbuf, "<code>("); for (i=1; i < n; i++) { sprintf(buf, "$%i, ", i); outbuf_add(outbuf, buf); } if (n) { sprintf(buf, "$%i", n); outbuf_add(outbuf, buf); } outbuf_add(outbuf, ")"); break; } case FP_EFUN: { int i; i = obj->u.fp->f.efun.index; outbuf_add(outbuf, query_instr_name(i)); break; } } if (obj->u.fp->hdr.args) { for (i=0; i<obj->u.fp->hdr.args->size; i++) { outbuf_add(outbuf, ", "); svalue_to_string(&(obj->u.fp->hdr.args->item[i]), outbuf, indent, 0, 0); } } } outbuf_add(outbuf, " :)"); break; case T_MAPPING: if (!(obj->u.map->count)) { outbuf_add(outbuf, "([ ])"); } else { outbuf_add(outbuf, "([ /* sizeof() == "); numadd(outbuf, obj->u.map->count); outbuf_add(outbuf, " */\n"); for (i = 0; i <= obj->u.map->table_size; i++) { mapping_node_t *elm; for (elm = obj->u.map->table[i]; elm; elm = elm->next) { svalue_to_string(&(elm->values[0]), outbuf, indent + 2, 0, 0); outbuf_add(outbuf, " : "); svalue_to_string(&(elm->values[1]), outbuf, indent + 4, 1, 1); } } add_space(outbuf, indent); outbuf_add(outbuf, "])"); } break; case T_OBJECT: { svalue_t *temp; if (obj->u.ob->flags & O_DESTRUCTED) { numadd(outbuf, 0); break; } outbuf_addchar(outbuf, '/'); outbuf_add(outbuf, obj->u.ob->obname); if (!max_eval_error && !too_deep_error) { push_object(obj->u.ob); temp = safe_apply_master_ob(APPLY_OBJECT_NAME, 1); if (temp && temp != (svalue_t *) -1 && (temp->type == T_STRING)) { outbuf_add(outbuf, " (\""); outbuf_add(outbuf, temp->u.string); outbuf_add(outbuf, "\")"); } } break; } default: outbuf_addv(outbuf, "!ERROR: GARBAGE SVALUE: %x!", obj->type); } /* end of switch (obj->type) */ if (trailing) outbuf_add(outbuf, ",\n"); } /* end of svalue_to_string() */