/** Evaluate a lock.
* Evaluate lock ltype on thing for player, passing dbrefs for %0/%1.
* \param player dbref attempting to pass the lock.
* \param thing object containing the lock.
* \param ltype type of lock to check.
* \retval 1 player passes the lock.
* \retval 0 player does not pass the lock.
*/
int
eval_lock_with(dbref player, dbref thing, lock_type ltype, dbref env0,
dbref env1)
{
char *myenv[10] = { NULL };
char e0[SBUF_LEN], e1[SBUF_LEN], *ep;
char *preserves[10];
int result;
if (env0 != NOTHING) {
ep = e0;
safe_dbref(env0, e0, &ep);
*ep = '\0';
myenv[0] = e0;
}
if (env1 != NOTHING) {
ep = e1;
safe_dbref(env1, e1, &ep);
*ep = '\0';
myenv[1] = e1;
}
save_global_env("eval_lock_save", preserves);
restore_global_env("eval_lock", myenv);
boolexp b = getlock(thing, ltype);
log_activity(LA_LOCK, thing, unparse_boolexp(player, b, UB_DBREF));
result = eval_boolexp(player, b, thing, NULL);
restore_global_env("eval_lock_save", preserves);
return result;
}
void
check_common(dbref obj)
{
printf("\nObject %s\n", unparse_object(me, obj));
printf("Name: %s\n", uncompress(DBFETCH(obj)->name));
if (GETDESC(obj))
printf("Desc: %s\n", uncompress(GETDESC(obj)));
printf("Loc: #%s\n", unparse_object(me, DBFETCH(obj)->location));
printf("Owner: #%d\n", unparse_object(me, DBFETCH(obj)->owner));
printf("First contents: #%d\n", unparse_object(me, DBFETCH(obj)->contents));
printf("Next item: #%d\n", unparse_object(me, DBFETCH(obj)->next));
printf("Key: %s\n", unparse_boolexp(me, GETLOCK(obj)), 1);
if (GETFAIL(obj))
printf("Fail: %s\n", uncompress(GETFAIL(obj)));
if (GETSUCC(obj))
printf("Succ: %s\n", uncompress(GETSUCC(obj)));
if (GETDROP(obj))
printf("Drop: %s\n", uncompress(GETDROP(obj)));
if (GETOFAIL(obj))
printf("Ofail: %s\n", uncompress(GETOFAIL(obj)));
if (GETOSUCC(obj))
printf("Osucc: %s\n", uncompress(GETOSUCC(obj)));
if (GETODROP(obj))
printf("Odrop: %s\n", uncompress(GETODROP(obj)));
printf("Properties:\n");
check_properties("/", obj);
printf("End of properties.\n");
}
/** Evaluate a lock.
* Evaluate lock ltype on thing for player.
* \param player dbref attempting to pass the lock.
* \param thing object containing the lock.
* \param ltype type of lock to check.
* \retval 1 player passes the lock.
* \retval 0 player does not pass the lock.
*/
int
eval_lock(dbref player, dbref thing, lock_type ltype)
{
boolexp b = getlock(thing, ltype);
log_activity(LA_LOCK, thing, unparse_boolexp(player, b, UB_DBREF));
if(Pass_Lock(player, thing) && IS_passlock_type(ltype))
return 1;
return eval_boolexp(player, getlock(thing, ltype), thing, NULL);
}
/** Evaluate a lock.
* Evaluate lock ltype on thing for player.
* \param player dbref attempting to pass the lock.
* \param thing object containing the lock.
* \param ltype type of lock to check.
* \param pe_info the pe_info to use when evaluating softcode in the lock
* \retval 1 player passes the lock.
* \retval 0 player does not pass the lock.
*/
int
eval_lock_with(dbref player, dbref thing, lock_type ltype, NEW_PE_INFO *pe_info)
{
boolexp b = getlock(thing, ltype);
/* Prevent overwriting a static buffer in unparse_boolexp() */
if (!unparsing_boolexp)
log_activity(LA_LOCK, thing, unparse_boolexp(player, b, UB_DBREF));
return eval_boolexp(player, b, thing, pe_info);
}
char *
displayprop(dbref player, dbref obj, const char *name, char *buf)
{
char mybuf[BUFFER_LEN], tbuf[BUFFER_LEN];
int pdflag;
PropPtr p = get_property(obj, name);
if (!p) {
sprintf(buf, SYSGLOOM "%s: No such property.", name);
return buf;
}
#ifdef DISKBASE
propfetch(obj, p);
#endif
pdflag = (PropDir(p) != NULL);
sprintf(tbuf, "%.*s%c", (BUFFER_LEN / 4), name,
(pdflag) ? PROPDIR_DELIMITER : '\0');
tct(tbuf, mybuf);
switch (PropType(p)) {
case PROP_STRTYP:
sprintf(buf, SYSAQUA "str " SYSGREEN "%s" SYSRED ":" SYSCYAN
"%.*s", mybuf, (BUFFER_LEN / 2),
tct(PropDataUNCStr(p), tbuf));
break;
case PROP_REFTYP:
sprintf(buf, SYSBROWN "ref " SYSGREEN "%s" SYSRED ":%s", mybuf,
ansi_unparse_object(player, PropDataRef(p)));
break;
case PROP_INTTYP:
sprintf(buf, SYSFOREST "int " SYSGREEN "%s" SYSRED ":" SYSYELLOW
"%d", mybuf, PropDataVal(p));
break;
case PROP_FLTTYP:
sprintf(buf, SYSNAVY "flt " SYSGREEN "%s" SYSRED ":" SYSBROWN
"%.15g", mybuf, PropDataFVal(p));
break;
case PROP_LOKTYP:
if (PropFlags(p) & PROP_ISUNLOADED) {
sprintf(buf, SYSCRIMSON "lok " SYSGREEN "%s" SYSRED ":"
SYSPURPLE "*UNLOCKED*", mybuf);
} else {
sprintf(buf, SYSCRIMSON "lok " SYSGREEN "%s" SYSRED ":"
SYSPURPLE "%.*s", mybuf, (BUFFER_LEN / 2),
tct(unparse_boolexp(player, PropDataLok(p), 1), tbuf));
}
break;
case PROP_DIRTYP:
sprintf(buf, SYSWHITE "dir " SYSGREEN "%s" SYSRED ":", mybuf);
break;
}
return buf;
}
void
prim_prettylock(PRIM_PROTOTYPE)
{
const char *ptr;
CHECKOP(1);
oper1 = POP(); /* lock: lock */
if (oper1->type != PROG_LOCK)
abort_interp("Invalid argument");
ptr = unparse_boolexp(ProgUID, oper1->data.lock, 1);
CHECKOFLOW(1);
CLEAR(oper1);
PushString(ptr);
}
HS_DBREF CHSInterface::GetLock(int objnum, HS_LOCKTYPE lock)
{
#ifdef PENNMUSH // No change in code between versions
boolexp boolExp = getlock(objnum, Use_Lock);
if (boolExp == TRUE_BOOLEXP)
{
return NOTHING;
}
else
{
return strtodbref(unparse_boolexp(objnum, boolExp, UB_DBREF));
}
#endif
#if defined(TM3) || defined(MUX)
char *value;
BOOLEXP *key;
int aowner, aflags;
dbref lockobj;
#ifdef TM3
int alen;
value = atr_get((dbref) objnum, A_LUSE, &aowner, &aflags, &alen);
#else
value = atr_get((dbref) objnum, A_LUSE, &aowner, &aflags);
#endif
key = parse_boolexp((dbref) objnum, value, 1);
free_lbuf(value);
if (key == TRUE_BOOLEXP)
{
free_boolexp(key);
return NOTHING;
}
else
{
lockobj = key->thing;
free_boolexp(key);
return lockobj;
}
#endif
}
void
prim_unparselock(PRIM_PROTOTYPE)
{
const char *ptr;
CHECKOP(1);
oper1 = POP(); /* lock: lock */
if (oper1->type != PROG_LOCK)
abort_interp("Invalid argument");
if (oper1->data.lock != (struct boolexp *) TRUE_BOOLEXP) {
ptr = unparse_boolexp(ProgUID, oper1->data.lock, 0);
} else {
ptr = NULL;
}
CHECKOFLOW(1);
CLEAR(oper1);
if (ptr) {
PushString(ptr);
} else {
PushNullStr;
}
}
void
disassemble(dbref player, dbref program)
{
struct inst *curr;
struct inst *codestart;
int i;
char buf[BUFFER_LEN];
codestart = curr = DBFETCH(program)->sp.program.code;
if (!DBFETCH(program)->sp.program.siz) {
notify(player, "Nothing to disassemble!");
return;
}
for (i = 0; i < DBFETCH(program)->sp.program.siz; i++, curr++) {
switch (curr->type) {
case PROG_PRIMITIVE:
if (curr->data.number >= BASE_MIN && curr->data.number <= BASE_MAX)
sprintf(buf, "%d: (line %d) PRIMITIVE: %s", i,
curr->line, base_inst[curr->data.number - BASE_MIN]);
else
sprintf(buf, "%d: (line %d) PRIMITIVE: %d", i,
curr->line, curr->data.number);
break;
case PROG_STRING:
sprintf(buf, "%d: (line %d) STRING: \"%s\"", i, curr->line,
curr->data.string ? curr->data.string->data : "");
break;
case PROG_FUNCTION:
sprintf(buf,"%d: (line %d) FUNCTION HEADER: %s",i,curr->line,
curr->data.string ? curr->data.string->data : "");
break;
case PROG_LOCK:
sprintf(buf, "%d: (line %d) LOCK: [%s]", i, curr->line,
curr->data.lock == TRUE_BOOLEXP ? "TRUE_BOOLEXP" :
unparse_boolexp(0, curr->data.lock, 0));
break;
case PROG_INTEGER:
sprintf(buf, "%d: (line %d) INTEGER: %d", i,
curr->line, curr->data.number);
break;
case PROG_FLOAT:
sprintf(buf, "%d: (line %d) FLOAT: %f", i, curr->line,
curr->data.float_n);
break;
case PROG_ADD:
sprintf(buf, "%d: (line %d) ADDRESS: %d", i,
curr->line, (int)(curr->data.addr->data - codestart));
break;
case PROG_IF:
sprintf(buf, "%d: (line %d) IF: %d", i,
curr->line, (int)(curr->data.call - codestart));
break;
case PROG_JMP:
sprintf(buf, "%d: (line %d) JMP: %d", i,
curr->line, (int)(curr->data.call - codestart));
break;
case PROG_EXEC:
sprintf(buf, "%d: (line %d) EXEC: %d", i,
curr->line, (int)(curr->data.call - codestart));
break;
case PROG_OBJECT:
sprintf(buf, "%d: (line %d) OBJECT REF: %d", i,
curr->line, curr->data.number);
break;
case PROG_VAR:
sprintf(buf, "%d: (line %d) VARIABLE: %d", i,
curr->line, curr->data.number);
break;
case PROG_LVAR:
sprintf(buf, "%d: (line %d) LOCALVAR: %d", i,
curr->line, curr->data.number);
}
notify(player, buf);
}
}
/* natural = 1 performs a "natural" numeric sort on strings -Hinoserm */
static int
array_tree_compare(array_iter *a, array_iter *b, int case_sens, int objname, bool natural)
{
char pad_char[] = "";
if (a->type != b->type) {
if (a->type == PROG_INTEGER && b->type == PROG_FLOAT) {
if (fabs
(((double) a->data.number -
b->data.fnumber) / (double) a->data.number) < DBL_EPSILON) {
return 0;
} else if (a->data.number > b->data.fnumber) {
return 1;
} else {
return -1;
}
} else if (a->type == PROG_FLOAT && b->type == PROG_INTEGER) {
if (a->data.fnumber == b->data.fnumber) {
return 0;
} else
if (fabs((a->data.fnumber - b->data.number) / a->data.fnumber) <
DBL_EPSILON) {
return 0;
} else if (a->data.fnumber > b->data.number) {
return 1;
} else {
return -1;
}
} else if (a->type == PROG_OBJECT && b->type == PROG_STRING
&& objname && valid_obj(a->data.objref)) {
char *astr = (char *) NAME(a->data.objref);
char *bstr = (b->data.string) ? b->data.string->data : pad_char;
if (case_sens) {
if (natural)
return strnatcmp(astr, bstr);
else
return strcmp(astr, bstr);
} else {
if (natural)
return strnatcasecmp(astr, bstr);
else
return string_compare(astr, bstr);
}
} else if (a->type == PROG_STRING && b->type == PROG_OBJECT
&& objname && valid_obj(b->data.objref)) {
char *astr = (a->data.string) ? a->data.string->data : pad_char;
char *bstr = (char *) NAME(b->data.objref);
if (case_sens) {
if (natural)
return strnatcmp(astr, bstr);
else
return strcmp(astr, bstr);
} else {
if (natural)
return strnatcasecmp(astr, bstr);
else
return string_compare(astr, bstr);
}
}
return (a->type - b->type);
}
/* Indexes are of same type if we reached here. */
if (a->type == PROG_OBJECT && objname && valid_obj(a->data.objref)
&& valid_obj(b->data.objref)) {
char *astr = (char *) NAME(a->data.objref);
char *bstr = (char *) NAME(b->data.objref);
if (case_sens) {
if (natural)
return strnatcmp(astr, bstr);
else
return strcmp(astr, bstr);
} else {
if (natural)
return strnatcasecmp(astr, bstr);
else
return string_compare(astr, bstr);
}
}
if (a->type == PROG_OBJECT) {
if (a->data.objref > b->data.objref)
return 1;
else if (a->data.objref < b->data.objref)
return -1;
else
return 0;
}
if (a->type == PROG_FLOAT) {
if (a->data.fnumber == b->data.fnumber) {
return 0;
} else
if (fabs((a->data.fnumber - b->data.fnumber) / a->data.fnumber) <
DBL_EPSILON) {
return 0;
} else if (a->data.fnumber > b->data.fnumber) {
return 1;
} else {
return -1;
}
} else if (a->type == PROG_STRING) {
char pad_char[] = "";
char *astr = (a->data.string) ? a->data.string->data : pad_char;
char *bstr = (b->data.string) ? b->data.string->data : pad_char;
if (case_sens) {
if (natural)
return strnatcmp(astr, bstr);
else
return strcmp(astr, bstr);
} else {
if (natural)
return strnatcasecmp(astr, bstr);
else
return string_compare(astr, bstr);
}
} else if (a->type == PROG_ARRAY) {
/* Sort arrays by memory address. */
/* This is a bug, really. */
/* in a perfect world, we'd compare the array elements recursively. */
return (a->data.array - b->data.array);
} else if (a->type == PROG_LOCK) {
/* Sort locks by memory address. */
/* This is a bug, really. */
/* in a perfect world, we'd compare the locks by element. */
char *la;
char *lb;
int retval = 0;
la = (char *) unparse_boolexp((dbref) 1, a->data.lock, 0);
la = string_dup(la);
lb = (char *) unparse_boolexp((dbref) 1, b->data.lock, 0);
retval = strcmp(la, lb);
free(la);
return retval;
} else if (a->type == PROG_ADD) {
int result = (a->data.addr->progref - b->data.addr->progref);
if (result) {
return result;
}
return (a->data.addr->data - b->data.addr->data);
} else {
return (a->data.number - b->data.number);
}
}
void
db_putprop(FILE * f, const char *dir, PropPtr p)
{
char buf[BUFFER_LEN * 2];
char fbuf[BUFFER_LEN];
char num[16];
char *ptr;
const char *ptr2;
if (PropType(p) == PROP_DIRTYP)
return;
for (ptr = buf, ptr2 = dir + 1; *ptr2;)
*ptr++ = *ptr2++;
for (ptr2 = PropName(p); *ptr2;)
*ptr++ = *ptr2++;
*ptr++ = PROP_DELIMITER;
ptr2 =
intostr(num,
PropFlagsRaw(p) & ~(PROP_TOUCHED | PROP_ISUNLOADED |
PROP_NOASCIICHK));
while (*ptr2)
*ptr++ = *ptr2++;
*ptr++ = PROP_DELIMITER;
ptr2 = "";
switch (PropType(p)) {
case PROP_INTTYP:
if (!PropDataVal(p))
return;
ptr2 = intostr(num, PropDataVal(p));
break;
case PROP_FLTTYP:
if (!PropDataFVal(p))
return;
ptr2 = fltostr(fbuf, PropDataFVal(p));
break;
case PROP_REFTYP:
if (PropDataRef(p) == NOTHING)
return;
ptr2 = intostr(num, (int) PropDataRef(p));
break;
case PROP_STRTYP:
if (!*PropDataStr(p))
return;
if (db_decompression_flag) {
ptr2 = PropDataUNCStr(p);
} else {
ptr2 = PropDataStr(p);
}
break;
case PROP_LOKTYP:
if (PropFlags(p) & PROP_ISUNLOADED)
return;
if (PropDataLok(p) == TRUE_BOOLEXP)
return;
ptr2 = unparse_boolexp((dbref) 1, PropDataLok(p), 0);
break;
}
while (*ptr2)
if (*ptr2 != '\n')
*ptr++ = *ptr2++;
else {
*ptr++ = '\\';
*ptr++ = 'n';
ptr2++;
}
*ptr++ = '\n';
*ptr++ = '\0';
if (fputs(buf, f) == EOF) {
fprintf(stderr, "PANIC: Unable to write to db to write prop.\n");
abort();
}
}
void
disassemble(dbref player, dbref program)
{
struct inst *curr;
struct inst *codestart;
int i;
char buf[BUFFER_LEN];
codestart = curr = DBFETCH(program)->sp.program.code;
if (!DBFETCH(program)->sp.program.siz) {
notify(player, "Nothing to disassemble!");
return;
}
for (i = 0; i < DBFETCH(program)->sp.program.siz; i++, curr++) {
switch (curr->type) {
case PROG_PRIMITIVE:
if (curr->data.number >= BASE_MIN
&& curr->data.number <= BASE_MAX)
sprintf(buf, "%d: (line %d) PRIMITIVE: %s", i, curr->line,
base_inst[curr->data.number - BASE_MIN]);
else
sprintf(buf, "%d: (line %d) PRIMITIVE: %d", i, curr->line,
curr->data.number);
break;
case PROG_MARK:
sprintf(buf, "%d: (line %d) MARK", i, curr->line);
break;
case PROG_STRING:
sprintf(buf, "%d: (line %d) STRING: \"%s\"", i, curr->line,
curr->data.string ? curr->data.string->data : "");
break;
case PROG_ARRAY:
sprintf(buf, "%d: (line %d) ARRAY: %d items", i, curr->line,
curr->data.array ? curr->data.array->items : 0);
break;
case PROG_FUNCTION:
sprintf(buf, "%d: (line %d) FUNCTION: %s, VARS: %d, ARGS: %d",
i, curr->line,
curr->data.mufproc->procname ? curr->data.mufproc->
procname : "", curr->data.mufproc->vars,
curr->data.mufproc->args);
break;
case PROG_LOCK:
sprintf(buf, "%d: (line %d) LOCK: [%s]", i, curr->line,
curr->data.lock ==
TRUE_BOOLEXP ? "TRUE_BOOLEXP" : unparse_boolexp(0,
curr->
data.
lock,
0));
break;
case PROG_INTEGER:
sprintf(buf, "%d: (line %d) INTEGER: %d", i, curr->line,
curr->data.number);
break;
case PROG_FLOAT:
sprintf(buf, " %d: (line %d) FLOAT: %.15g", i, curr->line,
curr->data.fnumber);
break;
case PROG_ADD:
sprintf(buf, "%d: (line %d) ADDRESS: %d", i, curr->line,
(int) (curr->data.addr->data - codestart));
break;
case PROG_TRY:
sprintf(buf, "%d: (line %d) TRY: %d", i, curr->line,
(int) (curr->data.call - codestart));
case PROG_IF:
sprintf(buf, "%d: (line %d) IF: %d", i, curr->line,
(int) (curr->data.call - codestart));
break;
case PROG_JMP:
sprintf(buf, "%d: (line %d) JMP: %d", i, curr->line,
(int) (curr->data.call - codestart));
break;
case PROG_EXEC:
sprintf(buf, "%d: (line %d) EXEC: %d", i, curr->line,
(int) (curr->data.call - codestart));
break;
case PROG_OBJECT:
sprintf(buf, "%d: (line %d) OBJECT REF: %d", i, curr->line,
curr->data.number);
break;
case PROG_VAR:
sprintf(buf, "%d: (line %d) VARIABLE: %d", i, curr->line,
curr->data.number);
break;
case PROG_SVAR:
sprintf(buf, "%d: (line %d) SCOPEDVAR: %d", i, curr->line,
curr->data.number);
break;
case PROG_SVAR_AT:
sprintf(buf, "%d: (line %d) GET SCOPEDVAR: %d", i, curr->line,
curr->data.number);
break;
case PROG_SVAR_BANG:
sprintf(buf, "%d: (line %d) SET SCOPEDVAR: %d", i, curr->line,
curr->data.number);
break;
case PROG_LVAR:
sprintf(buf, "%d: (line %d) LOCALVAR: %d", i,
curr->line, curr->data.number);
break;
case PROG_LABEL:
sprintf(buf, "%d: (line %d) LABEL: %s", i, curr->line,
curr->data.labelname);
break;
#ifdef MUF_SOCKETS
case PROG_SOCKET:
sprintf(buf, "%d: (line %d) SOCKET", i, curr->line);
break;
#endif
#ifdef SQL_SUPPORT
case PROG_MYSQL:
sprintf(buf, "%d: (line %d) MYSQL", i, curr->line);
break;
#endif
case PROG_CLEARED:
sprintf(buf, "%d: (line ?) CLEARED INST AT %s:%d", i,
(char *) curr->data.addr, curr->line);
default:
sprintf(buf, "%d: (line ?) UNKNOWN INST", i);
}
notify(player, buf);
}
}
void
disassemble(dbref player, dbref program)
{
struct inst *curr;
struct inst *codestart;
int i;
char buf[BUFFER_LEN];
codestart = curr = PROGRAM_CODE(program);
if (!PROGRAM_SIZ(program)) {
notify(player, "Nothing to disassemble!");
return;
}
for (i = 0; i < PROGRAM_SIZ(program); i++, curr++) {
switch (curr->type) {
case PROG_PRIMITIVE:
if (curr->data.number >= BASE_MIN && curr->data.number <= BASE_MAX)
snprintf(buf, sizeof(buf), "%d: (line %d) PRIMITIVE: %s", i,
curr->line, base_inst[curr->data.number - BASE_MIN]);
else
snprintf(buf, sizeof(buf), "%d: (line %d) PRIMITIVE: %d", i, curr->line, curr->data.number);
break;
case PROG_MARK:
snprintf(buf, sizeof(buf), "%d: (line %d) MARK", i, curr->line);
break;
case PROG_STRING:
snprintf(buf, sizeof(buf), "%d: (line %d) STRING: \"%s\"", i, curr->line,
curr->data.string ? curr->data.string->data : "");
break;
case PROG_ARRAY:
snprintf(buf, sizeof(buf), "%d: (line %d) ARRAY: %d items", i, curr->line,
curr->data.array ? curr->data.array->items : 0);
break;
case PROG_FUNCTION:
snprintf(buf, sizeof(buf), "%d: (line %d) FUNCTION: %s, VARS: %d, ARGS: %d", i, curr->line,
curr->data.mufproc->procname ? curr->data.mufproc->procname : "",
curr->data.mufproc->vars, curr->data.mufproc->args);
break;
case PROG_LOCK:
snprintf(buf, sizeof(buf), "%d: (line %d) LOCK: [%s]", i, curr->line,
curr->data.lock == TRUE_BOOLEXP ? "TRUE_BOOLEXP" :
unparse_boolexp(0, curr->data.lock, 0));
break;
case PROG_INTEGER:
snprintf(buf, sizeof(buf), "%d: (line %d) INTEGER: %d", i, curr->line, curr->data.number);
break;
case PROG_FLOAT:
snprintf(buf, sizeof(buf), "%d: (line %d) FLOAT: %.17g", i, curr->line, curr->data.fnumber);
break;
case PROG_ADD:
snprintf(buf, sizeof(buf), "%d: (line %d) ADDRESS: %d", i,
curr->line, (int)(curr->data.addr->data - codestart));
break;
case PROG_TRY:
snprintf(buf, sizeof(buf), "%d: (line %d) TRY: %d", i, curr->line, (int)(curr->data.call - codestart));
break;
case PROG_IF:
snprintf(buf, sizeof(buf), "%d: (line %d) IF: %d", i, curr->line, (int)(curr->data.call - codestart));
break;
case PROG_JMP:
snprintf(buf, sizeof(buf), "%d: (line %d) JMP: %d", i, curr->line, (int)(curr->data.call - codestart));
break;
case PROG_EXEC:
snprintf(buf, sizeof(buf), "%d: (line %d) EXEC: %d", i, curr->line, (int)(curr->data.call - codestart));
break;
case PROG_OBJECT:
snprintf(buf, sizeof(buf), "%d: (line %d) OBJECT REF: %d", i, curr->line, curr->data.number);
break;
case PROG_VAR:
snprintf(buf, sizeof(buf), "%d: (line %d) VARIABLE: %d", i, curr->line, curr->data.number);
break;
case PROG_SVAR:
snprintf(buf, sizeof(buf), "%d: (line %d) SCOPEDVAR: %d (%s)", i, curr->line, curr->data.number, scopedvar_getname_byinst(curr, curr->data.number));
break;
case PROG_SVAR_AT:
snprintf(buf, sizeof(buf), "%d: (line %d) FETCH SCOPEDVAR: %d (%s)", i, curr->line, curr->data.number, scopedvar_getname_byinst(curr, curr->data.number));
break;
case PROG_SVAR_AT_CLEAR:
snprintf(buf, sizeof(buf), "%d: (line %d) FETCH SCOPEDVAR (clear optim): %d (%s)", i, curr->line, curr->data.number, scopedvar_getname_byinst(curr, curr->data.number));
break;
case PROG_SVAR_BANG:
snprintf(buf, sizeof(buf), "%d: (line %d) SET SCOPEDVAR: %d (%s)", i, curr->line, curr->data.number, scopedvar_getname_byinst(curr, curr->data.number));
break;
case PROG_LVAR:
snprintf(buf, sizeof(buf), "%d: (line %d) LOCALVAR: %d", i, curr->line, curr->data.number);
break;
case PROG_LVAR_AT:
snprintf(buf, sizeof(buf), "%d: (line %d) FETCH LOCALVAR: %d", i, curr->line, curr->data.number);
break;
case PROG_LVAR_AT_CLEAR:
snprintf(buf, sizeof(buf), "%d: (line %d) FETCH LOCALVAR (clear optim): %d", i, curr->line, curr->data.number);
break;
case PROG_LVAR_BANG:
snprintf(buf, sizeof(buf), "%d: (line %d) SET LOCALVAR: %d", i, curr->line, curr->data.number);
break;
case PROG_CLEARED:
snprintf(buf, sizeof(buf), "%d: (line ?) CLEARED INST AT %s:%d", i, (char *) curr->data.addr,
curr->line);
default:
snprintf(buf, sizeof(buf), "%d: (line ?) UNKNOWN INST", i);
}
notify(player, buf);
}
}
void
prim_array_filter_prop(PRIM_PROTOTYPE)
{
char pattern[BUFFER_LEN];
char tname[BUFFER_LEN];
struct inst *in;
struct inst temp1;
stk_array *arr;
stk_array *nu;
char* prop;
int len;
CHECKOP(3);
oper3 = POP(); /* str pattern */
oper2 = POP(); /* str propname */
oper1 = POP(); /* refarr Array */
if (oper1->type != PROG_ARRAY)
abort_interp("Argument not an array. (1)");
if (!array_is_homogenous(oper1->data.array, PROG_OBJECT))
abort_interp("Argument not an array of dbrefs. (1)");
if (oper2->type != PROG_STRING || !oper2->data.string)
abort_interp("Argument not a non-null string. (2)");
if (oper3->type != PROG_STRING)
abort_interp("Argument not a string pattern. (3)");
len = oper2->data.string ? oper2->data.string->length : 0;
strcpyn(tname, sizeof(tname), DoNullInd(oper2->data.string));
while (len-- > 0 && tname[len] == PROPDIR_DELIMITER) {
tname[len] = '\0';
}
nu = new_array_packed(0);
arr = oper1->data.array;
prop = tname;
strcpyn(pattern, sizeof(pattern), DoNullInd(oper3->data.string));
if (array_first(arr, &temp1)) {
do {
in = array_getitem(arr, &temp1);
if (valid_object(in)) {
ref = in->data.objref;
CHECKREMOTE(ref);
if (prop_read_perms(ProgUID, ref, prop, mlev)) {
PropPtr pptr = get_property(ref, prop);
if (pptr)
{
switch(PropType(pptr))
{
case PROP_STRTYP:
strncpy(buf, PropDataStr(pptr), BUFFER_LEN);
break;
case PROP_LOKTYP:
if (PropFlags(pptr) & PROP_ISUNLOADED) {
strncpy(buf, "*UNLOCKED*", BUFFER_LEN);
} else {
strncpy(buf, unparse_boolexp(ProgUID, PropDataLok(pptr), 0), BUFFER_LEN);
}
break;
case PROP_REFTYP:
snprintf(buf, BUFFER_LEN, "#%i", PropDataRef(pptr));
break;
case PROP_INTTYP:
snprintf(buf, BUFFER_LEN, "%i", PropDataVal(pptr));
break;
case PROP_FLTTYP:
snprintf(buf, BUFFER_LEN, "%g", PropDataFVal(pptr));
break;
default:
strncpy(buf, "", BUFFER_LEN);
break;
}
}
else
strncpy(buf, "", BUFFER_LEN);
if (equalstr(pattern, buf)) {
array_appenditem(&nu, in);
}
}
}
} while (array_next(arr, &temp1));
}
CLEAR(oper3);
CLEAR(oper2);
CLEAR(oper1);
PushArrayRaw(nu);
}
void
prim_envpropstr(PRIM_PROTOTYPE)
{
CHECKOP(2);
oper1 = POP();
oper2 = POP();
if (oper1->type != PROG_STRING)
abort_interp("Non-string argument (2)");
if (!oper1->data.string)
abort_interp("Empty string argument (2)");
if (!valid_object(oper2))
abort_interp("Non-object argument (1)");
CHECKREMOTE(oper2->data.objref);
{
char tname[BUFFER_LEN];
dbref what;
PropPtr ptr;
const char *temp;
int len = oper1->data.string->length;
strcpyn(tname, sizeof(tname), oper1->data.string->data);
while (len-- > 0 && tname[len] == PROPDIR_DELIMITER) {
tname[len] = '\0';
}
what = oper2->data.objref;
ptr = envprop(&what, tname, 0);
if (!ptr) {
temp = "";
} else {
#ifdef DISKBASE
propfetch(what, ptr);
#endif
switch (PropType(ptr)) {
case PROP_STRTYP:
temp = PropDataStr(ptr);
break;
/*
*case PROP_INTTYP:
* snprintf(buf, sizeof(buf), "%d", PropDataVal(ptr));
* temp = buf;
* break;
*/
case PROP_REFTYP:
snprintf(buf, sizeof(buf), "#%d", PropDataRef(ptr));
temp = buf;
break;
case PROP_LOKTYP:
if (PropFlags(ptr) & PROP_ISUNLOADED) {
temp = "*UNLOCKED*";
} else {
temp = unparse_boolexp(ProgUID, PropDataLok(ptr), 1);
}
break;
default:
temp = "";
break;
}
}
#ifdef LOG_PROPS
log2file("props.log", "#%d (%d) ENVPROPSTR: o=%d so=%d n=\"%s\" s=\"%s\"",
program, pc->line, what, oper2->data.objref, tname, temp);
#endif
if (what != NOTHING) {
if (!prop_read_perms(ProgUID, what, oper1->data.string->data, mlev))
abort_interp("Permission denied.");
/* if (Typeof(what) != TYPE_PLAYER)
* ts_lastuseobject(what); */
}
CLEAR(oper1);
CLEAR(oper2);
PushObject(what);
PushString(temp);
}
}
void
prim_parsepropex(PRIM_PROTOTYPE)
{
struct inst* oper1 = NULL; /* prevents reentrancy issues! */
struct inst* oper2 = NULL; /* prevents reentrancy issues! */
struct inst* oper3 = NULL; /* prevents reentrancy issues! */
struct inst* oper4 = NULL; /* prevents reentrancy issues! */
stk_array* vars;
const char* mpi;
char* str = 0;
array_iter idx;
extern int varc; /* from msgparse.c */
int mvarcnt = 0;
char* buffers = NULL;
int novars;
int hashow = 0;
int i;
int len;
char tname[BUFFER_LEN];
char buf[BUFFER_LEN];
CHECKOP(4);
oper4 = POP(); /* int:Private */
oper3 = POP(); /* dict:Vars */
oper2 = POP(); /* str:Prop */
oper1 = POP(); /* ref:Object */
if (mlev < 3)
abort_interp("Mucker level 3 or greater required.");
if (oper1->type != PROG_OBJECT)
abort_interp("Non-object argument. (1)");
if (oper2->type != PROG_STRING)
abort_interp("Non-string argument. (2)");
if (oper3->type != PROG_ARRAY)
abort_interp("Non-array argument. (3)");
if (oper3->data.array && (oper3->data.array->type != ARRAY_DICTIONARY))
abort_interp("Dictionary array expected. (3)");
if (oper4->type != PROG_INTEGER)
abort_interp("Non-integer argument. (4)");
if (!valid_object(oper1))
abort_interp("Invalid object. (1)");
if (!oper2->data.string)
abort_interp("Empty string argument. (2)");
if ((oper4->data.number != 0) && (oper4->data.number != 1))
abort_interp("Integer of 0 or 1 expected. (4)");
CHECKREMOTE(oper1->data.objref);
if (!prop_read_perms(ProgUID, oper1->data.objref, oper2->data.string->data, mlev))
abort_interp("Permission denied.");
len = oper2->data.string->length;
strcpyn(tname, sizeof(tname), oper2->data.string->data);
while (len-- > 0 && tname[len] == PROPDIR_DELIMITER) {
tname[len] = '\0';
}
mpi = get_property_class(oper1->data.objref, tname);
vars = oper3->data.array;
novars = array_count(vars);
if (check_mvar_overflow(novars))
abort_interp("Out of MPI variables. (3)");
if (array_first(vars, &idx))
{
do
{
array_data* val = array_getitem(vars, &idx);
if (idx.type != PROG_STRING)
{
CLEAR(&idx);
abort_interp("Only string keys supported. (3)");
}
if (idx.data.string == NULL)
{
CLEAR(&idx);
abort_interp("Empty string keys not supported. (3)");
}
if (strlen(idx.data.string->data) > MAX_MFUN_NAME_LEN)
{
CLEAR(&idx);
abort_interp("Key too long to be an MPI variable. (3)");
}
switch(val->type)
{
case PROG_INTEGER:
case PROG_FLOAT:
case PROG_OBJECT:
case PROG_STRING:
case PROG_LOCK:
break;
default:
CLEAR(&idx);
abort_interp("Only integer, float, dbref, string and lock values supported. (3)");
break;
}
if (string_compare(idx.data.string->data, "how") == 0)
hashow = 1;
}
while(array_next(vars, &idx));
}
if (mpi && *mpi)
{
if (novars > 0)
{
mvarcnt = varc;
if ((buffers = (char*)malloc(novars * BUFFER_LEN)) == NULL)
abort_interp("Out of memory.");
if (array_first(vars, &idx))
{
i = 0;
do
{
char* var_buf = buffers + (i++ * BUFFER_LEN);
array_data* val;
val = array_getitem(vars, &idx);
switch(val->type)
{
case PROG_INTEGER:
snprintf(var_buf, BUFFER_LEN, "%i", val->data.number);
break;
case PROG_FLOAT:
snprintf(var_buf, BUFFER_LEN, "%g", val->data.fnumber);
break;
case PROG_OBJECT:
snprintf(var_buf, BUFFER_LEN, "#%i", val->data.objref);
break;
case PROG_STRING:
strncpy(var_buf, DoNullInd(val->data.string), BUFFER_LEN);
break;
case PROG_LOCK:
strncpy(var_buf, unparse_boolexp(ProgUID, val->data.lock, 1), BUFFER_LEN);
break;
default:
var_buf[0] = '\0';
break;
}
var_buf[BUFFER_LEN - 1] = '\0';
new_mvar(idx.data.string->data, var_buf);
}
while(array_next(vars, &idx));
}
}
result = 0;
if (oper4->data.number)
result |= MPI_ISPRIVATE;
if (Prop_Blessed(oper1->data.objref, oper2->data.string->data))
result |= MPI_ISBLESSED;
if (hashow)
result |= MPI_NOHOW;
str = do_parse_mesg(fr->descr, player, oper1->data.objref, mpi, "(parsepropex)", buf, sizeof(buf), result);
if (novars > 0)
{
if (array_first(vars, &idx))
{
i = 0;
do
{
char* var_buf = buffers + (i++ * BUFFER_LEN);
struct inst temp;
temp.type = PROG_STRING;
temp.data.string = alloc_prog_string(var_buf);
array_setitem(&vars, &idx, &temp);
CLEAR(&temp);
}
while(array_next(vars, &idx));
}
free(buffers);
varc = mvarcnt;
}
}
oper3->data.array = NULL;
CLEAR(oper1);
CLEAR(oper2);
CLEAR(oper3);
CLEAR(oper4);
PushArrayRaw(vars);
PushString(str);
}