common.c

Go to the documentation of this file.

/*
===========================================================================
Copyright (C) 1999-2005 Id Software, Inc.

This file is part of Quake III Arena source code.

Quake III Arena source code is free software; you can redistribute it
and/or modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the License,
or (at your option) any later version.

Quake III Arena source code is distributed in the hope that it will be
useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Foobar; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
===========================================================================
*/
// common.c -- misc functions used in client and server

#include "../game/q_shared.h"
#include "qcommon.h"
#include <setjmp.h>
#ifdef __linux__
#include <netinet/in.h>
#else
#if defined(MACOS_X)
#include <netinet/in.h>
#else
#include <winsock.h>
#endif
#endif

int demo_protocols[] =
{ 66, 67, 68, 0 };

#define MAX_NUM_ARGVS   50

#define MIN_DEDICATED_COMHUNKMEGS 1
#define MIN_COMHUNKMEGS 56
#ifdef MACOS_X
#define DEF_COMHUNKMEGS "64"
#define DEF_COMZONEMEGS "24"
#else
#define DEF_COMHUNKMEGS "56"
#define DEF_COMZONEMEGS "16"
#endif

int     com_argc;
char    *com_argv[MAX_NUM_ARGVS+1];

jmp_buf abortframe;     // an ERR_DROP occured, exit the entire frame


FILE *debuglogfile;
static fileHandle_t logfile;
fileHandle_t    com_journalFile;            // events are written here
fileHandle_t    com_journalDataFile;        // config files are written here

cvar_t  *com_viewlog;
cvar_t  *com_speeds;
cvar_t  *com_developer;
cvar_t  *com_dedicated;
cvar_t  *com_timescale;
cvar_t  *com_fixedtime;
cvar_t  *com_dropsim;       // 0.0 to 1.0, simulated packet drops
cvar_t  *com_journal;
cvar_t  *com_maxfps;
cvar_t  *com_timedemo;
cvar_t  *com_sv_running;
cvar_t  *com_cl_running;
cvar_t  *com_logfile;       // 1 = buffer log, 2 = flush after each print
cvar_t  *com_showtrace;
cvar_t  *com_version;
cvar_t  *com_blood;
cvar_t  *com_buildScript;   // for automated data building scripts
cvar_t  *com_introPlayed;
cvar_t  *cl_paused;
cvar_t  *sv_paused;
cvar_t  *com_cameraMode;
#if defined(_WIN32) && defined(_DEBUG)
cvar_t  *com_noErrorInterrupt;
#endif

// com_speeds times
int     time_game;
int     time_frontend;      // renderer frontend time
int     time_backend;       // renderer backend time

int         com_frameTime;
int         com_frameMsec;
int         com_frameNumber;

qboolean    com_errorEntered;
qboolean    com_fullyInitialized;

char    com_errorMessage[MAXPRINTMSG];

void Com_WriteConfig_f( void );
void CIN_CloseAllVideos();

//============================================================================

static char *rd_buffer;
static int  rd_buffersize;
static void (*rd_flush)( char *buffer );

void Com_BeginRedirect (char *buffer, int buffersize, void (*flush)( char *) )
{
    if (!buffer || !buffersize || !flush)
        return;
    rd_buffer = buffer;
    rd_buffersize = buffersize;
    rd_flush = flush;

    *rd_buffer = 0;
}

void Com_EndRedirect (void)
{
    if ( rd_flush ) {
        rd_flush(rd_buffer);
    }

    rd_buffer = NULL;
    rd_buffersize = 0;
    rd_flush = NULL;
}

/*
=============
Com_Printf

Both client and server can use this, and it will output
to the apropriate place.

A raw string should NEVER be passed as fmt, because of "%f" type crashers.
=============
*/
void QDECL Com_Printf( const char *fmt, ... ) {
    va_list     argptr;
    char        msg[MAXPRINTMSG];
  static qboolean opening_qconsole = qfalse;

    va_start (argptr,fmt);
    Q_vsnprintf (msg, sizeof(msg), fmt, argptr);
    va_end (argptr);

    if ( rd_buffer ) {
        if ((strlen (msg) + strlen(rd_buffer)) > (rd_buffersize - 1)) {
            rd_flush(rd_buffer);
            *rd_buffer = 0;
        }
        Q_strcat(rd_buffer, rd_buffersize, msg);
    // TTimo nooo .. that would defeat the purpose
        //rd_flush(rd_buffer);          
        //*rd_buffer = 0;
        return;
    }

    // echo to console if we're not a dedicated server
    if ( com_dedicated && !com_dedicated->integer ) {
        CL_ConsolePrint( msg );
    }

    // echo to dedicated console and early console
    Sys_Print( msg );

    // logfile
    if ( com_logfile && com_logfile->integer ) {
    // TTimo: only open the qconsole.log if the filesystem is in an initialized state
    //   also, avoid recursing in the qconsole.log opening (i.e. if fs_debug is on)
        if ( !logfile && FS_Initialized() && !opening_qconsole) {
            struct tm *newtime;
            time_t aclock;

      opening_qconsole = qtrue;

            time( &aclock );
            newtime = localtime( &aclock );

            logfile = FS_FOpenFileWrite( "qconsole.log" );
            Com_Printf( "logfile opened on %s\n", asctime( newtime ) );
            if ( com_logfile->integer > 1 ) {
                // force it to not buffer so we get valid
                // data even if we are crashing
                FS_ForceFlush(logfile);
            }

      opening_qconsole = qfalse;
        }
        if ( logfile && FS_Initialized()) {
            FS_Write(msg, strlen(msg), logfile);
        }
    }
}


