272 lines
7.8 KiB
C
272 lines
7.8 KiB
C
#ifdef LATTICE
|
|
#include "/lpc_incl.h"
|
|
#include "/comm.h"
|
|
#include "/md.h"
|
|
#include "/sprintf.h"
|
|
#else
|
|
#include "../lpc_incl.h"
|
|
#include "../comm.h"
|
|
#include "../md.h"
|
|
#include "../sprintf.h"
|
|
#include "../efun_protos.h"
|
|
#endif
|
|
|
|
static object_t *ob;
|
|
|
|
#ifdef F_DEBUG_INFO
|
|
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");
|
|
|
|
}
|
|
#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);
|
|
}
|
|
#endif
|
|
|
|
#ifdef F_REFS
|
|
void
|
|
f_refs (void)
|
|
{
|
|
int r;
|
|
|
|
switch (sp->type) {
|
|
case T_MAPPING:
|
|
r = sp->u.map->ref;
|
|
break;
|
|
case T_CLASS:
|
|
case T_ARRAY:
|
|
r = sp->u.arr->ref;
|
|
break;
|
|
case T_OBJECT:
|
|
r = sp->u.ob->ref;
|
|
break;
|
|
case T_FUNCTION:
|
|
r = sp->u.fp->hdr.ref;
|
|
break;
|
|
#ifndef NO_BUFFER_TYPE
|
|
case T_BUFFER:
|
|
r = sp->u.buf->ref;
|
|
break;
|
|
#endif
|
|
case T_STRING:
|
|
if(sp->subtype & STRING_COUNTED)
|
|
r = MSTR_REF(sp->u.string);
|
|
else
|
|
r = 0;
|
|
break;
|
|
default:
|
|
r = 0;
|
|
break;
|
|
}
|
|
free_svalue(sp, "f_refs");
|
|
put_number(r - 1); /* minus 1 to compensate for being arg of
|
|
* refs() */
|
|
}
|
|
#endif
|
|
|
|
#ifdef F_DESTRUCTED_OBJECTS
|
|
void f_destructed_objects (void)
|
|
{
|
|
int i;
|
|
array_t *ret;
|
|
object_t *ob;
|
|
|
|
ret = allocate_empty_array(tot_dangling_object);
|
|
ob = obj_list_dangling;
|
|
|
|
for (i = 0; i < tot_dangling_object; i++) {
|
|
ret->item[i].type = T_ARRAY;
|
|
ret->item[i].u.arr = allocate_empty_array(2);
|
|
ret->item[i].u.arr->item[0].type = T_STRING;
|
|
ret->item[i].u.arr->item[0].subtype = STRING_SHARED;
|
|
ret->item[i].u.arr->item[0].u.string = make_shared_string(ob->obname);
|
|
ret->item[i].u.arr->item[1].type = T_NUMBER;
|
|
ret->item[i].u.arr->item[1].u.number = ob->ref;
|
|
|
|
ob = ob->next_all;
|
|
}
|
|
|
|
push_refed_array(ret);
|
|
}
|
|
#endif
|
|
|
|
#if (defined(DEBUGMALLOC) && defined(DEBUGMALLOC_EXTENSIONS))
|
|
#ifdef F_DEBUGMALLOC
|
|
void
|
|
f_debugmalloc (void)
|
|
{
|
|
char *res;
|
|
|
|
res = dump_debugmalloc((sp - 1)->u.string, sp->u.number);
|
|
free_string_svalue(--sp);
|
|
sp->subtype = STRING_MALLOC;
|
|
sp->u.string = res;
|
|
}
|
|
#endif
|
|
|
|
#ifdef F_SET_MALLOC_MASK
|
|
void
|
|
f_set_malloc_mask (void)
|
|
{
|
|
set_malloc_mask((sp--)->u.number);
|
|
}
|
|
#endif
|
|
|
|
#ifdef F_CHECK_MEMORY
|
|
void
|
|
f_check_memory (void)
|
|
{
|
|
check_all_blocks((sp--)->u.number);
|
|
}
|
|
#endif
|
|
#endif /* (defined(DEBUGMALLOC) &&
|
|
* defined(DEBUGMALLOC_EXTENSIONS)) */
|
|
|
|
#ifdef F_TRACE
|
|
void
|
|
f_trace (void)
|
|
{
|
|
int ot = -1;
|
|
|
|
if (command_giver && command_giver->interactive) {
|
|
ot = command_giver->interactive->trace_level;
|
|
command_giver->interactive->trace_level = sp->u.number;
|
|
}
|
|
sp->u.number = ot;
|
|
}
|
|
#endif
|
|
|
|
#ifdef F_TRACEPREFIX
|
|
void
|
|
f_traceprefix (void)
|
|
{
|
|
char *old = 0;
|
|
|
|
if (command_giver && command_giver->interactive) {
|
|
old = command_giver->interactive->trace_prefix;
|
|
if (sp->type & T_STRING) {
|
|
const char *p = sp->u.string;
|
|
if (*p == '/') p++;
|
|
|
|
command_giver->interactive->trace_prefix = make_shared_string(p);
|
|
free_string_svalue(sp);
|
|
} else
|
|
command_giver->interactive->trace_prefix = 0;
|
|
}
|
|
if (old) {
|
|
put_malloced_string(add_slash(old));
|
|
free_string(old);
|
|
} else
|
|
*sp = const0;
|
|
}
|
|
#endif
|
|
|