static int db_write_object(FILE * f, dbref i, int db_format, int flags)
{
ATTR *a;
char *got, *as;
dbref aowner;
int ca, aflags, save, j;
BOOLEXP *tempbool;
if(!(flags & V_ATRNAME))
putstring(f, Name(i));
putref(f, Location(i));
if(flags & V_ZONE)
putref(f, Zone(i));
putref(f, Contents(i));
putref(f, Exits(i));
if(flags & V_LINK)
putref(f, Link(i));
putref(f, Next(i));
if(!(flags & V_ATRKEY)) {
got = atr_get(i, A_LOCK, &aowner, &aflags);
tempbool = parse_boolexp(GOD, got, 1);
free_lbuf(got);
putboolexp(f, tempbool);
if(tempbool)
free_bool(tempbool);
}
putref(f, Owner(i));
if(flags & V_PARENT)
putref(f, Parent(i));
if(!(flags & V_ATRMONEY))
putref(f, Pennies(i));
putref(f, Flags(i));
if(flags & V_XFLAGS)
putref(f, Flags2(i));
if(flags & V_3FLAGS)
putref(f, Flags3(i));
if(flags & V_POWERS) {
putref(f, Powers(i));
putref(f, Powers2(i));
}
/*
* write the attribute list
*/
if((!(flags & V_GDBM)) || (mudstate.panicking == 1)) {
for(ca = atr_head(i, &as); ca; ca = atr_next(&as)) {
save = 0;
a = atr_num(ca);
if(a)
j = a->number;
else
j = -1;
if(j > 0) {
switch (j) {
case A_NAME:
if(flags & V_ATRNAME)
save = 1;
break;
case A_LOCK:
if(flags & V_ATRKEY)
save = 1;
break;
case A_LIST:
case A_MONEY:
break;
default:
save = 1;
}
}
if(save) {
got = atr_get_raw(i, j);
fprintf(f, ">%d\n", j);
putstring(f, got);
}
}
fprintf(f, "<\n");
}
return 0;
}
static void unparse_boolexp1( dbref player, BOOLEXP *b, char outer_type, int format ) {
ATTR *ap;
char sep_ch;
char *buff;
if( b == TRUE_BOOLEXP ) {
if( format == F_EXAMINE ) {
safe_str( ( char * ) "*UNLOCKED*", boolexp_buf, &buftop );
}
return;
}
switch( b->type ) {
case BOOLEXP_AND:
if( outer_type == BOOLEXP_NOT ) {
safe_chr( '(', boolexp_buf, &buftop );
}
unparse_boolexp1( player, b->sub1, b->type, format );
safe_chr( AND_TOKEN, boolexp_buf, &buftop );
unparse_boolexp1( player, b->sub2, b->type, format );
if( outer_type == BOOLEXP_NOT ) {
safe_chr( ')', boolexp_buf, &buftop );
}
break;
case BOOLEXP_OR:
if( outer_type == BOOLEXP_NOT || outer_type == BOOLEXP_AND ) {
safe_chr( '(', boolexp_buf, &buftop );
}
unparse_boolexp1( player, b->sub1, b->type, format );
safe_chr( OR_TOKEN, boolexp_buf, &buftop );
unparse_boolexp1( player, b->sub2, b->type, format );
if( outer_type == BOOLEXP_NOT || outer_type == BOOLEXP_AND ) {
safe_chr( ')', boolexp_buf, &buftop );
}
break;
case BOOLEXP_NOT:
safe_chr( '!', boolexp_buf, &buftop );
unparse_boolexp1( player, b->sub1, b->type, format );
break;
case BOOLEXP_INDIR:
safe_chr( INDIR_TOKEN, boolexp_buf, &buftop );
unparse_boolexp1( player, b->sub1, b->type, format );
break;
case BOOLEXP_IS:
safe_chr( IS_TOKEN, boolexp_buf, &buftop );
unparse_boolexp1( player, b->sub1, b->type, format );
break;
case BOOLEXP_CARRY:
safe_chr( CARRY_TOKEN, boolexp_buf, &buftop );
unparse_boolexp1( player, b->sub1, b->type, format );
break;
case BOOLEXP_OWNER:
safe_chr( OWNER_TOKEN, boolexp_buf, &buftop );
unparse_boolexp1( player, b->sub1, b->type, format );
break;
case BOOLEXP_CONST:
if( !mudstate.standalone ) {
switch( format ) {
case F_QUIET:
/*
* Quiet output - for dumps and internal use.
* Always #Num
*/
safe_str( ( char * ) unparse_object_quiet( player,
b->thing ), boolexp_buf, &buftop );
break;
case F_EXAMINE:
/*
* Examine output - informative. *
* Name(#Num) or Name
*/
buff = unparse_object( player, b->thing, 0 );
safe_str( buff, boolexp_buf, &buftop );
free_lbuf( buff );
break;
case F_DECOMPILE:
/*
* Decompile output - should be usable on
* other MUSHes. *Name if player, Name if
* thing, else #Num
*/
switch( Typeof( b->thing ) ) {
case TYPE_PLAYER:
safe_chr( '*', boolexp_buf, &buftop );
case TYPE_THING:
safe_name( b->thing, boolexp_buf,
&buftop );
break;
default:
safe_dbref( boolexp_buf, &buftop,
b->thing );
break;
}
break;
case F_FUNCTION:
/*
* Function output - must be usable by @lock
* cmd. *Name if player, else #Num
*/
switch( Typeof( b->thing ) ) {
case TYPE_PLAYER:
safe_chr( '*', boolexp_buf, &buftop );
safe_name( b->thing, boolexp_buf,
&buftop );
break;
default:
safe_dbref( boolexp_buf, &buftop,
b->thing );
break;
}
}
} else {
safe_str( ( char * ) unparse_object_quiet( player,
b->thing ), boolexp_buf, &buftop );
}
break;
case BOOLEXP_ATR:
case BOOLEXP_EVAL:
if( b->type == BOOLEXP_EVAL ) {
sep_ch = '/';
} else {
sep_ch = ':';
}
ap = atr_num( b->thing );
if( ap && ap->number ) {
safe_str( ( char * ) ap->name, boolexp_buf, &buftop );
} else {
safe_ltos( boolexp_buf, &buftop, b->thing );
}
safe_chr( sep_ch, boolexp_buf, &buftop );
safe_str( ( char * ) b->sub1, boolexp_buf, &buftop );
break;
default:
log_write_raw( 1, "ABORT! unparse.c, bad boolexp type in unparse_boolexp1().\n" );
abort();
break;
}
}
/*
* ---------------------------------------------------------------------------
* * putbool_subexp: Write a boolean sub-expression to the flat file.
*/
static void putbool_subexp(FILE * f, BOOLEXP * b)
{
ATTR *va;
switch (b->type) {
case BOOLEXP_IS:
putc('(', f);
putc(IS_TOKEN, f);
putbool_subexp(f, b->sub1);
putc(')', f);
break;
case BOOLEXP_CARRY:
putc('(', f);
putc(CARRY_TOKEN, f);
putbool_subexp(f, b->sub1);
putc(')', f);
break;
case BOOLEXP_INDIR:
putc('(', f);
putc(INDIR_TOKEN, f);
putbool_subexp(f, b->sub1);
putc(')', f);
break;
case BOOLEXP_OWNER:
putc('(', f);
putc(OWNER_TOKEN, f);
putbool_subexp(f, b->sub1);
putc(')', f);
break;
case BOOLEXP_AND:
putc('(', f);
putbool_subexp(f, b->sub1);
putc(AND_TOKEN, f);
putbool_subexp(f, b->sub2);
putc(')', f);
break;
case BOOLEXP_OR:
putc('(', f);
putbool_subexp(f, b->sub1);
putc(OR_TOKEN, f);
putbool_subexp(f, b->sub2);
putc(')', f);
break;
case BOOLEXP_NOT:
putc('(', f);
putc(NOT_TOKEN, f);
putbool_subexp(f, b->sub1);
putc(')', f);
break;
case BOOLEXP_CONST:
fprintf(f, "%d", b->thing);
break;
case BOOLEXP_ATR:
va = atr_num(b->thing);
if(va) {
fprintf(f, "%s:%s", va->name, (char *) b->sub1);
} else {
fprintf(f, "%d:%s\n", b->thing, (char *) b->sub1);
}
break;
case BOOLEXP_EVAL:
va = atr_num(b->thing);
if(va) {
fprintf(f, "%s/%s\n", va->name, (char *) b->sub1);
} else {
fprintf(f, "%d/%s\n", b->thing, (char *) b->sub1);
}
break;
default:
fprintf(stderr, "Unknown boolean type in putbool_subexp: %d\n",
b->type);
}
}
// ---------------------------------------------------------------------------
// do_wait: Command interface to wait_que
//
void do_wait
(
dbref executor,
dbref caller,
dbref enactor,
int eval,
int key,
char *event,
char *cmd,
char *cargs[],
int ncargs
)
{
CLinearTimeAbsolute ltaWhen;
CLinearTimeDelta ltd;
// If arg1 is all numeric, do simple (non-sem) timed wait.
//
if (is_rational(event))
{
if (key & WAIT_UNTIL)
{
ltaWhen.SetSecondsString(event);
}
else
{
ltaWhen.GetUTC();
ltd.SetSecondsString(event);
ltaWhen += ltd;
}
wait_que(executor, caller, enactor, eval, true, ltaWhen, NOTHING, 0,
cmd,
ncargs, cargs,
mudstate.global_regs);
return;
}
// Semaphore wait with optional timeout.
//
char *what = parse_to(&event, '/', 0);
init_match(executor, what, NOTYPE);
match_everything(0);
dbref thing = noisy_match_result();
if (!Good_obj(thing))
{
return;
}
else if (!Controls(executor, thing) && !Link_ok(thing))
{
notify(executor, NOPERM_MESSAGE);
}
else
{
// Get timeout, default 0.
//
int atr = A_SEMAPHORE;
bool bTimed = false;
if (event && *event)
{
if (is_rational(event))
{
if (key & WAIT_UNTIL)
{
ltaWhen.SetSecondsString(event);
}
else
{
ltaWhen.GetUTC();
ltd.SetSecondsString(event);
ltaWhen += ltd;
}
bTimed = true;
}
else
{
ATTR *ap = atr_str(event);
if (!ap)
{
atr = mkattr(executor, event);
if (atr <= 0)
{
notify_quiet(executor, "Invalid attribute.");
return;
}
ap = atr_num(atr);
}
else
{
atr = ap->number;
}
if (!bCanSetAttr(executor, thing, ap))
{
notify_quiet(executor, NOPERM_MESSAGE);
return;
}
}
}
int num = add_to(thing, 1, atr);
if (num <= 0)
{
// Thing over-notified, run the command immediately.
//
thing = NOTHING;
bTimed = false;
}
wait_que(executor, caller, enactor, eval, bTimed, ltaWhen, thing, atr,
cmd,
ncargs, cargs,
mudstate.global_regs);
}
}