/*
================
Com_DPrintf

A Com_Printf that only shows up if the "developer" cvar is set
================
*/
void QDECL Com_DPrintf( const char *fmt, ...) {
    va_list     argptr;
    char        msg[MAXPRINTMSG];
        
    if ( !com_developer || !com_developer->integer ) {
        return;         // don't confuse non-developers with techie stuff...
    }

    va_start (argptr,fmt);  
    Q_vsnprintf (msg, sizeof(msg), fmt, argptr);
    va_end (argptr);
    
    Com_Printf ("%s", msg);
}

/*
=============
Com_Error

Both client and server can use this, and it will
do the apropriate things.
=============
*/
void QDECL Com_Error( int code, const char *fmt, ... ) {
    va_list     argptr;
    static int  lastErrorTime;
    static int  errorCount;
    int         currentTime;

#if defined(_WIN32) && defined(_DEBUG)
    if ( code != ERR_DISCONNECT && code != ERR_NEED_CD ) {
        if (!com_noErrorInterrupt->integer) {
            __asm {
                int 0x03
            }
        }
    }
#endif

    // when we are running automated scripts, make sure we
    // know if anything failed
    if ( com_buildScript && com_buildScript->integer ) {
        code = ERR_FATAL;
    }

    // make sure we can get at our local stuff
    FS_PureServerSetLoadedPaks( "", "" );

    // if we are getting a solid stream of ERR_DROP, do an ERR_FATAL
    currentTime = Sys_Milliseconds();
    if ( currentTime - lastErrorTime < 100 ) {
        if ( ++errorCount > 3 ) {
            code = ERR_FATAL;
        }
    } else {
        errorCount = 0;
    }
    lastErrorTime = currentTime;

    if ( com_errorEntered ) {
        Sys_Error( "recursive error after: %s", com_errorMessage );
    }
    com_errorEntered = qtrue;

    va_start (argptr,fmt);
    vsprintf (com_errorMessage,fmt,argptr);
    va_end (argptr);

    if ( code != ERR_DISCONNECT && code != ERR_NEED_CD ) {
        Cvar_Set("com_errorMessage", com_errorMessage);
    }

    if ( code == ERR_SERVERDISCONNECT ) {
        CL_Disconnect( qtrue );
        CL_FlushMemory( );
        com_errorEntered = qfalse;
        longjmp (abortframe, -1);
    } else if ( code == ERR_DROP || code == ERR_DISCONNECT ) {
        Com_Printf ("********************\nERROR: %s\n********************\n", com_errorMessage);
        SV_Shutdown (va("Server crashed: %s\n",  com_errorMessage));
        CL_Disconnect( qtrue );
        CL_FlushMemory( );
        com_errorEntered = qfalse;
        longjmp (abortframe, -1);
    } else if ( code == ERR_NEED_CD ) {
        SV_Shutdown( "Server didn't have CD\n" );
        if ( com_cl_running && com_cl_running->integer ) {
            CL_Disconnect( qtrue );
            CL_FlushMemory( );
            com_errorEntered = qfalse;
            CL_CDDialog();
        } else {
            Com_Printf("Server didn't have CD\n" );
        }
        longjmp (abortframe, -1);
    } else {
        CL_Shutdown ();
        SV_Shutdown (va("Server fatal crashed: %s\n", com_errorMessage));
    }

    Com_Shutdown ();

    Sys_Error ("%s", com_errorMessage);
}


/*
=============
Com_Quit_f

Both client and server can use this, and it will
do the apropriate things.
=============
*/
void Com_Quit_f( void ) {
    // don't try to shutdown if we are in a recursive error
    if ( !com_errorEntered ) {
        SV_Shutdown ("Server quit\n");
        CL_Shutdown ();
        Com_Shutdown ();
        FS_Shutdown(qtrue);
    }
    Sys_Quit ();
}



/*
============================================================================

COMMAND LINE FUNCTIONS

+ characters seperate the commandLine string into multiple console
command lines.

All of these are valid:

quake3 +set test blah +map test
quake3 set test blah+map test
quake3 set test blah + map test

============================================================================
*/

#define MAX_CONSOLE_LINES   32
int     com_numConsoleLines;
char    *com_consoleLines[MAX_CONSOLE_LINES];

