mux/src/db_rw.cpp File Reference

#include "copyright.h"
#include "autoconf.h"
#include "config.h"
#include "externs.h"
#include "attrs.h"
#include "vattr.h"

Include dependency graph for db_rw.cpp:

Go to the source code of this file.

Functions
static BOOLEXP *	getboolexp1 (FILE *f)
static BOOLEXP *	getboolexp (FILE *f)
static bool	get_list (FILE *f, dbref i)
static void	putbool_subexp (FILE *f, BOOLEXP *b)
static void	putboolexp (FILE *f, BOOLEXP *b)
dbref	db_read (FILE *f, int *db_format, int *db_version, int *db_flags)
static bool	db_write_object (FILE *f, dbref i, int db_format, int flags)
dbref	db_write (FILE *f, int format, int version)
Variables
static int	g_version
static int	g_format
static int	g_flags

---

Function Documentation

dbref db_read	(	FILE *	f,
		int *	db_format,
		int *	db_version,
		int *	db_flags
	)

Definition at line 501 of file db_rw.cpp.

References A_LOCK, alloc_lbuf, ANSI_ENDGOAL_NORMAL, ANSI_TruncateToField(), atr_add_raw(), statedata::attr_next, statedata::bStandAlone, c_Connected, db_free(), db_grow(), statedata::db_top, ENDLINE, F_MUX, F_UNKNOWN, FLAG_WORD1, FLAG_WORD2, FLAG_WORD3, CLogFile::Flush(), free_boolexp(), free_lbuf, g_flags, g_format, g_version, get_list(), getboolexp(), getref(), getstring_noalloc(), isPlayer, load_player_names(), Log, MakeCanonicalAttributeName(), MANDFLAGS, MAX_SUPPORTED_VERSION, MBUF_SIZE, statedata::min_size, MIN_SUPPORTED_VERSION, mudconf, mudstate, mux_assert, mux_isdigit, mux_isprint, NOTHING, statedata::record_players, confdata::reset_players, s_Contents, s_Exits, s_Flags, s_Link, s_Location, s_Name(), s_Next, s_Owner, s_Parent, s_PenniesDirect(), s_Powers, s_Powers2, s_Zone, CLogFile::tinyprintf(), unparse_boolexp_quiet(), V_ATRKEY, V_ATRMONEY, V_ATRNAME, V_DATABASE, V_MASK, vattr_define_LEN(), confdata::vattr_flags, and CLogFile::WriteString().

Referenced by dbconvert(), and load_game().

