src/db_xml.c File Reference

#include "copyright.h"
#include "config.h"
#include <sys/file.h>
#include "mudconf.h"
#include "externs.h"
#include "db.h"
#include "vattr.h"
#include "attrs.h"
#include "alloc.h"
#include "powers.h"

Include dependency graph for db_xml.c:

Go to the source code of this file.

Defines
#define	MUX_REPRESENTATION
Functions
const char *	getstring_noalloc (FILE *, int)
void	putstring (FILE *, const char *)
void	db_grow (dbref)
static int	xml_putescaped (FILE *f, const char *string)
static int	xml_putobjstring (FILE *f, const char *name, const char *value)
static int	xml_putobjref (FILE *f, const char *name, long value)
static int	xml_putattr (FILE *f, const char *name, const char *value, long owner, long flags)
static int	xml_db_write_object (FILE *f, dbref i, int db_format, int flags)
static int	xml_db_write_mux (FILE *f, dbref i, int db_format, int flags)
dbref	xml_db_write (FILE *f, int format, int version)
Variables
object *	db
static int	g_version
static int	g_format
static int	g_flags

---

Define Documentation

#define MUX_REPRESENTATION

Definition at line 19 of file db_xml.c.

---

Function Documentation

void db_grow

(

dbref

)

Definition at line 1609 of file db.c.

References confdata::cache_names, flatfiledb::db, statedata::db_size, statedata::db_top, GOD, GOING, confdata::init_size, initialize_objects(), LOG_ALWAYS, LOG_SIMPLE, statedata::markbits, statedata::min_size, mudconf, mudstate, NOTHING, purenames, s_Contents, s_Exits, s_Flags, s_Link, s_Location, s_Next, s_Owner, s_Parent, s_Powers, s_Powers2, s_Stack, s_Zone, SIZE_HACK, tprintf(), TYPE_GARBAGE, XFREE, and XMALLOC.

Referenced by create_obj(), db_make_minimal(), db_read(), and mmdb_db_read().

