common.c

/*
Copyright (C) 1996-1997 Id Software, Inc.
Copyright (C) 2002-2009 John Fitzgibbons and others
Copyright (C) 2010-2014 QuakeSpasm developers

This program 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.

This program 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 this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/
// common.c -- misc functions used in client and server
#include <stdio.h>
#include <ctype.h>
#include <retro_dirent.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <errno.h>

#ifdef NQ_HACK
#include "quakedef.h"
#include "host.h"
#endif
#ifdef QW_HACK
#ifdef SERVERONLY
#include "qwsvdef.h"
#include "server.h"
#else
#include "quakedef.h"
#endif
#include "protocol.h"
#endif

#include "cmd.h"
#include "common.h"
#include "console.h"
#include "crc.h"
#include "draw.h"
#include "net.h"
#include "shell.h"
#include "sys.h"
#include "zone.h"

#define NUM_SAFE_ARGVS 7

static const char *largv[MAX_NUM_ARGVS + NUM_SAFE_ARGVS + 1];
static const char *argvdummy = " ";

static const char *safeargvs[NUM_SAFE_ARGVS] = {
  "-stdvid", "-nolan", "-nosound", "-nocdaudio", "-nojoy", "-nomouse", "-dibonly"
};

cvar_t registered = { "registered", "0" };
#ifdef NQ_HACK
static cvar_t cmdline = { "cmdline", "0", false, true };
#endif

static qboolean com_modified;		// set true if using non-id files
static int static_registered = 1;	// only for startup check, then set

qboolean msg_suppress_1 = 0;

static void COM_InitFilesystem(void);
static void COM_Path_f(void);
static void *SZ_GetSpace(sizebuf_t *buf, int length);

// if a packfile directory differs from this, it is assumed to be hacked
#define PAK0_COUNT		339
#define NQ_PAK0_CRC		32981
#define QW_PAK0_CRC		52883

#ifdef NQ_HACK
#define CMDLINE_LENGTH	256
static char com_cmdline[CMDLINE_LENGTH];
#endif

qboolean standard_quake = true, rogue, hipnotic;

#ifdef QW_HACK
char gamedirfile[MAX_OSPATH];
#endif

/*

All of Quake's data access is through a hierchal file system, but the contents
of the file system can be transparently merged from several sources.

The "base directory" is the path to the directory holding the quake.exe and
all game directories.  The sys_* files pass this to host_init in
quakeparms_t->basedir.  This can be overridden with the "-basedir" command
line parm to allow code debugging in a different directory.  The base
directory is only used during filesystem initialization.

The "game directory" is the first tree on the search path and directory that
all generated files (savegames, screenshots, demos, config files) will be
saved to.  This can be overridden with the "-game" command line parameter.
The game directory can never be changed while quake is executing.  This is a
precacution against having a malicious server instruct clients to write files
over areas they shouldn't.

*/

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


// ClearLink is used for new headnodes
void ClearLink(link_t *l)
{
   l->prev = l->next = l;
}

void RemoveLink(link_t *l)
{
   l->next->prev = l->prev;
   l->prev->next = l->next;
}

void InsertLinkBefore(link_t *l, link_t *before)
{
   l->next = before;
   l->prev = before->prev;
   l->prev->next = l;
   l->next->prev = l;
}

/* Unused */
#if 0
void InsertLinkAfter(link_t *l, link_t *after)
{
   l->next = after->next;
   l->prev = after;
   l->prev->next = l;
   l->next->prev = l;
}
#endif

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

			LIBRARY REPLACEMENT FUNCTIONS

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

/*
 * Use this function to share static string buffers
 * between different text processing functions.
 * Try to avoid fixed-size intermediate buffers like this if possible
 */
#define COM_STRBUF_LEN 2048
static char *COM_GetStrBuf(void)
{
   static char buffers[4][COM_STRBUF_LEN];
   static int index;
   return buffers[3 & ++index];
}

int Q_atoi(const char *str)
{
   int val;
   int sign;
   int c;

   if (*str == '-')
   {
      sign = -1;
      str++;
   } else
      sign = 1;

   val = 0;

   // check for hex
   if (str[0] == '0' && (str[1] == 'x' || str[1] == 'X'))
   {
      str += 2;
      while (1)
      {
         c = *str++;
         if (c >= '0' && c <= '9')
            val = (val << 4) + c - '0';
         else if (c >= 'a' && c <= 'f')
            val = (val << 4) + c - 'a' + 10;
         else if (c >= 'A' && c <= 'F')
            val = (val << 4) + c - 'A' + 10;
         else
            return val * sign;
      }
   }

   // check for character
   if (str[0] == '\'')
      return sign * str[1];

   // assume decimal
   while (1)
   {
      c = *str++;
      if (c < '0' || c > '9')
         return val * sign;
      val = val * 10 + c - '0';
   }

   return 0;
}