{
    dbref i, anum;
    int ch;
    const char *tstr;
    int aflags;
    BOOLEXP *tempbool;
    char *buff;
    int nVisualWidth;

    g_format = F_UNKNOWN;
    g_version = 0;
    g_flags = 0;

    bool header_gotten = false;
    bool size_gotten = false;
    bool nextattr_gotten = false;

    bool read_attribs = true;
    bool read_name = true;
    bool read_key = true;
    bool read_money = true;

    int nName;
    bool bValid;
    char *pName;

    int iDotCounter = 0;
    if (mudstate.bStandAlone)
    {
        Log.WriteString("Reading ");
        Log.Flush();
    }
    db_free();
    for (i = 0;; i++)
    {
        if (mudstate.bStandAlone)
        {
            if (!iDotCounter)
            {
                iDotCounter = 100;
                fputc('.', stderr);
                fflush(stderr);
            }
            iDotCounter--;
        }

        ch = getc(f);
        switch (ch)
        {
        case '-':   // Misc tag
            ch = getc(f);
            if (ch == 'R')
            {
                // Record number of players
                //
                mudstate.record_players = getref(f);
                if (mudconf.reset_players)
                {
                    mudstate.record_players = 0;
                }
            }
            break;

        case '+':

            // MUX header
            //
            ch = getc(f);
            if (ch == 'A')
            {
                // USER-NAMED ATTRIBUTE
                //
                anum = getref(f);
                tstr = getstring_noalloc(f, true);
                if (mux_isdigit(*tstr))
                {
                    aflags = 0;
                    while (mux_isdigit(*tstr))
                    {
                        aflags = (aflags * 10) + (*tstr++ - '0');
                    }
                    tstr++; // skip ':'
                }
                else
                {
                    aflags = mudconf.vattr_flags;
                }
                pName = MakeCanonicalAttributeName(tstr, &nName, &bValid);
                if (bValid)
                {
                    vattr_define_LEN(pName, nName, anum, aflags);
                }
            }
            else if (ch == 'X')
            {
                // MUX VERSION
                //
                if (header_gotten)
                {
                    Log.tinyprintf(ENDLINE "Duplicate MUX version header entry at object %d, ignored." ENDLINE, i);
                    tstr = getstring_noalloc(f, 0);
                }
                else
                {
                    header_gotten = true;
                    g_format = F_MUX;
                    g_version = getref(f);
                    mux_assert((g_version & MANDFLAGS) == MANDFLAGS);

                    // Otherwise extract feature flags
                    //
                    if (g_version & V_DATABASE)
                    {
                        read_attribs = false;
                        read_name = !(g_version & V_ATRNAME);
                    }
                    read_key = !(g_version & V_ATRKEY);
                    read_money = !(g_version & V_ATRMONEY);
                    g_flags = g_version & ~V_MASK;

                    g_version &= V_MASK;
                    if (  g_version < MIN_SUPPORTED_VERSION
                       || MAX_SUPPORTED_VERSION < g_version)
                    {
                        Log.tinyprintf(ENDLINE "Unsupported flatfile version: %d." ENDLINE, g_version);
                        return -1;
                    }
                }
            }
            else if (ch == 'S')
            {
                // SIZE
                //
                if (size_gotten)
                {
                    Log.tinyprintf(ENDLINE "Duplicate size entry at object %d, ignored." ENDLINE, i);
                    tstr = getstring_noalloc(f, 0);
                }
                else
                {
                    mudstate.min_size = getref(f);
                    size_gotten = true;
                }
            }
            else if (ch == 'N')
            {
                // NEXT ATTR TO ALLOC WHEN NO FREELIST
                //
                if (nextattr_gotten)
                {
                    Log.tinyprintf(ENDLINE "Duplicate next free vattr entry at object %d, ignored." ENDLINE, i);
                    tstr = getstring_noalloc(f, 0);
                }
                else
                {
                    mudstate.attr_next = getref(f);
                    nextattr_gotten = true;
                }
            }
            else
            {
                Log.tinyprintf(ENDLINE "Unexpected character '%c' in MUX header near object #%d, ignored." ENDLINE, ch, i);
                tstr = getstring_noalloc(f, 0);
            }
            break;

        case '!':   // MUX entry
            i = getref(f);
            db_grow(i + 1);

            if (read_name)
            {
                tstr = getstring_noalloc(f, true);
                buff = alloc_lbuf("dbread.s_Name");
                (void)ANSI_TruncateToField(tstr, MBUF_SIZE, buff, MBUF_SIZE,
                    &nVisualWidth, ANSI_ENDGOAL_NORMAL);
                s_Name(i, buff);
                free_lbuf(buff);

                s_Location(i, getref(f));
            }
            else
            {
                s_Location(i, getref(f));
            }

            // ZONE
            //
            int zone;
            zone = getref(f);
            if (zone < NOTHING)
            {
                zone = NOTHING;
            }
            s_Zone(i, zone);

            // CONTENTS and EXITS
            //
            s_Contents(i, getref(f));
            s_Exits(i, getref(f));

            // LINK
            //
            s_Link(i, getref(f));

            // NEXT
            //
            s_Next(i, getref(f));

            // LOCK
            //
            if (read_key)
            {
                tempbool = getboolexp(f);
                atr_add_raw(i, A_LOCK,
                unparse_boolexp_quiet(1, tempbool));
                free_boolexp(tempbool);
            }

            // OWNER
            //
            s_Owner(i, getref(f));

            // PARENT
            //
            s_Parent(i, getref(f));

            // PENNIES
            //
            if (read_money)
            {
                s_PenniesDirect(i, getref(f));
            }

            // FLAGS
            //
            s_Flags(i, FLAG_WORD1, getref(f));
            s_Flags(i, FLAG_WORD2, getref(f));
            s_Flags(i, FLAG_WORD3, getref(f));

            // POWERS
            //
            s_Powers(i, getref(f));
            s_Powers2(i, getref(f));

            // ATTRIBUTES
            //
            if (read_attribs)
            {
                if (!get_list(f, i))
                {
                    Log.tinyprintf(ENDLINE "Error reading attrs for object #%d" ENDLINE, i);
                    return -1;
                }
            }

            // check to see if it's a player
            //
            if (isPlayer(i))
            {
                c_Connected(i);
            }
            break;

        case '*':   // EOF marker
            tstr = getstring_noalloc(f, 0);
            if (strncmp(tstr, "**END OF DUMP***", 16))
            {
                Log.tinyprintf(ENDLINE "Bad EOF marker at object #%d" ENDLINE, i);
                return -1;
            }
            else
            {
                *db_version = g_version;
                *db_format = g_format;
                *db_flags = g_flags;
                if (mudstate.bStandAlone)
                {
                    Log.WriteString(ENDLINE);
                    Log.Flush();
                }
                else
                {
                    load_player_names();
                }
                return mudstate.db_top;
            }

        case EOF:
            Log.tinyprintf(ENDLINE "Unexpected end of file near object #%d" ENDLINE, i);
            return -1;

        default:
            if (mux_isprint(ch))
            {
                Log.tinyprintf(ENDLINE "Illegal character '%c' near object #%d" ENDLINE, ch, i);
            }
            else
            {
                Log.tinyprintf(ENDLINE "Illegal character 0x%02x near object #%d" ENDLINE, ch, i);
            }
            return -1;
        }
    }
}