{
        int newsize, marksize, delta, i;
        MARKBUF *newmarkbuf;
        OBJ *newdb;
        NAME *newpurenames;

        char *cp;

        delta = mudconf.init_size;

        /*
         * Determine what to do based on requested size, current top and  * * 
         * 
         * *  * *  * *  * * size.  Make sure we grow in reasonable-sized
         * chunks to * * prevent *  * *  * frequent reallocations of the db
         * array. 
         */

        /*
         * If requested size is smaller than the current db size, ignore it 
         */

        if(newtop <= mudstate.db_top) {
                return;
        }
        /*
         * If requested size is greater than the current db size but smaller
         * * * * * * * than the amount of space we have allocated, raise the
         * db  * *  * size * * and * initialize the new area. 
         */

        if(newtop <= mudstate.db_size) {
                for(i = mudstate.db_top; i < newtop; i++) {
                        if(mudconf.cache_names)
                                purenames[i] = NULL;
                }
                initialize_objects(mudstate.db_top, newtop);
                mudstate.db_top = newtop;
                return;
        }
        /*
         * Grow by a minimum of delta objects 
         */

        if(newtop <= mudstate.db_size + delta) {
                newsize = mudstate.db_size + delta;
        } else {
                newsize = newtop;
        }

        /*
         * Enforce minimumdatabase size 
         */

        if(newsize < mudstate.min_size)
                newsize = mudstate.min_size + delta;;

        /*
         * Grow the name tables 
         */

        if(mudconf.cache_names) {
                newpurenames =
                        (NAME *) XMALLOC((newsize + SIZE_HACK) * sizeof(NAME),
                                                         "db_grow.purenames");

                if(!newpurenames) {
                        LOG_SIMPLE(LOG_ALWAYS, "ALC", "DB",
                                           tprintf
                                           ("Could not allocate space for %d item name cache.",
                                                newsize));
                        abort();
                }
                bzero((char *) newpurenames, (newsize + SIZE_HACK) * sizeof(NAME));

                if(purenames) {

                        /*
                         * An old name cache exists.  Copy it. 
                         */

                        purenames -= SIZE_HACK;
                        bcopy((char *) purenames, (char *) newpurenames,
                                  (newtop + SIZE_HACK) * sizeof(NAME));
                        cp = (char *) purenames;
                        XFREE(cp, "db_grow.purename");
                } else {

                        /*
                         * Creating a brand new struct database.  Fill in the
                         * 'reserved' area in case it gets referenced.  
                         */

                        purenames = newpurenames;
                        for(i = 0; i < SIZE_HACK; i++) {
                                purenames[i] = NULL;
                        }
                }
                purenames = newpurenames + SIZE_HACK;
                newpurenames = NULL;
        }
        /*
         * Grow the db array 
         */

        newdb = (OBJ *)
                XMALLOC((newsize + SIZE_HACK) * sizeof(OBJ), "db_grow.db");
        if(!newdb) {

                LOG_SIMPLE(LOG_ALWAYS, "ALC", "DB",
                                   tprintf
                                   ("Could not allocate space for %d item struct database.",
                                        newsize));
                abort();
        }
        if(db) {

                /*
                 * An old struct database exists.  Copy it to the new buffer 
                 */

                db -= SIZE_HACK;
                bcopy((char *) db, (char *) newdb,
                          (mudstate.db_top + SIZE_HACK) * sizeof(OBJ));
                cp = (char *) db;
                XFREE(cp, "db_grow.db");
        } else {

                /*
                 * Creating a brand new struct database.  Fill in the * * * * 
                 * 
                 * *  * * 'reserved' area in case it gets referenced. 
                 */

                db = newdb;
                for(i = 0; i < SIZE_HACK; i++) {
                        s_Owner(i, GOD);
                        s_Flags(i, (TYPE_GARBAGE | GOING));
                        s_Powers(i, 0);
                        s_Powers2(i, 0);
                        s_Location(i, NOTHING);
                        s_Contents(i, NOTHING);
                        s_Exits(i, NOTHING);
                        s_Link(i, NOTHING);
                        s_Next(i, NOTHING);
                        s_Zone(i, NOTHING);
                        s_Parent(i, NOTHING);
                        s_Stack(i, NULL);
                        db[i].ahead = NULL;
                        db[i].at_count = 0;
                }
        }
        db = newdb + SIZE_HACK;
        newdb = NULL;

        for(i = mudstate.db_top; i < newtop; i++) {
                if(mudconf.cache_names) {
                        purenames[i] = NULL;
                }
        }
        initialize_objects(mudstate.db_top, newtop);
        mudstate.db_top = newtop;
        mudstate.db_size = newsize;

        /*
         * Grow the db mark buffer 
         */

        marksize = (newsize + 7) >> 3;
        newmarkbuf = (MARKBUF *) XMALLOC(marksize, "db_grow");
        bzero((char *) newmarkbuf, marksize);
        if(mudstate.markbits) {
                marksize = (newtop + 7) >> 3;
                bcopy((char *) mudstate.markbits, (char *) newmarkbuf, marksize);
                cp = (char *) mudstate.markbits;
                XFREE(cp, "db_grow");
        }
        mudstate.markbits = newmarkbuf;
}

const char* getstring_noalloc	(	FILE *	,
		int
	)

Definition at line 1885 of file db.c.

{
        static char buf[LBUF_SIZE];
        char *p;
        int c, lastc;

        p = buf;
        c = fgetc(f);
        if(!new_strings || (c != '"')) {
                ungetc(c, f);
                c = '\0';
                for(;;) {
                        lastc = c;
                        c = fgetc(f);

                        /*
                         * If EOF or null, return 
                         */

                        if(!c || (c == EOF)) {
                                *p = '\0';
                                return buf;
                        }
                        /*
                         * If a newline, return if prior char is not a cr. *
                         * * * Otherwise * keep on truckin' 
                         */

                        if((c == '\n') && (lastc != '\r')) {
                                *p = '\0';
                                return buf;
                        }
                        safe_chr(c, buf, &p);
                }
        } else {
                for(;;) {
                        c = fgetc(f);
                        if(c == '"') {
                                if((c = fgetc(f)) != '\n')
                                        ungetc(c, f);
                                *p = '\0';
                                return buf;
                        } else if(c == '\\') {
                                c = fgetc(f);
                        }
                        if((c == '\0') || (c == EOF)) {
                                *p = '\0';
                                return buf;
                        }
                        safe_chr(c, buf, &p);
                }
        }
}