float Q_atof(const char *str)
{
   double val;
   int sign;
   int c;
   int decimal, total;

   if (*str == '-')
   {
      sign = -1;
      str++;
   }
   else
      sign = 1;

   val = 0;

   // check for hex
   if (str[0] == '0' && (str[1] == 'x' || str[1] == 'X'))
   {
      str += 2;
      while (1)
      {
         c = *str++;
         if (c >= '0' && c <= '9')
            val = (val * 16) + c - '0';
         else if (c >= 'a' && c <= 'f')
            val = (val * 16) + c - 'a' + 10;
         else if (c >= 'A' && c <= 'F')
            val = (val * 16) + c - 'A' + 10;
         else
            return val * sign;
      }
   }

   // check for character
   if (str[0] == '\'')
      return sign * str[1];

   // assume decimal
   decimal = -1;
   total = 0;
   while (1)
   {
      c = *str++;
      if (c == '.')
      {
         decimal = total;
         continue;
      }
      if (c < '0' || c > '9')
         break;
      val = val * 10 + c - '0';
      total++;
   }

   if (decimal == -1)
      return val * sign;

   while (total > decimal)
   {
      val /= 10;
      total--;
   }

   return val * sign;
}

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

			MESSAGE IO FUNCTIONS

Handles byte ordering and avoids alignment errors
==============================================================================
*/

#ifdef QW_HACK
usercmd_t nullcmd;		// guarenteed to be zero
#endif

// writing functions

void MSG_WriteChar(sizebuf_t *sb, int c)
{
   byte *buf = (byte*)SZ_GetSpace(sb, 1);
   buf[0] = c;
}

void MSG_WriteByte(sizebuf_t *sb, int c)
{
   byte *buf = (byte*)SZ_GetSpace(sb, 1);
   buf[0] = c;
}

void MSG_WriteShort(sizebuf_t *sb, int c)
{
   byte *buf = (byte*)SZ_GetSpace(sb, 2);
   buf[0] = c & 0xff;
   buf[1] = c >> 8;
}

void MSG_WriteLong(sizebuf_t *sb, int c)
{
   byte *buf = (byte*)SZ_GetSpace(sb, 4);
   buf[0] = c & 0xff;
   buf[1] = (c >> 8) & 0xff;
   buf[2] = (c >> 16) & 0xff;
   buf[3] = c >> 24;
}

void MSG_WriteFloat(sizebuf_t *sb, float f)
{
#ifdef MSB_FIRST
   union {
      float f;
      int l;
   } dat;

   dat.f = f;
   dat.l = LittleLong(dat.l);

   SZ_Write(sb, &dat.l, 4);
#else
   SZ_Write (sb, &f, 4);
#endif
}

void MSG_WriteString(sizebuf_t *sb, const char *s)
{
   if (!s)
      SZ_Write(sb, "", 1);
   else
      SZ_Write(sb, s, strlen(s) + 1);
}

void MSG_WriteStringvf(sizebuf_t *sb, const char *fmt, va_list ap)
{
   /*
    * FIXME - Kind of ugly to check space first then do getspace
    * afterwards, but we don't know how much we'll need before
    * hand. Update the SZ interface?
    */
   int maxlen = sb->maxsize - sb->cursize;
   int    len = vsnprintf((char *)sb->data + sb->cursize, maxlen, fmt, ap);

   /* Use SZ_GetSpace to check for overflow */
   SZ_GetSpace(sb, len + 1);
}

void MSG_WriteStringf(sizebuf_t *sb, const char *fmt, ...)
{
   va_list ap;

   va_start(ap, fmt);
   MSG_WriteStringvf(sb, fmt, ap);
   va_end(ap);
}

void MSG_WriteCoord(sizebuf_t *sb, float f)
{
   /*
    * Co-ords are send as shorts, with the low 3 bits being the fractional
    * component
    */
   MSG_WriteShort(sb, (int)(f * (1 << 3)));
}

void MSG_WriteAngle(sizebuf_t *sb, float f)
{
   MSG_WriteByte(sb, (int)floorf((f * 256 / 360) + 0.5f) & 255);
}