dbref db_write	(	FILE *	f,
		int	format,
		int	version
	)

Definition at line 910 of file db_rw.cpp.

References A_USER_START, AF_DELETED, anum_alc_top, anum_get, statedata::attr_next, statedata::bStandAlone, statedata::db_top, ENDLINE, F_MUX, attr::flags, CLogFile::Flush(), LBUF_SIZE, Log, mudstate, mux_ltoa(), attr::name, attr::number, statedata::record_players, and CLogFile::WriteString().

Referenced by dbconvert(), and dump_database_internal().

{
    dbref i;
    int flags;
    ATTR *vp;

    switch (format)
    {
    case F_MUX:
        flags = version;
        break;

    default:
        Log.WriteString("Can only write MUX format." ENDLINE);
        return -1;
    }
    if (mudstate.bStandAlone)
    {
        Log.WriteString("Writing ");
        Log.Flush();
    }
    i = mudstate.attr_next;
    fprintf(f, "+X%d\n+S%d\n+N%d\n", flags, mudstate.db_top, i);
    fprintf(f, "-R%d\n", mudstate.record_players);

    // Dump user-named attribute info.
    //
    char Buffer[LBUF_SIZE];
    Buffer[0] = '+';
    Buffer[1] = 'A';
    int iAttr;
    for (iAttr = A_USER_START; iAttr <= anum_alc_top; iAttr++)
    {
        vp = (ATTR *) anum_get(iAttr);
        if (  vp != NULL
           && !(vp->flags & AF_DELETED))
        {
            // Format is: "+A%d\n\"%d:%s\"\n", vp->number, vp->flags, vp->name
            //
            char *pBuffer = Buffer+2;
            pBuffer += mux_ltoa(vp->number, pBuffer);
            *pBuffer++ = '\n';
            *pBuffer++ = '"';
            pBuffer += mux_ltoa(vp->flags, pBuffer);
            *pBuffer++ = ':';
            int nNameLength = strlen(vp->name);
            memcpy(pBuffer, vp->name, nNameLength);
            pBuffer += nNameLength;
            *pBuffer++ = '"';
            *pBuffer++ = '\n';
            fwrite(Buffer, sizeof(char), pBuffer-Buffer, f);
        }
    }

    int iDotCounter = 0;
    char buf[SBUF_SIZE];
    buf[0] = '!';
    DO_WHOLE_DB(i)
    {
        if (mudstate.bStandAlone)
        {
            if (!iDotCounter)
            {
                iDotCounter = 100;
                fputc('.', stderr);
                fflush(stderr);
            }
            iDotCounter--;
        }

        if (!isGarbage(i))
        {
            // Format is: "!%d\n", i
            //
            int n = mux_ltoa(i, buf+1) + 1;
            buf[n++] = '\n';
            fwrite(buf, sizeof(char), n, f);
            db_write_object(f, i, format, flags);
        }
    }
    fputs("***END OF DUMP***\n", f);
    if (mudstate.bStandAlone)
    {
        Log.WriteString(ENDLINE);
        Log.Flush();
    }
    return mudstate.db_top;
}

static bool db_write_object	(	FILE *	f,
		dbref	i,
		int	db_format,
		int	flags
	)			[static]

Definition at line 808 of file db_rw.cpp.