void putstring	(	FILE *	,
		const char *
	)

Definition at line 1867 of file db.c.

{
        putc('"', f);

        while (s && *s) {
                switch (*s) {
                case '\\':
                case '"':
                        putc('\\', f);
                default:
                        putc(*s, f);
                }
                s++;
        }
        putc('"', f);
        putc('\n', f);
}

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

Definition at line 234 of file db_xml.c.

References statedata::db_top, DO_WHOLE_DB, object::flags, Going, mudstate, statedata::now, xml_db_write_mux(), and xml_db_write_object().

{
        dbref i;
        int flags;
        VATTR *vp;

        fprintf(f, "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n");
        fprintf(f, "<TinyMUXDataBase dumptime=\"%lu\">\n", mudstate.now);
        DO_WHOLE_DB(i) {
                if(!(Going(i))) {
#ifdef MUX_REPRESENTATION
                        xml_db_write_mux(f, i, format, flags);
#else
                        xml_db_write_object(f, i, format, flags);
#endif
                }
        }
        fprintf(f, "</TinyMUXDataBase>\n");
        fflush(f);
        return (mudstate.db_top);
}

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

Definition at line 172 of file db_xml.c.

References A_LIST, A_LOCK, A_MONEY, A_NAME, atr_get(), atr_head(), atr_next(), atr_num(), Contents, Exits, Flags, Flags2, Flags3, free_lbuf, Link, Location, attr::name, Name(), attr::number, Owner, Parent, Pennies(), Powers, Powers2, V_ATRKEY, V_ATRNAME, xml_putattr(), xml_putobjref(), xml_putobjstring(), and Zone.

Referenced by xml_db_write().

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

        fprintf(f, "\t<Object dbref=\"%ld\">\n", (long) i);
        xml_putobjstring(f, "Name", Name(i));
        xml_putobjref(f, "Location", Location(i));
        xml_putobjref(f, "Zone", Zone(i));
        xml_putobjref(f, "Contents", Contents(i));
        xml_putobjref(f, "Exits", Exits(i));
        got = atr_get(i, A_LOCK, &aowner, &aflags);
        xml_putobjstring(f, "Lock", got);
        free_lbuf(got);

        xml_putobjref(f, "Link", Link(i));
        xml_putobjref(f, "Owner", Owner(i));
        xml_putobjref(f, "Parent", Parent(i));
        xml_putobjref(f, "Pennies", Pennies(i));
        xml_putobjref(f, "Flags", Flags(i));
        xml_putobjref(f, "Flags2", Flags2(i));
        xml_putobjref(f, "Flags3", Flags3(i));
        xml_putobjref(f, "Powers", Powers(i));
        xml_putobjref(f, "Powers2", Powers2(i));
        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(i, j, &aowner, &aflags);
                        xml_putattr(f, a->name, got, aowner, aflags);
                }
        }
        fprintf(f, "\t</Object>\n");
        return 0;
}

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

Definition at line 89 of file db_xml.c.

References A_LIST, A_LOCK, A_MONEY, A_NAME, atr_get(), atr_head(), atr_next(), atr_num(), Contents, Exits, Flags, Flags2, Flags3, free_lbuf, Link, Location, attr::name, Name(), Next, attr::number, Owner, Parent, Pennies(), Powers, Powers2, V_ATRKEY, V_ATRNAME, xml_putattr(), xml_putobjref(), xml_putobjstring(), and Zone.