/*
==================
Com_ParseCommandLine

Break it up into multiple console lines
==================
*/
void Com_ParseCommandLine( char *commandLine ) {
    int inq = 0;
    com_consoleLines[0] = commandLine;
    com_numConsoleLines = 1;

    while ( *commandLine ) {
        if (*commandLine == '"') {
            inq = !inq;
        }
        // look for a + seperating character
        // if commandLine came from a file, we might have real line seperators
        if ( (*commandLine == '+' && !inq) || *commandLine == '\n'  || *commandLine == '\r' ) {
            if ( com_numConsoleLines == MAX_CONSOLE_LINES ) {
                return;
            }
            com_consoleLines[com_numConsoleLines] = commandLine + 1;
            com_numConsoleLines++;
            *commandLine = 0;
        }
        commandLine++;
    }
}


/*
===================
Com_SafeMode

Check for "safe" on the command line, which will
skip loading of q3config.cfg
===================
*/
qboolean Com_SafeMode( void ) {
    int     i;

    for ( i = 0 ; i < com_numConsoleLines ; i++ ) {
        Cmd_TokenizeString( com_consoleLines[i] );
        if ( !Q_stricmp( Cmd_Argv(0), "safe" )
            || !Q_stricmp( Cmd_Argv(0), "cvar_restart" ) ) {
            com_consoleLines[i][0] = 0;
            return qtrue;
        }
    }
    return qfalse;
}


/*
===============
Com_StartupVariable

Searches for command line parameters that are set commands.
If match is not NULL, only that cvar will be looked for.
That is necessary because cddir and basedir need to be set
before the filesystem is started, but all other sets shouls
be after execing the config and default.
===============
*/
void Com_StartupVariable( const char *match ) {
    int     i;
    char    *s;
    cvar_t  *cv;

    for (i=0 ; i < com_numConsoleLines ; i++) {
        Cmd_TokenizeString( com_consoleLines[i] );
        if ( strcmp( Cmd_Argv(0), "set" ) ) {
            continue;
        }

        s = Cmd_Argv(1);
        if ( !match || !strcmp( s, match ) ) {
            Cvar_Set( s, Cmd_Argv(2) );
            cv = Cvar_Get( s, "", 0 );
            cv->flags |= CVAR_USER_CREATED;
//          com_consoleLines[i] = 0;
        }
    }
}


/*
=================
Com_AddStartupCommands

Adds command line parameters as script statements
Commands are seperated by + signs

Returns qtrue if any late commands were added, which
will keep the demoloop from immediately starting
=================
*/
qboolean Com_AddStartupCommands( void ) {
    int     i;
    qboolean    added;

    added = qfalse;
    // quote every token, so args with semicolons can work
    for (i=0 ; i < com_numConsoleLines ; i++) {
        if ( !com_consoleLines[i] || !com_consoleLines[i][0] ) {
            continue;
        }

        // set commands won't override menu startup
        if ( Q_stricmpn( com_consoleLines[i], "set", 3 ) ) {
            added = qtrue;
        }
        Cbuf_AddText( com_consoleLines[i] );
        Cbuf_AddText( "\n" );
    }

    return added;
}


//============================================================================

void Info_Print( const char *s ) {
    char    key[512];
    char    value[512];
    char    *o;
    int     l;

    if (*s == '\\')
        s++;
    while (*s)
    {
        o = key;
        while (*s && *s != '\\')
            *o++ = *s++;

        l = o - key;
        if (l < 20)
        {
            Com_Memset (o, ' ', 20-l);
            key[20] = 0;
        }
        else
            *o = 0;
        Com_Printf ("%s", key);

        if (!*s)
        {
            Com_Printf ("MISSING VALUE\n");
            return;
        }

        o = value;
        s++;
        while (*s && *s != '\\')
            *o++ = *s++;
        *o = 0;

        if (*s)
            s++;
        Com_Printf ("%s\n", value);
    }
}

/*
============
Com_StringContains
============
*/
char *Com_StringContains(char *str1, char *str2, int casesensitive) {
    int len, i, j;

    len = strlen(str1) - strlen(str2);
    for (i = 0; i <= len; i++, str1++) {
        for (j = 0; str2[j]; j++) {
            if (casesensitive) {
                if (str1[j] != str2[j]) {
                    break;
                }
            }
            else {
                if (toupper(str1[j]) != toupper(str2[j])) {
                    break;
                }
            }
        }
        if (!str2[j]) {
            return str1;
        }
    }
    return NULL;
}