References A_LIST, A_LOCK, A_MONEY, A_NAME, A_USER_START, atr_get, atr_get_raw(), atr_head(), atr_next(), atr_num(), statedata::bStandAlone, Contents, Exits, Flags, Flags2, Flags3, free_boolexp(), free_lbuf, GOD, Link, Location, mudstate, mux_ltoa(), Name, Next, attr::number, Owner, Parent, parse_boolexp(), Pennies(), Powers, Powers2, putboolexp(), putref(), putstring(), SBUF_SIZE, UNUSED_PARAMETER, V_ATRKEY, V_ATRMONEY, V_ATRNAME, V_DATABASE, and Zone.

{
    UNUSED_PARAMETER(db_format);

    ATTR *a;
    char *got, *as;
    dbref aowner;
    int ca, aflags, j;
    BOOLEXP *tempbool;

    if (!(flags & V_ATRNAME))
    {
        putstring(f, Name(i));
    }
    putref(f, Location(i));
    putref(f, Zone(i));
    putref(f, Contents(i));
    putref(f, Exits(i));
    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, true);
        free_lbuf(got);
        putboolexp(f, tempbool);
        if (tempbool)
        {
            free_boolexp(tempbool);
        }
    }
    putref(f, Owner(i));
    putref(f, Parent(i));
    if (!(flags & V_ATRMONEY))
    {
        putref(f, Pennies(i));
    }
    putref(f, Flags(i));
    putref(f, Flags2(i));
    putref(f, Flags3(i));
    putref(f, Powers(i));
    putref(f, Powers2(i));

    // Write the attribute list.
    //
    if (!(flags & V_DATABASE))
    {
        char buf[SBUF_SIZE];
        buf[0] = '>';
        for (ca = atr_head(i, &as); ca; ca = atr_next(&as))
        {
            if (mudstate.bStandAlone)
            {
                j = ca;
            }
            else
            {
                a = atr_num(ca);
                if (!a)
                {
                    continue;
                }
                j = a->number;
            }

            if (j < A_USER_START)
            {
                switch (j)
                {
                case A_NAME:
                    if (!(flags & V_ATRNAME))
                    {
                        continue;
                    }
                    break;

                case A_LOCK:
                    if (!(flags & V_ATRKEY))
                    {
                        continue;
                    }
                    break;

                case A_LIST:
                case A_MONEY:
                    continue;
                }
            }

            // Format is: ">%d\n", j
            //
            const char *p = atr_get_raw(i, j);
            int n = mux_ltoa(j, buf+1) + 1;
            buf[n++] = '\n';
            fwrite(buf, sizeof(char), n, f);
            putstring(f, p);
        }
        fwrite("<\n", sizeof(char), 2, f);
    }
    return false;
}

static bool get_list	(	FILE *	f,
		dbref	i
	)			[static]

Definition at line 332 of file db_rw.cpp.

References alloc_lbuf, atr_add_raw(), ENDLINE, free_lbuf, getref(), getstring_noalloc(), Log, and CLogFile::tinyprintf().

Referenced by db_read().

{
    char *buff = alloc_lbuf("get_list");
    for (;;)
    {
        dbref atr;
        int c;
        switch (c = getc(f))
        {
        case '>':   // read # then string
            atr = getref(f);
            if (atr > 0)
            {
                // Store the attr
                //
                atr_add_raw(i, atr, getstring_noalloc(f, true));
            }
            else
            {
                // Silently discard
                //
                getstring_noalloc(f, true);
            }
            break;

        case '\n':  // ignore newlines. They're due to v(r).

            break;

        case '<':   // end of list

            free_lbuf(buff);
            c = getc(f);
            if (c != '\n')
            {
                ungetc(c, f);
                Log.tinyprintf("No line feed on object %d" ENDLINE, i);
                return true;
            }
            return true;

        default:
            Log.tinyprintf("Bad character '%c' when getting attributes on object %d" ENDLINE, c, i);

            // We've found a bad spot.  I hope things aren't too bad.
            //
            getstring_noalloc(f, true);
        }
    }
}

static BOOLEXP* getboolexp

(

FILE *

f

)

[static]

Definition at line 312 of file db_rw.cpp.

References F_MUX, g_format, getboolexp1(), and mux_assert.

Referenced by db_read().

{
    BOOLEXP *b = getboolexp1(f);
    int c = getc(f);
    mux_assert(c == '\n');

    if (g_format == F_MUX)
    {
        if ((c = getc(f)) != '\n')
        {
            ungetc(c, f);
        }
    }
    return b;
}

static BOOLEXP* getboolexp1