Referenced by xml_db_write().

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

        fprintf(f, "\t<Object dbref=\"%ld\">\n", (long) i);
        xml_putobjstring(f, "Name", Name(i));
        xml_putobjref(f, "Location", Location(i));
        xml_putobjref(f, "Zone", Zone(i));
        if(Contents(i) == -1) {
                fprintf(f, "\t\t<Contents/>\n");
        } else {
                fprintf(f, "\t\t<Contents>\n");
                sub = Contents(i);
                while (sub != -1) {
                        fprintf(f, "\t\t\t<DBREF dbref=\"%ld\"/>\n", sub);
                        sub = Next(sub);
                }
                fprintf(f, "\t\t</Contents>\n");
        }
        if(Exits(i) == -1) {
                fprintf(f, "\t\t<Exits/>\n");
        } else {
                fprintf(f, "\t\t<Exits>\n");
                sub = Exits(i);
                while (sub != -1) {
                        fprintf(f, "\t\t\t<DBREF dbref=\"%ld\"/>\n", sub);
                        sub = Next(sub);
                }
                fprintf(f, "\t\t</Exits>\n");
        }
        got = atr_get(i, A_LOCK, &aowner, &aflags);
        xml_putobjstring(f, "Lock", got);
        free_lbuf(got);

        xml_putobjref(f, "Link", Link(i));
        xml_putobjref(f, "Owner", Owner(i));
        xml_putobjref(f, "Parent", Parent(i));
        xml_putobjref(f, "Pennies", Pennies(i));
        xml_putobjref(f, "Flags", Flags(i));
        xml_putobjref(f, "Flags2", Flags2(i));
        xml_putobjref(f, "Flags3", Flags3(i));
        xml_putobjref(f, "Powers", Powers(i));
        xml_putobjref(f, "Powers2", Powers2(i));

        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(i, j, &aowner, &aflags);
                        xml_putattr(f, a->name, got, aowner, aflags);
                }
        }
        fprintf(f, "\t</Object>\n");
        return 0;
}

static int xml_putattr	(	FILE *	f,
		const char *	name,
		const char *	value,
		long	owner,
		long	flags
	)			[static]

Definition at line 78 of file db_xml.c.

References xml_putescaped().

Referenced by xml_db_write_mux(), and xml_db_write_object().

{
        fprintf(f, "\t\t<Attribute name=\"");
        xml_putescaped(f, name);
        fprintf(f, "\" owner=\"%ld\" flags=\"%ld\">", owner, flags);
        xml_putescaped(f, value);
        fprintf(f, "</Attribute>\n");
        return 1;
}

static int xml_putescaped	(	FILE *	f,
		const char *	string
	)			[static]

Definition at line 32 of file db_xml.c.

References LBUF_SIZE.

Referenced by xml_putattr(), and xml_putobjstring().

{
        char emit_buffer[LBUF_SIZE * 7];
        char *r, *s;
        s = emit_buffer;
        memset(emit_buffer, 0, sizeof(emit_buffer));
        for(r = (char *)string; *r; r++) {
                switch (*r) {
                case '"':
                        s = stpcpy(s, """);
                        break;
                case '\'':
                        s = stpcpy(s, "'");
                        break;
                case '&':
                        s = stpcpy(s, "&");
                case '<':
                        s = stpcpy(s, "&lt;");
                        break;
                case '>':
                        s = stpcpy(s, "&gt;");
                        break;
                case '\\':
                        s = stpcpy(s, "\\\\");
                        break;
                default:
                        *s++ = *r;
                }
        }
        *s = '\0';
        return fprintf(f, "%s", emit_buffer);
}

static int xml_putobjref	(	FILE *	f,
		const char *	name,
		long	value
	)			[static]

Definition at line 73 of file db_xml.c.

Referenced by xml_db_write_mux(), and xml_db_write_object().

{
        return fprintf(f, "\t\t<%s>%ld</%s>\n", name, value, name);
}

static int xml_putobjstring	(	FILE *	f,
		const char *	name,
		const char *	value
	)			[static]

Definition at line 65 of file db_xml.c.

References xml_putescaped().

Referenced by xml_db_write_mux(), and xml_db_write_object().

{
        fprintf(f, "\t\t<%s>", name);
        xml_putescaped(f, value);
        fprintf(f, "</%s>\n", name);
        return 1;
}

---

Variable Documentation

struct object* db

Definition at line 38 of file db.c.

int g_flags [static]

Definition at line 30 of file db_xml.c.

int g_format [static]

Definition at line 29 of file db_xml.c.

int g_version [static]

Definition at line 28 of file db_xml.c.

---