void MSG_WriteAngle16(sizebuf_t *sb, float f)
{
   MSG_WriteShort(sb, (int)floorf((f * 65536 / 360) + 0.5f) & 65535);
}

#ifdef QW_HACK
void MSG_WriteDeltaUsercmd(sizebuf_t *buf, const usercmd_t *from,
      const usercmd_t *cmd)
{
   // send the movement message
   int bits = 0;
   if (cmd->angles[0] != from->angles[0])
      bits |= CM_ANGLE1;
   if (cmd->angles[1] != from->angles[1])
      bits |= CM_ANGLE2;
   if (cmd->angles[2] != from->angles[2])
      bits |= CM_ANGLE3;
   if (cmd->forwardmove != from->forwardmove)
      bits |= CM_FORWARD;
   if (cmd->sidemove != from->sidemove)
      bits |= CM_SIDE;
   if (cmd->upmove != from->upmove)
      bits |= CM_UP;
   if (cmd->buttons != from->buttons)
      bits |= CM_BUTTONS;
   if (cmd->impulse != from->impulse)
      bits |= CM_IMPULSE;

   MSG_WriteByte(buf, bits);

   if (bits & CM_ANGLE1)
      MSG_WriteAngle16(buf, cmd->angles[0]);
   if (bits & CM_ANGLE2)
      MSG_WriteAngle16(buf, cmd->angles[1]);
   if (bits & CM_ANGLE3)
      MSG_WriteAngle16(buf, cmd->angles[2]);

   if (bits & CM_FORWARD)
      MSG_WriteShort(buf, cmd->forwardmove);
   if (bits & CM_SIDE)
      MSG_WriteShort(buf, cmd->sidemove);
   if (bits & CM_UP)
      MSG_WriteShort(buf, cmd->upmove);

   if (bits & CM_BUTTONS)
      MSG_WriteByte(buf, cmd->buttons);
   if (bits & CM_IMPULSE)
      MSG_WriteByte(buf, cmd->impulse);
   MSG_WriteByte(buf, cmd->msec);
}
#endif /* QW_HACK */

#ifdef NQ_HACK
/*
 * Write the current message length to the start of the buffer (in big
 * endian format) with the control flag set.
 */
void MSG_WriteControlHeader(sizebuf_t *sb)
{
   int c = NETFLAG_CTL | (sb->cursize & NETFLAG_LENGTH_MASK);

   sb->data[0] = c >> 24;
   sb->data[1] = (c >> 16) & 0xff;
   sb->data[2] = (c >> 8) & 0xff;
   sb->data[3] = c & 0xff;
}
#endif

// reading functions
int msg_readcount;
qboolean msg_badread;

void MSG_BeginReading(void)
{
   msg_readcount = 0;
   msg_badread = false;
}

#ifdef QW_HACK
int MSG_GetReadCount(void)
{
   return msg_readcount;
}
#endif

// returns -1 and sets msg_badread if no more characters are available
int MSG_ReadChar(void)
{
   int c;

   if (msg_readcount + 1 > net_message.cursize)
      goto error;

   c = (signed char)net_message.data[msg_readcount];
   msg_readcount++;

   return c;

error:
   msg_badread = true;
   return -1;
}

int MSG_ReadByte(void)
{
   int c;

   if (msg_readcount + 1 > net_message.cursize)
      goto error;

   c = (unsigned char)net_message.data[msg_readcount];
   msg_readcount++;

   return c;

error:
   msg_badread = true;
   return -1;
}

int MSG_ReadShort(void)
{
   int c;

   if (msg_readcount + 2 > net_message.cursize)
      goto error;

   c = (short)(net_message.data[msg_readcount]
         + (net_message.data[msg_readcount + 1] << 8));

   msg_readcount += 2;

   return c;

error:
   msg_badread = true;
   return -1;
}

int MSG_ReadLong(void)
{
   int c;

   if (msg_readcount + 4 > net_message.cursize)
      goto error;

   c = net_message.data[msg_readcount]
   + (net_message.data[msg_readcount + 1] << 8)
   + (net_message.data[msg_readcount + 2] << 16)
   + (net_message.data[msg_readcount + 3] << 24);

   msg_readcount += 4;

   return c;

error:
   msg_badread = true;
   return -1;
}

float MSG_ReadFloat(void)
{
   union {
      byte b[4];
      float f;
#ifdef MSB_FIRST
      int l;
#endif
   } dat;

   dat.b[0] = net_message.data[msg_readcount];
   dat.b[1] = net_message.data[msg_readcount + 1];
   dat.b[2] = net_message.data[msg_readcount + 2];
   dat.b[3] = net_message.data[msg_readcount + 3];
   msg_readcount += 4;

#ifdef MSB_FIRST
   dat.l = LittleLong(dat.l);
#endif

   return dat.f;
}