(

FILE *

f

)

[static]

Definition at line 22 of file db_rw.cpp.

References alloc_bool, alloc_lbuf, AND_TOKEN, BOOLEXP_AND, BOOLEXP_ATR, BOOLEXP_CARRY, BOOLEXP_CONST, BOOLEXP_EVAL, BOOLEXP_INDIR, BOOLEXP_IS, BOOLEXP_NOT, BOOLEXP_OR, BOOLEXP_OWNER, CARRY_TOKEN, free_bool, free_lbuf, getstring_noalloc(), GOD, INDIR_TOKEN, IS_TOKEN, LBUF_SIZE, mkattr(), mux_assert, mux_AttrNameInitialSet, mux_isdigit, NOT_TOKEN, OR_TOKEN, OWNER_TOKEN, StringClone(), boolexp::sub1, boolexp::sub2, boolexp::thing, TRUE_BOOLEXP, and boolexp::type.

Referenced by getboolexp().

{
    BOOLEXP *b;
    char *buff, *s;
    int d, anum;

    int c = getc(f);
    switch (c)
    {
    case '\n':
        ungetc(c, f);
        return TRUE_BOOLEXP;

    case EOF:

        // Unexpected EOF in boolexp.
        //
        mux_assert(0);
        break;

    case '(':
        b = alloc_bool("getboolexp1.openparen");
        switch (c = getc(f))
        {
        case NOT_TOKEN:
            b->type = BOOLEXP_NOT;
            b->sub1 = getboolexp1(f);
            if ((d = getc(f)) == '\n')
            {
                d = getc(f);
            }
            if (d != ')')
            {
                goto error;
            }
            return b;

        case INDIR_TOKEN:
            b->type = BOOLEXP_INDIR;
            b->sub1 = getboolexp1(f);
            if ((d = getc(f)) == '\n')
            {
                d = getc(f);
            }
            if (d != ')')
            {
                goto error;
            }
            return b;

        case IS_TOKEN:
            b->type = BOOLEXP_IS;
            b->sub1 = getboolexp1(f);
            if ((d = getc(f)) == '\n')
            {
                d = getc(f);
            }
            if (d != ')')
            {
                goto error;
            }
            return b;

        case CARRY_TOKEN:
            b->type = BOOLEXP_CARRY;
            b->sub1 = getboolexp1(f);
            if ((d = getc(f)) == '\n')
            {
                d = getc(f);
            }
            if (d != ')')
            {
                goto error;
            }
            return b;

        case OWNER_TOKEN:
            b->type = BOOLEXP_OWNER;
            b->sub1 = getboolexp1(f);
            if ((d = getc(f)) == '\n')
            {
                d = getc(f);
            }
            if (d != ')')
            {
                goto error;
            }
            return b;

        default:
            ungetc(c, f);
            b->sub1 = getboolexp1(f);
            if ((c = getc(f)) == '\n')
            {
                c = getc(f);
            }
            switch (c)
            {
            case AND_TOKEN:
                b->type = BOOLEXP_AND;
                break;

            case OR_TOKEN:
                b->type = BOOLEXP_OR;
                break;

            default:
                goto error;
            }
            b->sub2 = getboolexp1(f);
            if ((d = getc(f)) == '\n')
            {
                d = getc(f);
            }
            if (d != ')')
            {
                goto error;
            }
            return b;
        }

    case '-':

        // obsolete NOTHING key, eat it.
        //
        while ((c = getc(f)) != '\n')
        {
            mux_assert(c != EOF);
        }
        ungetc(c, f);
        return TRUE_BOOLEXP;

    case '"':
        ungetc(c, f);
        buff = alloc_lbuf("getboolexp_quoted");
        strcpy(buff, getstring_noalloc(f, 1));
        c = fgetc(f);
        if (c == EOF)
        {
            free_lbuf(buff);
            return TRUE_BOOLEXP;
        }

        b = alloc_bool("getboolexp1_quoted");
        anum = mkattr(GOD, buff);
        if (anum <= 0)
        {
            free_bool(b);
            free_lbuf(buff);
            goto error;
        }
        free_lbuf(buff);
        b->thing = anum;

        // If last character is : then this is an attribute lock. A
        // last character of / means an eval lock.
        //
        if (  c == ':'
           || c == '/')
        {
            if (c == '/')
            {
                b->type = BOOLEXP_EVAL;
            }
            else
            {
                b->type = BOOLEXP_ATR;
            }
            buff = alloc_lbuf("getboolexp1.attr_lock");
            strcpy(buff, getstring_noalloc(f, 1));
            b->sub1 = (BOOLEXP *)StringClone(buff);
            free_lbuf(buff);
        }
        return b;

    default: // dbref or attribute.

        ungetc(c, f);
        b = alloc_bool("getboolexp1.default");
        b->type = BOOLEXP_CONST;
        b->thing = 0;

        // This is either an attribute, eval, or constant lock. Constant locks
        // are of the form <num>, while attribute and eval locks are of the
        // form <anam-or-anum>:<string> or <aname-or-anum>/<string>
        // respectively. The characters <nl>, |, and & terminate the string.
        //
        if (mux_isdigit(c))
        {
            while (mux_isdigit(c = getc(f)))
            {
                b->thing = b->thing * 10 + c - '0';
            }
        }
        else if (mux_AttrNameInitialSet(c))
        {
            buff = alloc_lbuf("getboolexp1.atr_name");

            for (  s = buff;

                   (c = getc(f)) != EOF
                && c != '\n'
                && c != ':'
                && c != '/'
                && s < buff + LBUF_SIZE;

                   *s++ = (char)c)
            {
                ; // Nothing.
            }

            if (c == EOF)
            {
                free_lbuf(buff);
                free_bool(b);
                goto error;
            }
            *s = '\0';

            // Look the name up as an attribute. If not found, create a new
            // attribute.
            //
            anum = mkattr(GOD, buff);
            if (anum <= 0)
            {
                free_bool(b);
                free_lbuf(buff);
                goto error;
            }
            free_lbuf(buff);
            b->thing = anum;
        }
        else
        {
            free_bool(b);
            goto error;
        }

        // If last character is : then this is an attribute lock. A last
        // character of / means an eval lock.
        //
        if (  c == ':'
           || c == '/')
        {
            if (c == '/')
            {
                b->type = BOOLEXP_EVAL;
            }
            else
            {
                b->type = BOOLEXP_ATR;
            }
            buff = alloc_lbuf("getboolexp1.attr_lock");
            for (  s = buff;

                   (c = getc(f)) != EOF
                && c != '\n'
                && c != ')'
                && c != OR_TOKEN
                && c != AND_TOKEN
                && s < buff + LBUF_SIZE;

                   *s++ = (char)c)
            {
                ; // Nothing
            }
            if (c == EOF)
            {
                goto error;
            }
            *s++ = 0;
            b->sub1 = (BOOLEXP *)StringClone(buff);
            free_lbuf(buff);
        }
        ungetc(c, f);
        return b;
    }

error:

    // Bomb Out.
    //
    mux_assert(0);
    return TRUE_BOOLEXP;
}

