1.27 import

1 files changed, 1229 insertions, 0 deletions

diff --git a/src/game/q_shared.c b/src/game/q_shared.c
new file mode 100644
index 00000000..3477de84
--- /dev/null
+++ b/src/game/q_shared.c
@@ -0,0 +1,1229 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+// q_shared.c -- stateless support routines that are included in each code dll
+
+/*
+ *  Portions Copyright (C) 2000-2001 Tim Angus
+ *
+ *  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, 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.
+ */
+
+/*  To assertain which portions are licensed under the GPL and which are
+ *  licensed by Id Software, Inc. please run a diff between the equivalent
+ *  versions of the "Tremulous" modification and the unmodified "Quake3"
+ *  game source code.
+ */
+                    
+#include "q_shared.h"
+
+float Com_Clamp( float min, float max, float value ) {
+  if ( value < min ) {
+    return min;
+  }
+  if ( value > max ) {
+    return max;
+  }
+  return value;
+}
+
+
+/*
+============
+COM_SkipPath
+============
+*/
+char *COM_SkipPath (char *pathname)
+{
+  char  *last;
+
+  last = pathname;
+  while (*pathname)
+  {
+    if (*pathname=='/')
+      last = pathname+1;
+    pathname++;
+  }
+  return last;
+}
+
+/*
+============
+COM_StripExtension
+============
+*/
+void COM_StripExtension( const char *in, char *out ) {
+  while ( *in && *in != '.' ) {
+    *out++ = *in++;
+  }
+  *out = 0;
+}
+
+
+/*
+==================
+COM_DefaultExtension
+==================
+*/
+void COM_DefaultExtension (char *path, int maxSize, const char *extension ) {
+  char  oldPath[MAX_QPATH];
+  char    *src;
+
+//
+// if path doesn't have a .EXT, append extension
+// (extension should include the .)
+//
+  src = path + strlen(path) - 1;
+
+  while (*src != '/' && src != path) {
+    if ( *src == '.' ) {
+      return;                 // it has an extension
+    }
+    src--;
+  }
+
+  Q_strncpyz( oldPath, path, sizeof( oldPath ) );
+  Com_sprintf( path, maxSize, "%s%s", oldPath, extension );
+}
+
+/*
+============================================================================
+
+          BYTE ORDER FUNCTIONS
+
+============================================================================
+*/
+
+// can't just use function pointers, or dll linkage can
+// mess up when qcommon is included in multiple places
+static short  (*_BigShort) (short l);
+static short  (*_LittleShort) (short l);
+static int    (*_BigLong) (int l);
+static int    (*_LittleLong) (int l);
+static qint64 (*_BigLong64) (qint64 l);
+static qint64 (*_LittleLong64) (qint64 l);
+static float  (*_BigFloat) (float l);
+static float  (*_LittleFloat) (float l);
+
+short BigShort(short l){return _BigShort(l);}
+short LittleShort(short l) {return _LittleShort(l);}
+int   BigLong (int l) {return _BigLong(l);}
+int   LittleLong (int l) {return _LittleLong(l);}
+qint64  BigLong64 (qint64 l) {return _BigLong64(l);}
+qint64  LittleLong64 (qint64 l) {return _LittleLong64(l);}
+float BigFloat (float l) {return _BigFloat(l);}
+float LittleFloat (float l) {return _LittleFloat(l);}
+
+short   ShortSwap (short l)
+{
+  byte    b1,b2;
+
+  b1 = l&255;
+  b2 = (l>>8)&255;
+
+  return (b1<<8) + b2;
+}
+
+short ShortNoSwap (short l)
+{
+  return l;
+}
+
+int    LongSwap (int l)
+{
+  byte    b1,b2,b3,b4;
+
+  b1 = l&255;
+  b2 = (l>>8)&255;
+  b3 = (l>>16)&255;
+  b4 = (l>>24)&255;
+
+  return ((int)b1<<24) + ((int)b2<<16) + ((int)b3<<8) + b4;
+}
+
+int LongNoSwap (int l)
+{
+  return l;
+}
+
+qint64 Long64Swap (qint64 ll)
+{
+  qint64  result;
+
+  result.b0 = ll.b7;
+  result.b1 = ll.b6;
+  result.b2 = ll.b5;
+  result.b3 = ll.b4;
+  result.b4 = ll.b3;
+  result.b5 = ll.b2;
+  result.b6 = ll.b1;
+  result.b7 = ll.b0;
+
+  return result;
+}
+
+qint64 Long64NoSwap (qint64 ll)
+{
+  return ll;
+}
+
+
+float FloatSwap (float f)
+{
+  union
+  {
+    float f;
+    byte  b[4];
+  } dat1, dat2;
+
+
+  dat1.f = f;
+  dat2.b[0] = dat1.b[3];
+  dat2.b[1] = dat1.b[2];
+  dat2.b[2] = dat1.b[1];
+  dat2.b[3] = dat1.b[0];
+  return dat2.f;
+}
+
+float FloatNoSwap (float f)
+{
+  return f;
+}
+
+/*
+================
+Swap_Init
+================
+*/
+void Swap_Init (void)
+{
+  byte  swaptest[2] = {1,0};
+
+// set the byte swapping variables in a portable manner
+  if ( *(short *)swaptest == 1)
+  {
+    _BigShort = ShortSwap;
+    _LittleShort = ShortNoSwap;
+    _BigLong = LongSwap;
+    _LittleLong = LongNoSwap;
+    _BigLong64 = Long64Swap;
+    _LittleLong64 = Long64NoSwap;
+    _BigFloat = FloatSwap;
+    _LittleFloat = FloatNoSwap;
+  }
+  else
+  {
+    _BigShort = ShortNoSwap;
+    _LittleShort = ShortSwap;
+    _BigLong = LongNoSwap;
+    _LittleLong = LongSwap;
+    _BigLong64 = Long64NoSwap;
+    _LittleLong64 = Long64Swap;
+    _BigFloat = FloatNoSwap;
+    _LittleFloat = FloatSwap;
+  }
+
+}
+
+
+/*
+============================================================================
+
+PARSING
+
+============================================================================
+*/
+
+static  char  com_token[MAX_TOKEN_CHARS];
+static  char  com_parsename[MAX_TOKEN_CHARS];
+static  int   com_lines;
+
+void COM_BeginParseSession( const char *name )
+{
+  com_lines = 0;
+  Com_sprintf(com_parsename, sizeof(com_parsename), "%s", name);
+}
+
+int COM_GetCurrentParseLine( void )
+{
+  return com_lines;
+}
+
+char *COM_Parse( char **data_p )
+{
+  return COM_ParseExt( data_p, qtrue );
+}
+
+
+void COM_ParseError( char *format, ... )
+{
+  va_list argptr;
+  static char string[4096];
+
+  va_start (argptr, format);
+  vsprintf (string, format, argptr);
+  va_end (argptr);
+
+  Com_Printf("ERROR: %s, line %d: %s\n", com_parsename, com_lines, string);
+}
+
+void COM_ParseWarning( char *format, ... )
+{
+  va_list argptr;
+  static char string[4096];
+
+  va_start (argptr, format);
+  vsprintf (string, format, argptr);
+  va_end (argptr);
+
+  Com_Printf("WARNING: %s, line %d: %s\n", com_parsename, com_lines, string);
+}
+
+
+/*
+==============
+COM_Parse
+
+Parse a token out of a string
+Will never return NULL, just empty strings
+
+If "allowLineBreaks" is qtrue then an empty
+string will be returned if the next token is
+a newline.
+==============
+*/
+static char *SkipWhitespace( char *data, qboolean *hasNewLines ) {
+  int c;
+
+  while( (c = *data) <= ' ') {
+    if( !c ) {
+      return NULL;
+    }
+    if( c == '\n' ) {
+      com_lines++;
+      *hasNewLines = qtrue;
+    }
+    data++;
+  }
+
+  return data;
+}
+
+
+int COM_Compress( char *data_p ) {
+  char *datai, *datao;
+  int c, pc, size;
+  qboolean ws = qfalse;
+
+  size = 0;
+  pc = 0;
+  datai = datao = data_p;
+  if (datai) {
+    while ((c = *datai) != 0) {
+      if (c == 13 || c == 10) {
+        *datao = c;
+        datao++;
+        ws = qfalse;
+        pc = c;
+        datai++;
+        size++;
+      // skip double slash comments
+      } else if ( c == '/' && datai[1] == '/' ) {
+        while (*datai && *datai != '\n') {
+          datai++;
+        }
+        ws = qfalse;
+      // skip /* */ comments
+      } else if ( c=='/' && datai[1] == '*' ) {
+        while ( *datai && ( *datai != '*' || datai[1] != '/' ) ) 
+        {
+          datai++;
+        }
+        if ( *datai ) 
+        {
+          datai += 2;
+        }
+        ws = qfalse;
+      } else {
+        if (ws) {
+          *datao = ' ';
+          datao++;
+        }
+        *datao = c;
+        datao++;
+        datai++;
+        ws = qfalse;
+        pc = c;
+        size++;
+      }
+    }
+  }
+  *datao = 0;
+  return size;
+}
+
+
+char *COM_ParseExt( char **data_p, qboolean allowLineBreaks )
+{
+  int c = 0, len;
+  qboolean hasNewLines = qfalse;
+  char *data;
+
+  data = *data_p;
+  len = 0;
+  com_token[0] = 0;
+
+  // make sure incoming data is valid
+  if ( !data )
+  {
+    *data_p = NULL;
+    return com_token;
+  }
+
+  while ( 1 )
+  {
+    // skip whitespace
+    data = SkipWhitespace( data, &hasNewLines );
+    if ( !data )
+    {
+      *data_p = NULL;
+      return com_token;
+    }
+    if ( hasNewLines && !allowLineBreaks )
+    {
+      *data_p = data;
+      return com_token;
+    }
+
+    c = *data;
+
+    // skip double slash comments
+    if ( c == '/' && data[1] == '/' )
+    {
+      data += 2;
+      while (*data && *data != '\n') {
+        data++;
+      }
+    }
+    // skip /* */ comments
+    else if ( c=='/' && data[1] == '*' )
+    {
+      data += 2;
+      while ( *data && ( *data != '*' || data[1] != '/' ) )
+      {
+        data++;
+      }
+      if ( *data )
+      {
+        data += 2;
+      }
+    }
+    else
+    {
+      break;
+    }
+  }
+
+  // handle quoted strings
+  if (c == '\"')
+  {
+    data++;
+    while (1)
+    {
+      c = *data++;
+      if (c=='\"' || !c)
+      {
+        com_token[len] = 0;
+        *data_p = ( char * ) data;
+        return com_token;
+      }
+      if (len < MAX_TOKEN_CHARS)
+      {
+        com_token[len] = c;
+        len++;
+      }
+    }
+  }
+
+  // parse a regular word
+  do
+  {
+    if (len < MAX_TOKEN_CHARS)
+    {
+      com_token[len] = c;
+      len++;
+    }
+    data++;
+    c = *data;
+    if ( c == '\n' )
+      com_lines++;
+  } while (c>32);
+
+  if (len == MAX_TOKEN_CHARS)
+  {
+//    Com_Printf ("Token exceeded %i chars, discarded.\n", MAX_TOKEN_CHARS);
+    len = 0;
+  }
+  com_token[len] = 0;
+
+  *data_p = ( char * ) data;
+  return com_token;
+}
+
+
+#if 0
+// no longer used
+/*
+===============
+COM_ParseInfos
+===============
+*/
+int COM_ParseInfos( char *buf, int max, char infos[][MAX_INFO_STRING] ) {
+  char  *token;
+  int   count;
+  char  key[MAX_TOKEN_CHARS];
+
+  count = 0;
+
+  while ( 1 ) {
+    token = COM_Parse( &buf );
+    if ( !token[0] ) {
+      break;
+    }
+    if ( strcmp( token, "{" ) ) {
+      Com_Printf( "Missing { in info file\n" );
+      break;
+    }
+
+    if ( count == max ) {
+      Com_Printf( "Max infos exceeded\n" );
+      break;
+    }
+
+    infos[count][0] = 0;
+    while ( 1 ) {
+      token = COM_ParseExt( &buf, qtrue );
+      if ( !token[0] ) {
+        Com_Printf( "Unexpected end of info file\n" );
+        break;
+      }
+      if ( !strcmp( token, "}" ) ) {
+        break;
+      }
+      Q_strncpyz( key, token, sizeof( key ) );
+
+      token = COM_ParseExt( &buf, qfalse );
+      if ( !token[0] ) {
+        strcpy( token, "<NULL>" );
+      }
+      Info_SetValueForKey( infos[count], key, token );
+    }
+    count++;
+  }
+
+  return count;
+}
+#endif
+
+
+/*
+==================
+COM_MatchToken
+==================
+*/
+void COM_MatchToken( char **buf_p, char *match ) {
+  char  *token;
+
+  token = COM_Parse( buf_p );
+  if ( strcmp( token, match ) ) {
+    Com_Error( ERR_DROP, "MatchToken: %s != %s", token, match );
+  }
+}
+
+
+/*
+=================
+SkipBracedSection
+
+The next token should be an open brace.
+Skips until a matching close brace is found.
+Internal brace depths are properly skipped.
+=================
+*/
+void SkipBracedSection (char **program) {
+  char      *token;
+  int       depth;
+
+  depth = 0;
+  do {
+    token = COM_ParseExt( program, qtrue );
+    if( token[1] == 0 ) {
+      if( token[0] == '{' ) {
+        depth++;
+      }
+      else if( token[0] == '}' ) {
+        depth--;
+      }
+    }
+  } while( depth && *program );
+}
+
+/*
+=================
+SkipRestOfLine
+=================
+*/
+void SkipRestOfLine ( char **data ) {
+  char  *p;
+  int   c;
+
+  p = *data;
+  while ( (c = *p++) != 0 ) {
+    if ( c == '\n' ) {
+      com_lines++;
+      break;
+    }
+  }
+
+  *data = p;
+}
+
+
+void Parse1DMatrix (char **buf_p, int x, float *m) {
+  char  *token;
+  int   i;
+
+  COM_MatchToken( buf_p, "(" );
+
+  for (i = 0 ; i < x ; i++) {
+    token = COM_Parse(buf_p);
+    m[i] = atof(token);
+  }
+
+  COM_MatchToken( buf_p, ")" );
+}
+
+void Parse2DMatrix (char **buf_p, int y, int x, float *m) {
+  int   i;
+
+  COM_MatchToken( buf_p, "(" );
+
+  for (i = 0 ; i < y ; i++) {
+    Parse1DMatrix (buf_p, x, m + i * x);
+  }
+
+  COM_MatchToken( buf_p, ")" );
+}
+
+void Parse3DMatrix (char **buf_p, int z, int y, int x, float *m) {
+  int   i;
+
+  COM_MatchToken( buf_p, "(" );
+
+  for (i = 0 ; i < z ; i++) {
+    Parse2DMatrix (buf_p, y, x, m + i * x*y);
+  }
+
+  COM_MatchToken( buf_p, ")" );
+}
+
+
+/*
+============================================================================
+
+          LIBRARY REPLACEMENT FUNCTIONS
+
+============================================================================
+*/
+
+int Q_isprint( int c )
+{
+  if ( c >= 0x20 && c <= 0x7E )
+    return ( 1 );
+  return ( 0 );
+}
+
+int Q_islower( int c )
+{
+  if (c >= 'a' && c <= 'z')
+    return ( 1 );
+  return ( 0 );
+}
+
+int Q_isupper( int c )
+{
+  if (c >= 'A' && c <= 'Z')
+    return ( 1 );
+  return ( 0 );
+}
+
+int Q_isalpha( int c )
+{
+  if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))
+    return ( 1 );
+  return ( 0 );
+}
+
+char* Q_strrchr( const char* string, int c )
+{
+  char cc = c;
+  char *s;
+  char *sp=(char *)0;
+
+  s = (char*)string;
+
+  while (*s)
+  {
+    if (*s == cc)
+      sp = s;
+    s++;
+  }
+  if (cc == 0)
+    sp = s;
+
+  return sp;
+}
+
+/*
+=============
+Q_strncpyz
+
+Safe strncpy that ensures a trailing zero
+=============
+*/
+void Q_strncpyz( char *dest, const char *src, int destsize ) {
+  if ( !src ) {
+    Com_Error( ERR_FATAL, "Q_strncpyz: NULL src" );
+  }
+  if ( destsize < 1 ) {
+    Com_Error(ERR_FATAL,"Q_strncpyz: destsize < 1" );
+  }
+
+  strncpy( dest, src, destsize-1 );
+    dest[destsize-1] = 0;
+}
+
+int Q_stricmpn (const char *s1, const char *s2, int n) {
+  int   c1, c2;
+
+  do {
+    c1 = *s1++;
+    c2 = *s2++;
+
+    if (!n--) {
+      return 0;   // strings are equal until end point
+    }
+
+    if (c1 != c2) {
+      if (c1 >= 'a' && c1 <= 'z') {
+        c1 -= ('a' - 'A');
+      }
+      if (c2 >= 'a' && c2 <= 'z') {
+        c2 -= ('a' - 'A');
+      }
+      if (c1 != c2) {
+        return c1 < c2 ? -1 : 1;
+      }
+    }
+  } while (c1);
+
+  return 0;   // strings are equal
+}
+
+int Q_strncmp (const char *s1, const char *s2, int n) {
+  int   c1, c2;
+
+  do {
+    c1 = *s1++;
+    c2 = *s2++;
+
+    if (!n--) {
+      return 0;   // strings are equal until end point
+    }
+
+    if (c1 != c2) {
+      return c1 < c2 ? -1 : 1;
+    }
+  } while (c1);
+
+  return 0;   // strings are equal
+}
+
+int Q_stricmp (const char *s1, const char *s2) {
+  return (s1 && s2) ? Q_stricmpn (s1, s2, 99999) : -1;
+}
+
+
+char *Q_strlwr( char *s1 ) {
+    char  *s;
+
+    s = s1;
+  while ( *s ) {
+    *s = tolower(*s);
+    s++;
+  }
+    return s1;
+}
+
+char *Q_strupr( char *s1 ) {
+    char  *s;
+
+    s = s1;
+  while ( *s ) {
+    *s = toupper(*s);
+    s++;
+  }
+    return s1;
+}
+
+
+// never goes past bounds or leaves without a terminating 0
+void Q_strcat( char *dest, int size, const char *src ) {
+  int   l1;
+
+  l1 = strlen( dest );
+  if ( l1 >= size ) {
+    Com_Error( ERR_FATAL, "Q_strcat: already overflowed" );
+  }
+  Q_strncpyz( dest + l1, src, size - l1 );
+}
+
+
+int Q_PrintStrlen( const char *string ) {
+  int     len;
+  const char  *p;
+
+  if( !string ) {
+    return 0;
+  }
+
+  len = 0;
+  p = string;
+  while( *p ) {
+    if( Q_IsColorString( p ) ) {
+      p += 2;
+      continue;
+    }
+    p++;
+    len++;
+  }
+
+  return len;
+}
+
+
+char *Q_CleanStr( char *string ) {
+  char* d;
+  char* s;
+  int   c;
+
+  s = string;
+  d = string;
+  while ((c = *s) != 0 ) {
+    if ( Q_IsColorString( s ) ) {
+      s++;
+    }
+    else if ( c >= 0x20 && c <= 0x7E ) {
+      *d++ = c;
+    }
+    s++;
+  }
+  *d = '\0';
+
+  return string;
+}
+
+
+void QDECL Com_sprintf( char *dest, int size, const char *fmt, ...) {
+  int   len;
+  va_list   argptr;
+  char  bigbuffer[32000]; // big, but small enough to fit in PPC stack
+
+  va_start (argptr,fmt);
+  len = vsprintf (bigbuffer,fmt,argptr);
+  va_end (argptr);
+  if ( len >= sizeof( bigbuffer ) ) {
+    Com_Error( ERR_FATAL, "Com_sprintf: overflowed bigbuffer" );
+  }
+  if (len >= size) {
+    Com_Printf ("Com_sprintf: overflow of %i in %i\n", len, size);
+  }
+  Q_strncpyz (dest, bigbuffer, size );
+}
+
+
+/*
+============
+va
+
+does a varargs printf into a temp buffer, so I don't need to have
+varargs versions of all text functions.
+FIXME: make this buffer size safe someday
+============
+*/
+char  * QDECL va( char *format, ... ) {
+  va_list   argptr;
+  static char   string[2][32000]; // in case va is called by nested functions
+  static int    index = 0;
+  char  *buf;
+
+  buf = string[index & 1];
+  index++;
+
+  va_start (argptr, format);
+  vsprintf (buf, format,argptr);
+  va_end (argptr);
+
+  return buf;
+}
+
+
+/*
+=====================================================================
+
+  INFO STRINGS
+
+=====================================================================
+*/
+
+/*
+===============
+Info_ValueForKey
+
+Searches the string for the given
+key and returns the associated value, or an empty string.
+FIXME: overflow check?
+===============
+*/
+char *Info_ValueForKey( const char *s, const char *key ) {
+  char  pkey[BIG_INFO_KEY];
+  static  char value[2][BIG_INFO_VALUE];  // use two buffers so compares
+                      // work without stomping on each other
+  static  int valueindex = 0;
+  char  *o;
+
+  if ( !s || !key ) {
+    return "";
+  }
+
+  if ( strlen( s ) >= BIG_INFO_STRING ) {
+    Com_Error( ERR_DROP, "Info_ValueForKey: oversize infostring" );
+  }
+
+  valueindex ^= 1;
+  if (*s == '\\')
+    s++;
+  while (1)
+  {
+    o = pkey;
+    while (*s != '\\')
+    {
+      if (!*s)
+        return "";
+      *o++ = *s++;
+    }
+    *o = 0;
+    s++;
+
+    o = value[valueindex];
+
+    while (*s != '\\' && *s)
+    {
+      *o++ = *s++;
+    }
+    *o = 0;
+
+    if (!Q_stricmp (key, pkey) )
+      return value[valueindex];
+
+    if (!*s)
+      break;
+    s++;
+  }
+
+  return "";
+}
+
+
+/*
+===================
+Info_NextPair
+
+Used to itterate through all the key/value pairs in an info string
+===================
+*/
+void Info_NextPair( const char **head, char *key, char *value ) {
+  char  *o;
+  const char  *s;
+
+  s = *head;
+
+  if ( *s == '\\' ) {
+    s++;
+  }
+  key[0] = 0;
+  value[0] = 0;
+
+  o = key;
+  while ( *s != '\\' ) {
+    if ( !*s ) {
+      *o = 0;
+      *head = s;
+      return;
+    }
+    *o++ = *s++;
+  }
+  *o = 0;
+  s++;
+
+  o = value;
+  while ( *s != '\\' && *s ) {
+    *o++ = *s++;
+  }
+  *o = 0;
+
+  *head = s;
+}
+
+
+/*
+===================
+Info_RemoveKey
+===================
+*/
+void Info_RemoveKey( char *s, const char *key ) {
+  char  *start;
+  char  pkey[MAX_INFO_KEY];
+  char  value[MAX_INFO_VALUE];
+  char  *o;
+
+  if ( strlen( s ) >= MAX_INFO_STRING ) {
+    Com_Error( ERR_DROP, "Info_RemoveKey: oversize infostring" );
+  }
+
+  if (strchr (key, '\\')) {
+    return;
+  }
+
+  while (1)
+  {
+    start = s;
+    if (*s == '\\')
+      s++;
+    o = pkey;
+    while (*s != '\\')
+    {
+      if (!*s)
+        return;
+      *o++ = *s++;
+    }
+    *o = 0;
+    s++;
+
+    o = value;
+    while (*s != '\\' && *s)
+    {
+      if (!*s)
+        return;
+      *o++ = *s++;
+    }
+    *o = 0;
+
+    if (!strcmp (key, pkey) )
+    {
+      strcpy (start, s);  // remove this part
+      return;
+    }
+
+    if (!*s)
+      return;
+  }
+
+}
+
+
+/*
+===================
+Info_RemoveKey_Big
+===================
+*/
+void Info_RemoveKey_Big( char *s, const char *key ) {
+  char  *start;
+  char  pkey[BIG_INFO_KEY];
+  char  value[BIG_INFO_VALUE];
+  char  *o;
+
+  if ( strlen( s ) >= BIG_INFO_STRING ) {
+    Com_Error( ERR_DROP, "Info_RemoveKey_Big: oversize infostring" );
+  }
+
+  if (strchr (key, '\\')) {
+    return;
+  }
+
+  while (1)
+  {
+    start = s;
+    if (*s == '\\')
+      s++;
+    o = pkey;
+    while (*s != '\\')
+    {
+      if (!*s)
+        return;
+      *o++ = *s++;
+    }
+    *o = 0;
+    s++;
+
+    o = value;
+    while (*s != '\\' && *s)
+    {
+      if (!*s)
+        return;
+      *o++ = *s++;
+    }
+    *o = 0;
+
+    if (!strcmp (key, pkey) )
+    {
+      strcpy (start, s);  // remove this part
+      return;
+    }
+
+    if (!*s)
+      return;
+  }
+
+}
+
+
+/*
+==================
+Info_Validate
+
+Some characters are illegal in info strings because they
+can mess up the server's parsing
+==================
+*/
+qboolean Info_Validate( const char *s ) {
+  if ( strchr( s, '\"' ) ) {
+    return qfalse;
+  }
+  if ( strchr( s, ';' ) ) {
+    return qfalse;
+  }
+  return qtrue;
+}
+
+/*
+==================
+Info_SetValueForKey
+
+Changes or adds a key/value pair
+==================
+*/
+void Info_SetValueForKey( char *s, const char *key, const char *value ) {
+  char  newi[MAX_INFO_STRING];
+
+  if ( strlen( s ) >= MAX_INFO_STRING ) {
+    Com_Error( ERR_DROP, "Info_SetValueForKey: oversize infostring" );
+  }
+
+  if (strchr (key, '\\') || strchr (value, '\\'))
+  {
+    Com_Printf ("Can't use keys or values with a \\\n");
+    return;
+  }
+
+  if (strchr (key, ';') || strchr (value, ';'))
+  {
+    Com_Printf ("Can't use keys or values with a semicolon\n");
+    return;
+  }
+
+  if (strchr (key, '\"') || strchr (value, '\"'))
+  {
+    Com_Printf ("Can't use keys or values with a \"\n");
+    return;
+  }
+
+  Info_RemoveKey (s, key);
+  if (!value || !strlen(value))
+    return;
+
+  Com_sprintf (newi, sizeof(newi), "\\%s\\%s", key, value);
+
+  if (strlen(newi) + strlen(s) > MAX_INFO_STRING)
+  {
+    Com_Printf ("Info string length exceeded\n");
+    return;
+  }
+
+  strcat (s, newi);
+}
+
+//====================================================================
+
+
+/*
+==================
+Info_SetValueForKey_Big
+
+Changes or adds a key/value pair
+==================
+*/
+void Info_SetValueForKey_Big( char *s, const char *key, const char *value ) {
+  char  newi[BIG_INFO_STRING];
+
+  if ( strlen( s ) >= BIG_INFO_STRING ) {
+    Com_Error( ERR_DROP, "Info_SetValueForKey: oversize infostring" );
+  }
+
+  if (strchr (key, '\\') || strchr (value, '\\'))
+  {
+    Com_Printf ("Can't use keys or values with a \\\n");
+    return;
+  }
+
+  if (strchr (key, ';') || strchr (value, ';'))
+  {
+    Com_Printf ("Can't use keys or values with a semicolon\n");
+    return;
+  }
+
+  if (strchr (key, '\"') || strchr (value, '\"'))
+  {
+    Com_Printf ("Can't use keys or values with a \"\n");
+    return;
+  }
+
+  Info_RemoveKey_Big (s, key);
+  if (!value || !strlen(value))
+    return;
+
+  Com_sprintf (newi, sizeof(newi), "\\%s\\%s", key, value);
+
+  if (strlen(newi) + strlen(s) > BIG_INFO_STRING)
+  {
+    Com_Printf ("BIG Info string length exceeded\n");
+    return;
+  }
+
+  strcat (s, newi);
+}
+
+
+
+//====================================================================