char *MSG_ReadString(void)
{
   char *buf = COM_GetStrBuf();
   int len   = 0;

   do
   {
      int c = MSG_ReadChar();
      if (c == -1 || c == 0)
         break;
      buf[len++] = c;
   }while (len < COM_STRBUF_LEN - 1);

   buf[len] = 0;

   return buf;
}

#ifdef QW_HACK
char *MSG_ReadStringLine(void)
{
   char *buf = COM_GetStrBuf();
   int len = 0;

   do {
      int c = MSG_ReadChar();
      if (c == -1 || c == 0 || c == '\n')
         break;
      buf[len++] = c;
   } while (len < COM_STRBUF_LEN - 1);

   buf[len] = 0;

   return buf;
}
#endif

float MSG_ReadCoord(void)
{
   /*
    * Co-ords are send as shorts, with the low 3 bits being the fractional
    * component
    */
   return MSG_ReadShort() * (1.0 / (1 << 3));
}

float MSG_ReadAngle(void)
{
   return MSG_ReadChar() * (360.0 / 256);
}

float MSG_ReadAngle16(void)
{
   return MSG_ReadShort() * (360.0 / 65536);
}

#ifdef QW_HACK
void MSG_ReadDeltaUsercmd(const usercmd_t *from, usercmd_t *move)
{
   int bits;

   memcpy(move, from, sizeof(*move));

   bits = MSG_ReadByte();

   // read current angles
   if (bits & CM_ANGLE1)
      move->angles[0] = MSG_ReadAngle16();
   if (bits & CM_ANGLE2)
      move->angles[1] = MSG_ReadAngle16();
   if (bits & CM_ANGLE3)
      move->angles[2] = MSG_ReadAngle16();

   // read movement
   if (bits & CM_FORWARD)
      move->forwardmove = MSG_ReadShort();
   if (bits & CM_SIDE)
      move->sidemove = MSG_ReadShort();
   if (bits & CM_UP)
      move->upmove = MSG_ReadShort();

   // read buttons
   if (bits & CM_BUTTONS)
      move->buttons = MSG_ReadByte();

   if (bits & CM_IMPULSE)
      move->impulse = MSG_ReadByte();

   // read time to run command
   move->msec = MSG_ReadByte();
}
#endif /* QW_HACK */

#ifdef NQ_HACK
/*
 * Read back the message control header
 * Essentially this is MSG_ReadLong, but big-endian byte order.
 */
int MSG_ReadControlHeader(void)
{
   int c;

   if (msg_readcount + 4 > net_message.cursize)
   {
      msg_badread = true;
      return -1;
   }

   c = (net_message.data[msg_readcount] << 24)
      + (net_message.data[msg_readcount + 1] << 16)
      + (net_message.data[msg_readcount + 2] << 8)
      + net_message.data[msg_readcount + 3];

   msg_readcount += 4;

   return c;
}
#endif

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

#ifdef NQ_HACK
void SZ_Alloc(sizebuf_t *buf, int startsize)
{
   if (startsize < 256)
      startsize = 256;
   buf->data = (byte*)Hunk_AllocName(startsize, "sizebuf");
   buf->maxsize = startsize;
   buf->cursize = 0;
}

void SZ_Free(sizebuf_t *buf)
{
   //      Z_Free (buf->data);
   //      buf->data = NULL;
   //      buf->maxsize = 0;
   buf->cursize = 0;
}
#endif

void SZ_Clear(sizebuf_t *buf)
{
   buf->cursize = 0;
   buf->overflowed = false;
}

static void *SZ_GetSpace(sizebuf_t *buf, int length)
{
   void *data;

   if (buf->cursize + length > buf->maxsize)
   {
      if (!buf->allowoverflow)
         Sys_Error("%s: overflow without allowoverflow set (%d > %d)",
               __func__, buf->cursize + length, buf->maxsize);
      if (length > buf->maxsize)
         Sys_Error("%s: %d is > full buffer size", __func__, length);
      if (developer.value)
         /* Con_Printf may be redirected */
         Sys_Printf("%s: overflow\n", __func__);
      SZ_Clear(buf);
      buf->overflowed = true;
   }
   data = buf->data + buf->cursize;
   buf->cursize += length;

   return data;
}