static void putbool_subexp	(	FILE *	f,
		BOOLEXP *	b
	)			[static]

Definition at line 386 of file db_rw.cpp.

References AND_TOKEN, atr_num(), BOOLEXP_AND, BOOLEXP_ATR, BOOLEXP_CARRY, BOOLEXP_CONST, BOOLEXP_EVAL, BOOLEXP_INDIR, BOOLEXP_IS, BOOLEXP_NOT, BOOLEXP_OR, BOOLEXP_OWNER, CARRY_TOKEN, ENDLINE, INDIR_TOKEN, IS_TOKEN, Log, attr::name, NOT_TOKEN, OR_TOKEN, OWNER_TOKEN, putref(), boolexp::sub1, boolexp::sub2, boolexp::thing, CLogFile::tinyprintf(), and boolexp::type.

Referenced by putboolexp().

{
    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:

        putref(f, 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:

        Log.tinyprintf("Unknown boolean type in putbool_subexp: %d" ENDLINE, b->type);
        break;
    }
}

static void putboolexp	(	FILE *	f,
		BOOLEXP *	b
	)			[static]

Definition at line 492 of file db_rw.cpp.

References putbool_subexp(), and TRUE_BOOLEXP.

Referenced by db_write_object().

{
    if (b != TRUE_BOOLEXP)
    {
        putbool_subexp(f, b);
    }
    putc('\n', f);
}

---

Variable Documentation

int g_flags [static]

Definition at line 16 of file db_rw.cpp.

Referenced by db_read().

int g_format [static]

Definition at line 15 of file db_rw.cpp.

Referenced by db_read(), and getboolexp().

int g_version [static]

Definition at line 14 of file db_rw.cpp.

Referenced by db_read().

---