/*
* boolexp.c
*/
/*
* $Id: boolexp.c,v 1.3 2005/08/08 09:43:05 murrayma Exp $
*/
#include "copyright.h"
#include "config.h"
#include "db.h"
#include "match.h"
#include "mudconf.h"
#include "externs.h"
#include "interface.h"
#include "attrs.h"
#include "flags.h"
#include "powers.h"
#include "alloc.h"
#ifndef STANDALONE
static int parsing_internal = 0;
/*
* ---------------------------------------------------------------------------
* * check_attr: indicate if attribute ATTR on player passes key when checked by
* * the object lockobj
*/
static int check_attr(player, lockobj, attr, key)
dbref player, lockobj;
ATTR *attr;
char *key;
{
char *buff;
dbref aowner;
int aflags, checkit;
buff = atr_pget(player, attr->number, &aowner, &aflags);
checkit = 0;
if (attr->number == A_LENTER) {
/* We can see enterlocks... else we'd break zones */
checkit = 1;
} else if (See_attr(lockobj, player, attr, aowner, aflags)) {
checkit = 1;
} else if (attr->number == A_NAME) {
checkit = 1;
}
if (checkit && (!wild_match(key, buff))) {
checkit = 0;
}
free_lbuf(buff);
return checkit;
}
int eval_boolexp(player, thing, from, b)
dbref player, thing, from;
BOOLEXP *b;
{
dbref aowner, obj, source;
int aflags, c, checkit;
char *key, *buff, *buff2, *bp, *str;
ATTR *a;
if (b == TRUE_BOOLEXP)
return 1;
switch (b->type) {
case BOOLEXP_AND:
return (eval_boolexp(player, thing, from, b->sub1) &&
eval_boolexp(player, thing, from, b->sub2));
case BOOLEXP_OR:
return (eval_boolexp(player, thing, from, b->sub1) ||
eval_boolexp(player, thing, from, b->sub2));
case BOOLEXP_NOT:
return !eval_boolexp(player, thing, from, b->sub1);
case BOOLEXP_INDIR:
/*
* BOOLEXP_INDIR (i.e. @) is a unary operation which is replaced at
* evaluation time by the lock of the object whose number is the
* argument of the operation.
*/
mudstate.lock_nest_lev++;
if (mudstate.lock_nest_lev >= mudconf.lock_nest_lim) {
#ifndef STANDALONE
STARTLOG(LOG_BUGS, "BUG", "LOCK") {
log_name_and_loc(player);
log_text((char *) ": Lock exceeded recursion limit.");
ENDLOG;
} notify(player, "Sorry, broken lock!");
#else
fprintf(stderr, "Lock exceeded recursion limit.\n");
#endif
mudstate.lock_nest_lev--;
return (0);
}
if ((b->sub1->type != BOOLEXP_CONST) || (b->sub1->thing < 0)) {
#ifndef STANDALONE
STARTLOG(LOG_BUGS, "BUG", "LOCK") {
log_name_and_loc(player);
buff = alloc_mbuf("eval_boolexp.LOG.indir");
sprintf(buff, ": Lock had bad indirection (%c, type %d)",
INDIR_TOKEN, b->sub1->type);
log_text(buff);
free_mbuf(buff);
ENDLOG;
}
notify(player, "Sorry, broken lock!");
#else
fprintf(stderr, "Broken lock.\n");
#endif
mudstate.lock_nest_lev--;
return (0);
}
key = atr_get(b->sub1->thing, A_LOCK, &aowner, &aflags);
c = eval_boolexp_atr(player, b->sub1->thing, from, key);
free_lbuf(key);
mudstate.lock_nest_lev--;
return (c);
case BOOLEXP_CONST:
return (b->thing == player || member(b->thing, Contents(player)));
case BOOLEXP_ATR:
a = atr_num(b->thing);
if (!a)
return 0; /*
* no such attribute
*/
/*
* First check the object itself, then its contents
*/
if (check_attr(player, from, a, (char *) b->sub1))
return 1;
DOLIST(obj, Contents(player)) {
if (check_attr(obj, from, a, (char *) b->sub1))
return 1;
}
return 0;
case BOOLEXP_EVAL:
a = atr_num(b->thing);
if (!a)
return 0; /*
* no such attribute
*/
source = from;
buff = atr_pget(from, a->number, &aowner, &aflags);
if (!buff || !*buff) {
free_lbuf(buff);
buff = atr_pget(thing, a->number, &aowner, &aflags);
source = thing;
}
checkit = 0;
if ((a->number == A_NAME) || (a->number == A_LENTER)) {
checkit = 1;
} else if (Read_attr(source, source, a, aowner, aflags)) {
checkit = 1;
}
if (checkit) {
buff2 = bp = alloc_lbuf("eval_boolexp");
str = buff;
exec(buff2, &bp, 0, source, player,
EV_FIGNORE | EV_EVAL | EV_TOP, &str, (char **) NULL, 0);
*bp = '\0';
checkit = !string_compare(buff2, (char *) b->sub1);
free_lbuf(buff2);
}
free_lbuf(buff);
return checkit;
case BOOLEXP_IS:
/*
* If an object check, do that
*/
if (b->sub1->type == BOOLEXP_CONST)
return (b->sub1->thing == player);
/*
* Nope, do an attribute check
*/
a = atr_num(b->sub1->thing);
if (!a)
return 0;
return (check_attr(player, from, a, (char *) (b->sub1)->sub1));
case BOOLEXP_CARRY:
/*
* If an object check, do that
*/
if (b->sub1->type == BOOLEXP_CONST)
return (member(b->sub1->thing, Contents(player)));
/*
* Nope, do an attribute check
*/
a = atr_num(b->sub1->thing);
if (!a)
return 0;
DOLIST(obj, Contents(player)) {
if (check_attr(obj, from, a, (char *) (b->sub1)->sub1))
return 1;
}
return 0;
case BOOLEXP_OWNER:
return (Owner(b->sub1->thing) == Owner(player));
default:
abort(); /*
* bad type
*/
return 0;
}
}
int eval_boolexp_atr(player, thing, from, key)
dbref player, thing, from;
char *key;
{
BOOLEXP *b;
int ret_value;
b = parse_boolexp(player, key, 1);
if (b == NULL) {
ret_value = 1;
} else {
ret_value = eval_boolexp(player, thing, from, b);
free_boolexp(b);
}
return (ret_value);
}
#endif
/*
* If the parser returns TRUE_BOOLEXP, you lose
*/
/*
* TRUE_BOOLEXP cannot be typed in by the user; use @unlock instead
*/
static const char *parsebuf;
static char parsestore[LBUF_SIZE];
static dbref parse_player;
static void skip_whitespace(void)
{
while (*parsebuf && isspace(*parsebuf))
parsebuf++;
}
static BOOLEXP *parse_boolexp_E(void); /*
* * defined below
*/
static BOOLEXP *test_atr(s)
char *s;
{
ATTR *attrib;
BOOLEXP *b;
char *buff, *s1;
int anum, locktype;
buff = alloc_lbuf("test_atr");
StringCopy(buff, s);
for (s = buff; *s && (*s != ':') && (*s != '/'); s++);
if (!*s) {
free_lbuf(buff);
return ((BOOLEXP *) NULL);
}
if (*s == '/')
locktype = BOOLEXP_EVAL;
else
locktype = BOOLEXP_ATR;
*s++ = '\0';
/*
* see if left side is valid attribute. Access to attr is checked on
*
* * * * * * * * * * eval * Also allow numeric references to *
* attributes. * It * can't * hurt * us, and * lets us import stuff
* * that stores * attr * locks by * number * instead of by * name.
*/
if (!(attrib = atr_str(buff))) {
/*
* Only #1 can lock on numbers
*/
if (!God(parse_player)) {
free_lbuf(buff);
return ((BOOLEXP *) NULL);
}
s1 = buff;
for (s1 = buff; isdigit(*s1); s1++);
if (*s1) {
free_lbuf(buff);
return ((BOOLEXP *) NULL);
}
anum = atoi(buff);
} else {
anum = attrib->number;
}
/*
* made it now make the parse tree node
*/
b = alloc_bool("test_str");
b->type = locktype;
b->thing = (dbref) anum;
b->sub1 = (BOOLEXP *) strsave(s);
free_lbuf(buff);
return (b);
}
/*
* L -> (E); L -> object identifier
*/
static BOOLEXP *parse_boolexp_L(void)
{
BOOLEXP *b;
char *p, *buf;
#ifndef STANDALONE
MSTATE mstate;
#endif
buf = NULL;
skip_whitespace();
switch (*parsebuf) {
case '(':
parsebuf++;
b = parse_boolexp_E();
skip_whitespace();
if (b == TRUE_BOOLEXP || *parsebuf++ != ')') {
free_boolexp(b);
return TRUE_BOOLEXP;
}
break;
default:
/*
* must have hit an object ref. Load the name into our * * *
*
* * * * * * buffer
*/
buf = alloc_lbuf("parse_boolexp_L");
p = buf;
while (*parsebuf && (*parsebuf != AND_TOKEN) &&
(*parsebuf != OR_TOKEN) && (*parsebuf != ')')) {
*p++ = *parsebuf++;
}
/*
* strip trailing whitespace
*/
*p-- = '\0';
while (isspace(*p))
*p-- = '\0';
/*
* check for an attribute
*/
if ((b = test_atr(buf)) != NULL) {
free_lbuf(buf);
return (b);
}
b = alloc_bool("parse_boolexp_L");
b->type = BOOLEXP_CONST;
/*
* do the match
*/
#ifndef STANDALONE
/*
* If we are parsing a boolexp that was a stored lock then *
* * * * * * we know that object refs are all dbrefs, so we *
* skip * * the * * * expensive match code.
*/
if (parsing_internal) {
if (buf[0] != '#') {
free_lbuf(buf);
free_bool(b);
return TRUE_BOOLEXP;
}
b->thing = atoi(&buf[1]);
if (!Good_obj(b->thing)) {
free_lbuf(buf);
free_bool(b);
return TRUE_BOOLEXP;
}
} else {
save_match_state(&mstate);
init_match(parse_player, buf, TYPE_THING);
match_everything(MAT_EXIT_PARENTS);
b->thing = match_result();
restore_match_state(&mstate);
}
if (b->thing == NOTHING) {
notify(parse_player, tprintf("I don't see %s here.", buf));
free_lbuf(buf);
free_bool(b);
return TRUE_BOOLEXP;
}
if (b->thing == AMBIGUOUS) {
notify(parse_player, tprintf("I don't know which %s you mean!",
buf));
free_lbuf(buf);
free_bool(b);
return TRUE_BOOLEXP;
}
#else /*
* * STANDALONE ... had better be #<num> or we're hosed
*/
if (buf[0] != '#') {
free_lbuf(buf);
free_bool(b);
return TRUE_BOOLEXP;
}
b->thing = atoi(&buf[1]);
if (b->thing < 0) {
free_lbuf(buf);
free_bool(b);
return TRUE_BOOLEXP;
}
#endif
free_lbuf(buf);
}
return b;
}
/*
* F -> !F; F -> @L; F -> =L; F -> +L; F -> $L
*/
/*
* The argument L must be type BOOLEXP_CONST
*/
static BOOLEXP *parse_boolexp_F(void)
{
BOOLEXP *b2;
skip_whitespace();
switch (*parsebuf) {
case NOT_TOKEN:
parsebuf++;
b2 = alloc_bool("parse_boolexp_F.not");
b2->type = BOOLEXP_NOT;
if ((b2->sub1 = parse_boolexp_F()) == TRUE_BOOLEXP) {
free_boolexp(b2);
return (TRUE_BOOLEXP);
} else
return (b2);
/*
* NOTREACHED
*/
break;
case INDIR_TOKEN:
parsebuf++;
b2 = alloc_bool("parse_boolexp_F.indir");
b2->type = BOOLEXP_INDIR;
b2->sub1 = parse_boolexp_L();
if ((b2->sub1) == TRUE_BOOLEXP) {
free_boolexp(b2);
return (TRUE_BOOLEXP);
} else if ((b2->sub1->type) != BOOLEXP_CONST) {
free_boolexp(b2);
return (TRUE_BOOLEXP);
} else
return (b2);
/*
* NOTREACHED
*/
break;
case IS_TOKEN:
parsebuf++;
b2 = alloc_bool("parse_boolexp_F.is");
b2->type = BOOLEXP_IS;
b2->sub1 = parse_boolexp_L();
if ((b2->sub1) == TRUE_BOOLEXP) {
free_boolexp(b2);
return (TRUE_BOOLEXP);
} else if (((b2->sub1->type) != BOOLEXP_CONST) &&
((b2->sub1->type) != BOOLEXP_ATR)) {
free_boolexp(b2);
return (TRUE_BOOLEXP);
} else
return (b2);
/*
* NOTREACHED
*/
break;
case CARRY_TOKEN:
parsebuf++;
b2 = alloc_bool("parse_boolexp_F.carry");
b2->type = BOOLEXP_CARRY;
b2->sub1 = parse_boolexp_L();
if ((b2->sub1) == TRUE_BOOLEXP) {
free_boolexp(b2);
return (TRUE_BOOLEXP);
} else if (((b2->sub1->type) != BOOLEXP_CONST) &&
((b2->sub1->type) != BOOLEXP_ATR)) {
free_boolexp(b2);
return (TRUE_BOOLEXP);
} else
return (b2);
/*
* NOTREACHED
*/
break;
case OWNER_TOKEN:
parsebuf++;
b2 = alloc_bool("parse_boolexp_F.owner");
b2->type = BOOLEXP_OWNER;
b2->sub1 = parse_boolexp_L();
if ((b2->sub1) == TRUE_BOOLEXP) {
free_boolexp(b2);
return (TRUE_BOOLEXP);
} else if ((b2->sub1->type) != BOOLEXP_CONST) {
free_boolexp(b2);
return (TRUE_BOOLEXP);
} else
return (b2);
/*
* NOTREACHED
*/
break;
default:
return (parse_boolexp_L());
}
}
/*
* T -> F; T -> F & T
*/
static BOOLEXP *parse_boolexp_T(void)
{
BOOLEXP *b, *b2;
if ((b = parse_boolexp_F()) != TRUE_BOOLEXP) {
skip_whitespace();
if (*parsebuf == AND_TOKEN) {
parsebuf++;
b2 = alloc_bool("parse_boolexp_T");
b2->type = BOOLEXP_AND;
b2->sub1 = b;
if ((b2->sub2 = parse_boolexp_T()) == TRUE_BOOLEXP) {
free_boolexp(b2);
return TRUE_BOOLEXP;
}
b = b2;
}
}
return b;
}
/*
* E -> T; E -> T | E
*/
static BOOLEXP *parse_boolexp_E(void)
{
BOOLEXP *b, *b2;
if ((b = parse_boolexp_T()) != TRUE_BOOLEXP) {
skip_whitespace();
if (*parsebuf == OR_TOKEN) {
parsebuf++;
b2 = alloc_bool("parse_boolexp_E");
b2->type = BOOLEXP_OR;
b2->sub1 = b;
if ((b2->sub2 = parse_boolexp_E()) == TRUE_BOOLEXP) {
free_boolexp(b2);
return TRUE_BOOLEXP;
}
b = b2;
}
}
return b;
}
BOOLEXP *parse_boolexp(player, buf, internal)
dbref player;
const char *buf;
int internal;
{
StringCopy(parsestore, buf);
parsebuf = parsestore;
parse_player = player;
if ((buf == NULL) || (*buf == '\0'))
return (TRUE_BOOLEXP);
#ifndef STANDALONE
parsing_internal = internal;
#endif
return parse_boolexp_E();
}