/*
============
Com_Filter
============
*/
int Com_Filter(char *filter, char *name, int casesensitive)
{
    char buf[MAX_TOKEN_CHARS];
    char *ptr;
    int i, found;

    while(*filter) {
        if (*filter == '*') {
            filter++;
            for (i = 0; *filter; i++) {
                if (*filter == '*' || *filter == '?') break;
                buf[i] = *filter;
                filter++;
            }
            buf[i] = '\0';
            if (strlen(buf)) {
                ptr = Com_StringContains(name, buf, casesensitive);
                if (!ptr) return qfalse;
                name = ptr + strlen(buf);
            }
        }
        else if (*filter == '?') {
            filter++;
            name++;
        }
        else if (*filter == '[' && *(filter+1) == '[') {
            filter++;
        }
        else if (*filter == '[') {
            filter++;
            found = qfalse;
            while(*filter && !found) {
                if (*filter == ']' && *(filter+1) != ']') break;
                if (*(filter+1) == '-' && *(filter+2) && (*(filter+2) != ']' || *(filter+3) == ']')) {
                    if (casesensitive) {
                        if (*name >= *filter && *name <= *(filter+2)) found = qtrue;
                    }
                    else {
                        if (toupper(*name) >= toupper(*filter) &&
                            toupper(*name) <= toupper(*(filter+2))) found = qtrue;
                    }
                    filter += 3;
                }
                else {
                    if (casesensitive) {
                        if (*filter == *name) found = qtrue;
                    }
                    else {
                        if (toupper(*filter) == toupper(*name)) found = qtrue;
                    }
                    filter++;
                }
            }
            if (!found) return qfalse;
            while(*filter) {
                if (*filter == ']' && *(filter+1) != ']') break;
                filter++;
            }
            filter++;
            name++;
        }
        else {
            if (casesensitive) {
                if (*filter != *name) return qfalse;
            }
            else {
                if (toupper(*filter) != toupper(*name)) return qfalse;
            }
            filter++;
            name++;
        }
    }
    return qtrue;
}

/*
============
Com_FilterPath
============
*/
int Com_FilterPath(char *filter, char *name, int casesensitive)
{
    int i;
    char new_filter[MAX_QPATH];
    char new_name[MAX_QPATH];

    for (i = 0; i < MAX_QPATH-1 && filter[i]; i++) {
        if ( filter[i] == '\\' || filter[i] == ':' ) {
            new_filter[i] = '/';
        }
        else {
            new_filter[i] = filter[i];
        }
    }
    new_filter[i] = '\0';
    for (i = 0; i < MAX_QPATH-1 && name[i]; i++) {
        if ( name[i] == '\\' || name[i] == ':' ) {
            new_name[i] = '/';
        }
        else {
            new_name[i] = name[i];
        }
    }
    new_name[i] = '\0';
    return Com_Filter(new_filter, new_name, casesensitive);
}

/*
============
Com_HashKey
============
*/
int Com_HashKey(char *string, int maxlen) {
    int register hash, i;

    hash = 0;
    for (i = 0; i < maxlen && string[i] != '\0'; i++) {
        hash += string[i] * (119 + i);
    }
    hash = (hash ^ (hash >> 10) ^ (hash >> 20));
    return hash;
}

/*
================
Com_RealTime
================
*/
int Com_RealTime(qtime_t *qtime) {
    time_t t;
    struct tm *tms;

    t = time(NULL);
    if (!qtime)
        return t;
    tms = localtime(&t);
    if (tms) {
        qtime->tm_sec = tms->tm_sec;
        qtime->tm_min = tms->tm_min;
        qtime->tm_hour = tms->tm_hour;
        qtime->tm_mday = tms->tm_mday;
        qtime->tm_mon = tms->tm_mon;
        qtime->tm_year = tms->tm_year;
        qtime->tm_wday = tms->tm_wday;
        qtime->tm_yday = tms->tm_yday;
        qtime->tm_isdst = tms->tm_isdst;
    }
    return t;
}


/*
==============================================================================

                        ZONE MEMORY ALLOCATION

There is never any space between memblocks, and there will never be two
contiguous free memblocks.

The rover can be left pointing at a non-empty block

The zone calls are pretty much only used for small strings and structures,
all big things are allocated on the hunk.
==============================================================================
*/

#define ZONEID  0x1d4a11
#define MINFRAGMENT 64

typedef struct zonedebug_s {
    char *label;
    char *file;
    int line;
    int allocSize;
} zonedebug_t;

typedef struct memblock_s {
    int     size;           // including the header and possibly tiny fragments
    int     tag;            // a tag of 0 is a free block
    struct memblock_s       *next, *prev;
    int     id;             // should be ZONEID
#ifdef ZONE_DEBUG
    zonedebug_t d;
#endif
} memblock_t;

typedef struct {
    int     size;           // total bytes malloced, including header
    int     used;           // total bytes used
    memblock_t  blocklist;  // start / end cap for linked list
    memblock_t  *rover;
} memzone_t;

// main zone for all "dynamic" memory allocation
memzone_t   *mainzone;
// we also have a small zone for small allocations that would only
// fragment the main zone (think of cvar and cmd strings)
memzone_t   *smallzone;

void Z_CheckHeap( void );