void SZ_Write(sizebuf_t *buf, const void *data, int length)
{
   memcpy(SZ_GetSpace(buf, length), data, length);
}

void SZ_Print(sizebuf_t *buf, const char *data)
{
   size_t len = strlen(data);

   /* If buf->data has a trailing zero, overwrite it */
   if (!buf->cursize || buf->data[buf->cursize - 1])
      memcpy(SZ_GetSpace(buf, len + 1), data, len + 1);
   else
      memcpy((byte*)SZ_GetSpace(buf, len) - 1, data, len + 1);
}


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


/*
============
COM_SkipPath
============
*/
const char *COM_SkipPath(const char *pathname)
{
   const char *last = pathname;
   while (*pathname)
   {
      if (*pathname == '/')
         last = pathname + 1;
      pathname++;
   }
   return last;
}

/*
============
COM_StripExtension
============
*/
void COM_StripExtension(char *filename)
{
   const char *start = COM_SkipPath(filename);
   char *pos = (char*)strrchr(start, '.');
   if (pos && *pos)
      *pos = 0;
}

/*
============
COM_FileExtension
============
*/
#ifdef NQ_HACK
const char *COM_FileExtension(const char *in)
{
   static char exten[8];
   const char *dot;
   int i;

   in = COM_SkipPath(in);
   dot = strrchr(in, '.');
   if (!dot)
      return "";

   dot++;
   for (i = 0; i < sizeof(exten) - 1 && *dot; i++, dot++)
      exten[i] = *dot;
   exten[i] = 0;

   return exten;
}
#endif

/*
============
COM_FileBase
============
*/
void COM_FileBase(const char *in, char *out, size_t buflen)
{
   const char *dot;
   int copylen;

   in = COM_SkipPath(in);
   dot = strrchr(in, '.');
   copylen = dot ? dot - in : strlen(in);

   if (copylen < 2) {
      in = "?model?";
      copylen = strlen(in);
   }
   snprintf(out, buflen, "%.*s", copylen, in);
}


/*
==================
COM_DefaultExtension
==================
*/
void COM_DefaultExtension(char *path, const char *extension)
{
   // if path doesn't have a .EXT, append extension
   // (extension should include the .)
   const char *src = path + strlen(path) - 1;
   while (*src != '/' && src != path)
   {
      if (*src == '.')
         return;		// it has an extension
      src--;
   }
   strcat(path, extension);
}

int COM_CheckExtension(const char *path, const char *extn)
{
   int ret   = 0;
   char *pos = (char*)strrchr(path, '.');

   if (pos)
   {
      if (extn[0] != '.')
         pos++;
      ret = pos && !strcasecmp(pos, extn);
   }

   return ret;
}

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

char com_token[1024];
unsigned com_argc;
const char **com_argv;

/*
==============
COM_Parse

Parse a token out of a string
==============
*/
static const char single_chars[] = "{})(':";

static const char *COM_Parse_(const char *data, qboolean split_single_chars)
{
   int c;
   int len = 0;

   com_token[0] = 0;

   if (!data)
      return NULL;

   // skip whitespace
skipwhite:
   while ((c = *data) <= ' ') {
      if (c == 0)
         return NULL;	// end of file;
      data++;
   }

   // skip // comments
   if (c == '/' && data[1] == '/') {
      while (*data && *data != '\n')
         data++;
      goto skipwhite;
   }
   // handle quoted strings specially
   if (c == '\"') {
      data++;
      while (1) {
         c = *data++;
         if (c == '\"' || !c) {
            com_token[len] = 0;
            return data;
         }
         com_token[len] = c;
         len++;
      }
   }
   // parse single characters
   if (split_single_chars && strchr(single_chars, c)) {
      com_token[len] = c;
      len++;
      com_token[len] = 0;
      return data + 1;
   }
   // parse a regular word
   do {
      com_token[len] = c;
      data++;
      len++;
      c = *data;
      if (split_single_chars && strchr(single_chars, c))
         break;
   } while (c > 32);

   com_token[len] = 0;
   return data;
}

const char *
COM_Parse(const char *data)
{
#ifdef NQ_HACK
    return COM_Parse_(data, true);
#endif
#ifdef QW_HACK
    return COM_Parse_(data, false);
#endif
}

/*
================
COM_CheckParm

Returns the position (1 to argc-1) in the program's argument list
where the given parameter apears, or 0 if not present
================
*/
unsigned COM_CheckParm(const char *parm)
{
   unsigned i;

   for (i = 1; i < com_argc; i++) {
      if (!com_argv[i])
         continue;		// NEXTSTEP sometimes clears appkit vars.
      if (!strcmp(parm, com_argv[i]))
         return i;
   }

   return 0;
}