/*
========================
Z_ClearZone
========================
*/
void Z_ClearZone( memzone_t *zone, int size ) {
    memblock_t  *block;
    
    // set the entire zone to one free block

    zone->blocklist.next = zone->blocklist.prev = block =
        (memblock_t *)( (byte *)zone + sizeof(memzone_t) );
    zone->blocklist.tag = 1;    // in use block
    zone->blocklist.id = 0;
    zone->blocklist.size = 0;
    zone->rover = block;
    zone->size = size;
    zone->used = 0;
    
    block->prev = block->next = &zone->blocklist;
    block->tag = 0;         // free block
    block->id = ZONEID;
    block->size = size - sizeof(memzone_t);
}

/*
========================
Z_AvailableZoneMemory
========================
*/
int Z_AvailableZoneMemory( memzone_t *zone ) {
    return zone->size - zone->used;
}

/*
========================
Z_AvailableMemory
========================
*/
int Z_AvailableMemory( void ) {
    return Z_AvailableZoneMemory( mainzone );
}

/*
========================
Z_Free
========================
*/
void Z_Free( void *ptr ) {
    memblock_t  *block, *other;
    memzone_t *zone;
    
    if (!ptr) {
        Com_Error( ERR_DROP, "Z_Free: NULL pointer" );
    }

    block = (memblock_t *) ( (byte *)ptr - sizeof(memblock_t));
    if (block->id != ZONEID) {
        Com_Error( ERR_FATAL, "Z_Free: freed a pointer without ZONEID" );
    }
    if (block->tag == 0) {
        Com_Error( ERR_FATAL, "Z_Free: freed a freed pointer" );
    }
    // if static memory
    if (block->tag == TAG_STATIC) {
        return;
    }

    // check the memory trash tester
    if ( *(int *)((byte *)block + block->size - 4 ) != ZONEID ) {
        Com_Error( ERR_FATAL, "Z_Free: memory block wrote past end" );
    }

    if (block->tag == TAG_SMALL) {
        zone = smallzone;
    }
    else {
        zone = mainzone;
    }

    zone->used -= block->size;
    // set the block to something that should cause problems
    // if it is referenced...
    Com_Memset( ptr, 0xaa, block->size - sizeof( *block ) );

    block->tag = 0;     // mark as free
    
    other = block->prev;
    if (!other->tag) {
        // merge with previous free block
        other->size += block->size;
        other->next = block->next;
        other->next->prev = other;
        if (block == zone->rover) {
            zone->rover = other;
        }
        block = other;
    }

    zone->rover = block;

    other = block->next;
    if ( !other->tag ) {
        // merge the next free block onto the end
        block->size += other->size;
        block->next = other->next;
        block->next->prev = block;
        if (other == zone->rover) {
            zone->rover = block;
        }
    }
}


/*
================
Z_FreeTags
================
*/
void Z_FreeTags( int tag ) {
    int         count;
    memzone_t   *zone;

    if ( tag == TAG_SMALL ) {
        zone = smallzone;
    }
    else {
        zone = mainzone;
    }
    count = 0;
    // use the rover as our pointer, because
    // Z_Free automatically adjusts it
    zone->rover = zone->blocklist.next;
    do {
        if ( zone->rover->tag == tag ) {
            count++;
            Z_Free( (void *)(zone->rover + 1) );
            continue;
        }
        zone->rover = zone->rover->next;
    } while ( zone->rover != &zone->blocklist );
}