/*
================
COM_CheckRegistered

Looks for the pop.txt file and verifies it.
Sets the "registered" cvar.
Immediately exits out if an alternate game was attempted to be started without
being registered.
================
*/
void COM_CheckRegistered(void)
{
   FILE *f;

#ifdef NQ_HACK
   Cvar_Set("cmdline", com_cmdline);
#endif
   COM_FOpenFile("gfx/pop.lmp", &f);
   if (!f)
      Con_Printf("Playing shareware version.\n");
   else
   {
      fclose(f);
      Cvar_Set("registered", "1");
      static_registered = 1;
      Con_Printf("Playing registered version.\n");
   }
}


/*
================
COM_InitArgv
================
*/
void COM_InitArgv(int argc, const char **argv)
{
   qboolean safe;
   int i;
#ifdef NQ_HACK
   int j, n = 0;
   // reconstitute the command line for the cmdline externally visible cvar
   for (j = 0; (j < MAX_NUM_ARGVS) && (j < argc); j++)
   {
      i = 0;
      while ((n < (CMDLINE_LENGTH - 1)) && argv[j][i])
         com_cmdline[n++] = argv[j][i++];

      if (n < (CMDLINE_LENGTH - 1))
         com_cmdline[n++] = ' ';
      else
         break;
   }
   com_cmdline[n] = 0;
#endif

   safe = false;

   for (com_argc = 0; (com_argc < MAX_NUM_ARGVS) && (com_argc < argc);
         com_argc++) {
      largv[com_argc] = argv[com_argc];
      if (!strcmp("-safe", argv[com_argc]))
         safe = true;
   }

   if (safe) {
      // force all the safe-mode switches. Note that we reserved extra space in
      // case we need to add these, so we don't need an overflow check
      for (i = 0; i < NUM_SAFE_ARGVS; i++) {
         largv[com_argc] = safeargvs[i];
         com_argc++;
      }
   }

   largv[com_argc] = argvdummy;
   com_argv = largv;

#ifdef NQ_HACK
   if (COM_CheckParm("-rogue")) {
      rogue = true;
      standard_quake = false;
   }

   if (COM_CheckParm("-hipnotic") || COM_CheckParm("-quoth")) {
      hipnotic = true;
      standard_quake = false;
   }
#endif
}

/*
================
COM_AddParm

Adds the given string at the end of the current argument list
================
*/
#ifdef QW_HACK
void COM_AddParm(const char *parm)
{
   largv[com_argc++] = parm;
}
#endif

/*
================
COM_Init
================
*/

void COM_Init(void)
{
   Cvar_RegisterVariable(&registered);
#ifdef NQ_HACK
   Cvar_RegisterVariable(&cmdline);
#endif
   Cmd_AddCommand("path", COM_Path_f);

   COM_InitFilesystem();
   COM_CheckRegistered();
}


/*
============
va

does a varargs printf into a temp buffer, so I don't need to have
varargs versions of all text functions.
============
*/
char *va(const char *format, ...)
{
   va_list argptr;
   int len;
   char *buf = COM_GetStrBuf();

   va_start(argptr, format);
   len = vsnprintf(buf, COM_STRBUF_LEN, format, argptr);
   va_end(argptr);

   if (len > COM_STRBUF_LEN - 1)
      Con_DPrintf("%s: overflow (string truncated)\n", __func__);

   return buf;
}


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

QUAKE FILESYSTEM

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

int com_filesize;

// in memory

typedef struct {
    char name[MAX_QPATH];
    int filepos, filelen;
} packfile_t;

typedef struct pack_s
{
    char filename[MAX_OSPATH];
    int numfiles;
    packfile_t *files;
} pack_t;

// on disk
#define MAX_PACKPATH 56
typedef struct
{
    char name[MAX_PACKPATH];
    int filepos, filelen;
} dpackfile_t;

typedef struct
{
    char id[4];
    int dirofs;
    int dirlen;
} dpackheader_t;

char com_gamedir[MAX_OSPATH];
char com_basedir[MAX_OSPATH];
char com_savedir[MAX_OSPATH];

typedef struct searchpath_s {
    char filename[MAX_OSPATH];
    pack_t *pack;		// only one of filename / pack will be used
    struct searchpath_s *next;
} searchpath_t;

static searchpath_t *com_searchpaths;