/*
================
Z_TagMalloc
================
*/
#ifdef ZONE_DEBUG
void *Z_TagMallocDebug( int size, int tag, char *label, char *file, int line ) {
#else
void *Z_TagMalloc( int size, int tag ) {
#endif
    int     extra, allocSize;
    memblock_t  *start, *rover, *new, *base;
    memzone_t *zone;

    if (!tag) {
        Com_Error( ERR_FATAL, "Z_TagMalloc: tried to use a 0 tag" );
    }

    if ( tag == TAG_SMALL ) {
        zone = smallzone;
    }
    else {
        zone = mainzone;
    }

    allocSize = size;
    //
    // scan through the block list looking for the first free block
    // of sufficient size
    //
    size += sizeof(memblock_t); // account for size of block header
    size += 4;                  // space for memory trash tester
    size = (size + 3) & ~3;     // align to 32 bit boundary
    
    base = rover = zone->rover;
    start = base->prev;
    
    do {
        if (rover == start) {
#ifdef ZONE_DEBUG
            Z_LogHeap();
#endif
            // scaned all the way around the list
            Com_Error( ERR_FATAL, "Z_Malloc: failed on allocation of %i bytes from the %s zone",
                                size, zone == smallzone ? "small" : "main");
            return NULL;
        }
        if (rover->tag) {
            base = rover = rover->next;
        } else {
            rover = rover->next;
        }
    } while (base->tag || base->size < size);
    
    //
    // found a block big enough
    //
    extra = base->size - size;
    if (extra > MINFRAGMENT) {
        // there will be a free fragment after the allocated block
        new = (memblock_t *) ((byte *)base + size );
        new->size = extra;
        new->tag = 0;           // free block
        new->prev = base;
        new->id = ZONEID;
        new->next = base->next;
        new->next->prev = new;
        base->next = new;
        base->size = size;
    }
    
    base->tag = tag;            // no longer a free block
    
    zone->rover = base->next;   // next allocation will start looking here
    zone->used += base->size;   //
    
    base->id = ZONEID;

#ifdef ZONE_DEBUG
    base->d.label = label;
    base->d.file = file;
    base->d.line = line;
    base->d.allocSize = allocSize;
#endif

    // marker for memory trash testing
    *(int *)((byte *)base + base->size - 4) = ZONEID;

    return (void *) ((byte *)base + sizeof(memblock_t));
}

/*
========================
Z_Malloc
========================
*/
#ifdef ZONE_DEBUG
void *Z_MallocDebug( int size, char *label, char *file, int line ) {
#else
void *Z_Malloc( int size ) {
#endif
    void    *buf;
    
  //Z_CheckHeap (); // DEBUG

#ifdef ZONE_DEBUG
    buf = Z_TagMallocDebug( size, TAG_GENERAL, label, file, line );
#else
    buf = Z_TagMalloc( size, TAG_GENERAL );
#endif
    Com_Memset( buf, 0, size );

    return buf;
}

#ifdef ZONE_DEBUG
void *S_MallocDebug( int size, char *label, char *file, int line ) {
    return Z_TagMallocDebug( size, TAG_SMALL, label, file, line );
}
#else
void *S_Malloc( int size ) {
    return Z_TagMalloc( size, TAG_SMALL );
}
#endif

/*
========================
Z_CheckHeap
========================
*/
void Z_CheckHeap( void ) {
    memblock_t  *block;
    
    for (block = mainzone->blocklist.next ; ; block = block->next) {
        if (block->next == &mainzone->blocklist) {
            break;          // all blocks have been hit
        }
        if ( (byte *)block + block->size != (byte *)block->next)
            Com_Error( ERR_FATAL, "Z_CheckHeap: block size does not touch the next block\n" );
        if ( block->next->prev != block) {
            Com_Error( ERR_FATAL, "Z_CheckHeap: next block doesn't have proper back link\n" );
        }
        if ( !block->tag && !block->next->tag ) {
            Com_Error( ERR_FATAL, "Z_CheckHeap: two consecutive free blocks\n" );
        }
    }
}

/*
========================
Z_LogZoneHeap
========================
*/
void Z_LogZoneHeap( memzone_t *zone, char *name ) {
#ifdef ZONE_DEBUG
    char dump[32], *ptr;
    int  i, j;
#endif
    memblock_t  *block;
    char        buf[4096];
    int size, allocSize, numBlocks;

    if (!logfile || !FS_Initialized())
        return;
    size = allocSize = numBlocks = 0;
    Com_sprintf(buf, sizeof(buf), "\r\n================\r\n%s log\r\n================\r\n", name);
    FS_Write(buf, strlen(buf), logfile);
    for (block = zone->blocklist.next ; block->next != &zone->blocklist; block = block->next) {
        if (block->tag) {
#ifdef ZONE_DEBUG
            ptr = ((char *) block) + sizeof(memblock_t);
            j = 0;
            for (i = 0; i < 20 && i < block->d.allocSize; i++) {
                if (ptr[i] >= 32 && ptr[i] < 127) {
                    dump[j++] = ptr[i];
                }
                else {
                    dump[j++] = '_';
                }
            }
            dump[j] = '\0';
            Com_sprintf(buf, sizeof(buf), "size = %8d: %s, line: %d (%s) [%s]\r\n", block->d.allocSize, block->d.file, block->d.line, block->d.label, dump);
            FS_Write(buf, strlen(buf), logfile);
            allocSize += block->d.allocSize;
#endif
            size += block->size;
            numBlocks++;
        }
    }
#ifdef ZONE_DEBUG
    // subtract debug memory
    size -= numBlocks * sizeof(zonedebug_t);
#else
    allocSize = numBlocks * sizeof(memblock_t); // + 32 bit alignment
#endif
    Com_sprintf(buf, sizeof(buf), "%d %s memory in %d blocks\r\n", size, name, numBlocks);
    FS_Write(buf, strlen(buf), logfile);
    Com_sprintf(buf, sizeof(buf), "%d %s memory overhead\r\n", size - allocSize, name);
    FS_Write(buf, strlen(buf), logfile);
}

/*
========================
Z_LogHeap
========================
*/
void Z_LogHeap( void ) {
    Z_LogZoneHeap( mainzone, "MAIN" );
    Z_LogZoneHeap( smallzone, "SMALL" );
}

// static mem blocks to reduce a lot of small zone overhead
typedef struct memstatic_s {
    memblock_t b;
    byte mem[2];
} memstatic_t;

// bk001204 - initializer brackets
memstatic_t emptystring =
    { {(sizeof(memblock_t)+2 + 3) & ~3, TAG_STATIC, NULL, NULL, ZONEID}, {'\0', '\0'} };
memstatic_t numberstring[] = {
    { {(sizeof(memstatic_t) + 3) & ~3, TAG_STATIC, NULL, NULL, ZONEID}, {'0', '\0'} },
    { {(sizeof(memstatic_t) + 3) & ~3, TAG_STATIC, NULL, NULL, ZONEID}, {'1', '\0'} },
    { {(sizeof(memstatic_t) + 3) & ~3, TAG_STATIC, NULL, NULL, ZONEID}, {'2', '\0'} },
    { {(sizeof(memstatic_t) + 3) & ~3, TAG_STATIC, NULL, NULL, ZONEID}, {'3', '\0'} },
    { {(sizeof(memstatic_t) + 3) & ~3, TAG_STATIC, NULL, NULL, ZONEID}, {'4', '\0'} },
    { {(sizeof(memstatic_t) + 3) & ~3, TAG_STATIC, NULL, NULL, ZONEID}, {'5', '\0'} },
    { {(sizeof(memstatic_t) + 3) & ~3, TAG_STATIC, NULL, NULL, ZONEID}, {'6', '\0'} },
    { {(sizeof(memstatic_t) + 3) & ~3, TAG_STATIC, NULL, NULL, ZONEID}, {'7', '\0'} },
    { {(sizeof(memstatic_t) + 3) & ~3, TAG_STATIC, NULL, NULL, ZONEID}, {'8', '\0'} }, 
    { {(sizeof(memstatic_t) + 3) & ~3, TAG_STATIC, NULL, NULL, ZONEID}, {'9', '\0'} }
};

/*
========================
CopyString

 NOTE:  never write over the memory CopyString returns because
        memory from a memstatic_t might be returned
========================
*/
char *CopyString( const char *in ) {
    char    *out;

    if (!in[0]) {
        return ((char *)&emptystring) + sizeof(memblock_t);
    }
    else if (!in[1]) {
        if (in[0] >= '0' && in[0] <= '9') {
            return ((char *)&numberstring[in[0]-'0']) + sizeof(memblock_t);
        }
    }
    out = S_Malloc (strlen(in)+1);
    strcpy (out, in);
    return out;
}

/*
==============================================================================

Goals:
    reproducable without history effects -- no out of memory errors on weird map to map changes
    allow restarting of the client without fragmentation
    minimize total pages in use at run time
    minimize total pages needed during load time

  Single block of memory with stack allocators coming from both ends towards the middle.

  One side is designated the temporary memory allocator.

  Temporary memory can be allocated and freed in any order.

  A highwater mark is kept of the most in use at any time.

  When there is no temporary memory allocated, the permanent and temp sides
  can be switched, allowing the already touched temp memory to be used for
  permanent storage.

  Temp memory must never be allocated on two ends at once, or fragmentation
  could occur.

  If we have any in-use temp memory, additional temp allocations must come from
  that side.

  If not, we can choose to make either side the new temp side and push future
  permanent allocations to the other side.  Permanent allocations should be
  kept on the side that has the current greatest wasted highwater mark.

==============================================================================
*/


#define HUNK_MAGIC  0x89537892
#define HUNK_FREE_MAGIC 0x89537893

typedef struct {
    int     magic;
    int     size;
} hunkHeader_t;

typedef struct {
    int     mark;
    int     permanent;
    int     temp;
    int     tempHighwater;
} hunkUsed_t;

typedef struct hunkblock_s {
    int size;
    byte printed;
    struct hunkblock_s *next;
    char *label;
    char *file;
    int line;
} hunkblock_t;

static  hunkblock_t *hunkblocks;

static  hunkUsed_t  hunk_low, hunk_high;
static  hunkUsed_t  *hunk_permanent, *hunk_temp;

static  byte    *s_hunkData = NULL;
static  int     s_hunkTotal;

static  int     s_zoneTotal;
static  int     s_smallZoneTotal;


/*
=================
Com_Meminfo_f
=================
*/
void Com_Meminfo_f( void ) {
    memblock_t  *block;
    int         zoneBytes, zoneBlocks;
    int         smallZoneBytes, smallZoneBlocks;
    int         botlibBytes, rendererBytes;
    int         unused;

    zoneBytes = 0;
    botlibBytes = 0;
    rendererBytes = 0;
    zoneBlocks = 0;
    for (block = mainzone->blocklist.next ; ; block = block->next) {
        if ( Cmd_Argc() != 1 ) {
            Com_Printf ("block:%p    size:%7i    tag:%3i\n",
                block, block->size, block->tag);
        }
        if ( block->tag ) {
            zoneBytes += block->size;
            zoneBlocks++;
            if ( block->tag == TAG_BOTLIB ) {
                botlibBytes += block->size;
            } else if ( block->tag == TAG_RENDERER ) {
                rendererBytes += block->size;
            }
        }

        if (block->next == &mainzone->blocklist) {
            break;          // all blocks have been hit 
        }
        if ( (byte *)block + block->size != (byte *)block->next) {
            Com_Printf ("ERROR: block size does not touch the next block\n");
        }
        if ( block->next->prev != block) {
            Com_Printf ("ERROR: next block doesn't have proper back link\n");
        }
        if ( !block->tag && !block->next->tag ) {
            Com_Printf ("ERROR: two consecutive free blocks\n");
        }
    }

    smallZoneBytes = 0;
    smallZoneBlocks = 0;
    for (block = smallzone->blocklist.next ; ; block = block->next) {
        if ( block->tag ) {
            smallZoneBytes += block->size;
            smallZoneBlocks++;
        }

        if (block->next == &smallzone->blocklist) {
            break;          // all blocks have been hit 
        }
    }

    Com_Printf( "%8i bytes total hunk\n", s_hunkTotal );
    Com_Printf( "%8i bytes total zone\n", s_zoneTotal );
    Com_Printf( "\n" );
    Com_Printf( "%8i low mark\n", hunk_low.mark );
    Com_Printf( "%8i low permanent\n", hunk_low.permanent );
    if ( hunk_low.temp != hunk_low.permanent ) {
        Com_Printf( "%8i low temp\n", hunk_low.temp );
    }
    Com_Printf( "%8i low tempHighwater\n", hunk_low.tempHighwater );
    Com_Printf( "\n" );
    Com_Printf( "%8i high mark\n", hunk_high.mark );
    Com_Printf( "%8i high permanent\n", hunk_high.permanent );
    if ( hunk_high.temp != hunk_high.permanent ) {
        Com_Printf( "%8i high temp\n", hunk_high.temp );
    }
    Com_Printf( "%8i high tempHighwater\n", hunk_high.tempHighwater );
    Com_Printf( "\n" );
    Com_Printf( "%8i total hunk in use\n", hunk_low.permanent + hunk_high.permanent );
    unused = 0;
    if ( hunk_low.tempHighwater > hunk_low.permanent ) {
        unused += hunk_low.tempHighwater - hunk_low.permanent;
    }
    if ( hunk_high.tempHighwater > hunk_high.permanent ) {
        unused += hunk_high.tempHighwater - hunk_high.permanent;
    }
    Com_Printf( "%8i unused highwater\n", unused );
    Com_Printf( "\n" );
    Com_Printf( "%8i bytes in %i zone blocks\n", zoneBytes, zoneBlocks  );
    Com_Printf( "        %8i bytes in dynamic botlib\n", botlibBytes );
    Com_Printf( "        %8i bytes in dynamic renderer\n", rendererBytes );
    Com_Printf( "        %8i bytes in dynamic other\n", zoneBytes - ( botlibBytes + rendererBytes ) );
    Com_Printf( "        %8i bytes in small Zone memory\n", smallZoneBytes );
}

/*
===============
Com_TouchMemory

Touch all known used data to make sure it is paged in
===============
*/
void Com_TouchMemory( void ) {
    int     start, end;
    int     i, j;
    int     sum;
    memblock_t  *block;

    Z_CheckHeap();

    start = Sys_Milliseconds();

    sum = 0;

    j = hunk_low.permanent >> 2;
    for ( i = 0 ; i < j ; i+=64 ) {         // only need to touch each page
        sum += ((int *)s_hunkData)[i];
    }

    i = ( s_hunkTotal - hunk_high.permanent ) >> 2;
    j = hunk_high.permanent >> 2;
    for (  ; i < j ; i+=64 ) {          // only need to touch each page
        sum += ((int *)s_hunkData)[i];
    }

    for (block = mainzone->blocklist.next ; ; block = block->next) {
        if ( block->tag ) {
            j = block->size >> 2;
            for ( i = 0 ; i < j ; i+=64 ) {             // only need to touch each page
                sum += ((int *)block)[i];
            }
        }
        if ( block->next == &mainzone->blocklist ) {
            break;          // all blocks have been hit 
        }
    }

    end = Sys_Milliseconds();

    Com_Printf( "Com_TouchMemory: %i msec\n", end - start );
}



/*
=================
Com_InitZoneMemory
=================
*/
void Com_InitSmallZoneMemory( void ) {
    s_smallZoneTotal = 512 * 1024;
    // bk001205 - was malloc
    smallzone = calloc( s_smallZoneTotal, 1 );
    if ( !smallzone ) {
        Com_Error( ERR_FATAL, "Small zone data failed to allocate %1.1f megs", (float)s_smallZoneTotal / (1024*1024) );
    }
    Z_ClearZone( smallzone, s_smallZoneTotal );