6212 lines
131 KiB
C
6212 lines
131 KiB
C
/*
|
|
Copyright (C) 1996-1997 Id Software, Inc.
|
|
|
|
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 "quakedef.h"
|
|
|
|
#include <wctype.h>
|
|
#include <ctype.h>
|
|
#include <errno.h>
|
|
|
|
// These 4 libraries required for the version command
|
|
|
|
#if defined(MINGW)
|
|
#if defined(AVAIL_PNGLIB) && !defined(SERVERONLY)
|
|
#include "./mingw-libs/png.h"
|
|
#endif
|
|
#ifdef AVAIL_ZLIB
|
|
#include "./mingw-libs/zlib.h"
|
|
#endif
|
|
#if defined(AVAIL_JPEGLIB) && !defined(SERVERONLY)
|
|
#define JPEG_API VARGS
|
|
//#include "./mingw-libs/jversion.h"
|
|
#include "./mingw-libs/jpeglib.h"
|
|
#endif
|
|
#ifdef FTE_SDL
|
|
#include <SDL.h>
|
|
#endif
|
|
#elif defined(_WIN32)
|
|
#if defined(AVAIL_PNGLIB) && !defined(SERVERONLY)
|
|
#include "png.h"
|
|
#endif
|
|
#ifdef AVAIL_ZLIB
|
|
#include "zlib.h"
|
|
#endif
|
|
#if defined(AVAIL_JPEGLIB) && !defined(SERVERONLY)
|
|
#define JPEG_API VARGS
|
|
//#include "jversion.h"
|
|
#include "jpeglib.h"
|
|
#endif
|
|
#ifdef FTE_SDL
|
|
#include <SDL.h>
|
|
#endif
|
|
#else
|
|
#if defined(AVAIL_PNGLIB) && !defined(SERVERONLY)
|
|
#include <png.h>
|
|
#endif
|
|
#ifdef AVAIL_ZLIB
|
|
#include <zlib.h>
|
|
#endif
|
|
#if defined(AVAIL_JPEGLIB) && !defined(SERVERONLY)
|
|
//#include <jversion.h>
|
|
#include <jpeglib.h>
|
|
#endif
|
|
#ifdef FTE_SDL
|
|
#include <SDL.h>
|
|
#endif
|
|
#endif
|
|
|
|
#define NUM_SAFE_ARGVS 6
|
|
|
|
usercmd_t nullcmd; // guarenteed to be zero
|
|
|
|
entity_state_t nullentitystate; //this is the default state
|
|
|
|
static const char *largv[MAX_NUM_ARGVS + NUM_SAFE_ARGVS + 1];
|
|
static char *argvdummy = " ";
|
|
|
|
static char *safeargvs[NUM_SAFE_ARGVS] =
|
|
{"-stdvid", "-nolan", "-nosound", "-nocdaudio", "-nojoy", "-nomouse"};
|
|
|
|
cvar_t registered = CVARD("registered","0","Set if quake's pak1.pak is available");
|
|
cvar_t gameversion = CVARFD("gameversion","", CVAR_SERVERINFO, "gamecode version for server browsers");
|
|
cvar_t gameversion_min = CVARD("gameversion_min","", "gamecode version for server browsers");
|
|
cvar_t gameversion_max = CVARD("gameversion_max","", "gamecode version for server browsers");
|
|
cvar_t fs_gamename = CVARAFD("com_fullgamename", NULL, "fs_gamename", CVAR_NOSET, "The filesystem is trying to run this game");
|
|
cvar_t fs_gamemanifest = CVARFD("fs_gamemanifest", "", CVAR_NOSET, "A small updatable file containing a description of the game, including download mirrors.");
|
|
cvar_t com_protocolname = CVARAD("com_protocolname", NULL, "com_gamename", "The protocol game name used for dpmaster queries. For compatibility with DP, you can set this to 'DarkPlaces-Quake' in order to be listed in DP's master server, and to list DP servers.");
|
|
cvar_t com_parseutf8 = CVARD("com_parseutf8", "0", "Interpret console messages/playernames/etc as UTF-8. Requires special fonts. -1=iso 8859-1. 0=quakeascii(chat uses high chars). 1=utf8, revert to ascii on decode errors. 2=utf8 ignoring errors"); //1 parse. 2 parse, but stop parsing that string if a char was malformed.
|
|
cvar_t com_parseezquake = CVARD("com_parseezquake", "0", "Treat chevron chars from configs as a per-character flag. You should use this only for compat with nquake's configs.");
|
|
cvar_t com_highlightcolor = CVARD("com_highlightcolor", STRINGIFY(COLOR_RED), "ANSI colour to be used for highlighted text, used when com_parseutf8 is active.");
|
|
cvar_t com_nogamedirnativecode = CVARFD("com_nogamedirnativecode", "1", CVAR_NOTFROMSERVER, FULLENGINENAME" blocks all downloads of files with a .dll or .so extension, however other engines (eg: ezquake and fodquake) do not - this omission can be used to trigger delayed eremote exploits in any engine (including "DISTRIBUTION") which is later run from the same gamedir.\nQuake2, Quake3(when debugging), and KTX typically run native gamecode from within gamedirs, so if you wish to run any of these games you will need to ensure this cvar is changed to 0, as well as ensure that you don't run unsafe clients.\n");
|
|
cvar_t sys_platform = CVAR("sys_platform", PLATFORM);
|
|
|
|
qboolean com_modified; // set true if using non-id files
|
|
|
|
qboolean static_registered = true; // only for startup check, then set
|
|
|
|
qboolean msg_suppress_1 = false;
|
|
int isPlugin; //if 2, we qcdebug to external program
|
|
qboolean wantquit;
|
|
|
|
void COM_Path_f (void);
|
|
void COM_Dir_f (void);
|
|
void COM_Locate_f (void);
|
|
|
|
|
|
// if a packfile directory differs from this, it is assumed to be hacked
|
|
#define PAK0_COUNT 339
|
|
#define PAK0_CRC 52883
|
|
|
|
qboolean standard_quake = true, rogue, hipnotic;
|
|
|
|
/*
|
|
|
|
|
|
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.
|
|
|
|
The "cache directory" is only used during development to save network bandwidth, especially over ISDN / T1 lines. If there is a cache directory
|
|
specified, when a file is found by the normal search path, it will be mirrored
|
|
into the cache directory, then opened there.
|
|
|
|
*/
|
|
|
|
//============================================================================
|
|
|
|
|
|
// 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;
|
|
}
|
|
void InsertLinkAfter (link_t *l, link_t *after)
|
|
{
|
|
l->next = after->next;
|
|
l->prev = after;
|
|
l->prev->next = l;
|
|
l->next->prev = l;
|
|
}
|
|
|
|
/*
|
|
============================================================================
|
|
|
|
LIBRARY REPLACEMENT FUNCTIONS
|
|
|
|
============================================================================
|
|
*/
|
|
|
|
void QDECL Q_strncpyz(char *d, const char *s, int n)
|
|
{
|
|
int i;
|
|
n--;
|
|
if (n < 0)
|
|
return; //this could be an error
|
|
|
|
for (i=0; *s; i++)
|
|
{
|
|
if (i == n)
|
|
break;
|
|
*d++ = *s++;
|
|
}
|
|
*d='\0';
|
|
}
|
|
|
|
//windows/linux have inconsistant snprintf
|
|
//this is an attempt to get them consistant and safe
|
|
//size is the total size of the buffer
|
|
void VARGS Q_vsnprintfz (char *dest, size_t size, const char *fmt, va_list argptr)
|
|
{
|
|
vsnprintf (dest, size, fmt, argptr);
|
|
dest[size-1] = 0;
|
|
}
|
|
|
|
//windows/linux have inconsistant snprintf
|
|
//this is an attempt to get them consistant and safe
|
|
//size is the total size of the buffer
|
|
void VARGS Q_snprintfz (char *dest, size_t size, const char *fmt, ...)
|
|
{
|
|
va_list argptr;
|
|
|
|
va_start (argptr, fmt);
|
|
Q_vsnprintfz(dest, size, fmt, argptr);
|
|
va_end (argptr);
|
|
}
|
|
|
|
|
|
#if 0
|
|
void Q_memset (void *dest, int fill, int count)
|
|
{
|
|
int i;
|
|
|
|
if ( (((long)dest | count) & 3) == 0)
|
|
{
|
|
count >>= 2;
|
|
fill = fill | (fill<<8) | (fill<<16) | (fill<<24);
|
|
for (i=0 ; i<count ; i++)
|
|
((int *)dest)[i] = fill;
|
|
}
|
|
else
|
|
for (i=0 ; i<count ; i++)
|
|
((qbyte *)dest)[i] = fill;
|
|
}
|
|
|
|
void Q_memcpy (void *dest, void *src, int count)
|
|
{
|
|
int i;
|
|
|
|
if (( ( (long)dest | (long)src | count) & 3) == 0 )
|
|
{
|
|
count>>=2;
|
|
for (i=0 ; i<count ; i++)
|
|
((int *)dest)[i] = ((int *)src)[i];
|
|
}
|
|
else
|
|
for (i=0 ; i<count ; i++)
|
|
((qbyte *)dest)[i] = ((qbyte *)src)[i];
|
|
}
|
|
|
|
int Q_memcmp (void *m1, void *m2, int count)
|
|
{
|
|
while(count)
|
|
{
|
|
count--;
|
|
if (((qbyte *)m1)[count] != ((qbyte *)m2)[count])
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void Q_strcpy (char *dest, char *src)
|
|
{
|
|
while (*src)
|
|
{
|
|
*dest++ = *src++;
|
|
}
|
|
*dest++ = 0;
|
|
}
|
|
|
|
void Q_strncpy (char *dest, char *src, int count)
|
|
{
|
|
while (*src && count--)
|
|
{
|
|
*dest++ = *src++;
|
|
}
|
|
if (count)
|
|
*dest++ = 0;
|
|
}
|
|
|
|
int Q_strlen (char *str)
|
|
{
|
|
int count;
|
|
|
|
count = 0;
|
|
while (str[count])
|
|
count++;
|
|
|
|
return count;
|
|
}
|
|
|
|
char *Q_strrchr(char *s, char c)
|
|
{
|
|
int len = Q_strlen(s);
|
|
s += len;
|
|
while (len--)
|
|
if (*--s == c) return s;
|
|
return 0;
|
|
}
|
|
|
|
void Q_strcat (char *dest, char *src)
|
|
{
|
|
dest += Q_strlen(dest);
|
|
Q_strcpy (dest, src);
|
|
}
|
|
|
|
int Q_strcmp (char *s1, char *s2)
|
|
{
|
|
while (1)
|
|
{
|
|
if (*s1 != *s2)
|
|
return -1; // strings not equal
|
|
if (!*s1)
|
|
return 0; // strings are equal
|
|
s1++;
|
|
s2++;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
int Q_strncmp (char *s1, char *s2, int count)
|
|
{
|
|
while (1)
|
|
{
|
|
if (!count--)
|
|
return 0;
|
|
if (*s1 != *s2)
|
|
return -1; // strings not equal
|
|
if (!*s1)
|
|
return 0; // strings are equal
|
|
s1++;
|
|
s2++;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
#endif
|
|
|
|
int Q_strncasecmp (const char *s1, const char *s2, int n)
|
|
{
|
|
int c1, c2;
|
|
|
|
while (1)
|
|
{
|
|
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)
|
|
{ // strings not equal
|
|
if (c1 > c2)
|
|
return 1; // strings not equal
|
|
return -1;
|
|
}
|
|
}
|
|
if (!c1)
|
|
return 0; // strings are equal
|
|
// s1++;
|
|
// s2++;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
int Q_strcasecmp (const char *s1, const char *s2)
|
|
{
|
|
return Q_strncasecmp (s1, s2, 99999);
|
|
}
|
|
int QDECL Q_stricmp (const char *s1, const char *s2)
|
|
{
|
|
return Q_strncasecmp (s1, s2, 99999);
|
|
}
|
|
|
|
char *Q_strcasestr(const char *haystack, const char *needle)
|
|
{
|
|
int c1, c2, c2f;
|
|
int i;
|
|
c2f = *needle;
|
|
if (c2f >= 'a' && c2f <= 'z')
|
|
c2f -= ('a' - 'A');
|
|
if (!c2f)
|
|
return (char*)haystack;
|
|
while (1)
|
|
{
|
|
c1 = *haystack;
|
|
if (!c1)
|
|
return NULL;
|
|
if (c1 >= 'a' && c1 <= 'z')
|
|
c1 -= ('a' - 'A');
|
|
if (c1 == c2f)
|
|
{
|
|
for (i = 1; ; i++)
|
|
{
|
|
c1 = haystack[i];
|
|
c2 = needle[i];
|
|
if (c1 >= 'a' && c1 <= 'z')
|
|
c1 -= ('a' - 'A');
|
|
if (c2 >= 'a' && c2 <= 'z')
|
|
c2 -= ('a' - 'A');
|
|
if (!c2)
|
|
return (char*)haystack; //end of needle means we found a complete match
|
|
if (!c1) //end of haystack means we can't possibly find needle in it any more
|
|
return NULL;
|
|
if (c1 != c2) //mismatch means no match starting at haystack[0]
|
|
break;
|
|
}
|
|
}
|
|
haystack++;
|
|
}
|
|
return NULL; //didn't find it
|
|
}
|
|
|
|
int QDECL Q_vsnprintf(char *buffer, int size, const char *format, va_list argptr)
|
|
{
|
|
return vsnprintf(buffer, size, format, argptr);
|
|
}
|
|
|
|
int VARGS Com_sprintf(char *buffer, int size, const char *format, ...)
|
|
{
|
|
int ret;
|
|
va_list argptr;
|
|
|
|
va_start (argptr, format);
|
|
ret = vsnprintf (buffer, size, format, argptr);
|
|
va_end (argptr);
|
|
|
|
return ret;
|
|
}
|
|
void QDECL Com_Error( int level, const char *error, ... )
|
|
{
|
|
Sys_Error("%s", error);
|
|
}
|
|
|
|
char *Q_strlwr(char *s)
|
|
{
|
|
char *ret=s;
|
|
while(*s)
|
|
{
|
|
if (*s >= 'A' && *s <= 'Z')
|
|
*s=*s-'A'+'a';
|
|
s++;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
int wildcmp(const char *wild, const char *string)
|
|
{
|
|
/*
|
|
while ((*string) && (*wild != '*'))
|
|
{
|
|
if ((*wild != *string) && (*wild != '?'))
|
|
{
|
|
return 0;
|
|
}
|
|
wild++;
|
|
string++;
|
|
}
|
|
*/
|
|
while (*string)
|
|
{
|
|
if (*wild == '*')
|
|
{
|
|
if (*string == '/' || *string == '\\')
|
|
{
|
|
//* terminates if we get a match on the char following it, or if its a \ or / char
|
|
wild++;
|
|
continue;
|
|
}
|
|
if (wildcmp(wild+1, string))
|
|
return true;
|
|
string++;
|
|
}
|
|
else if ((*wild == *string) || (*wild == '?'))
|
|
{
|
|
//this char matches
|
|
wild++;
|
|
string++;
|
|
}
|
|
else
|
|
{
|
|
//failure
|
|
return false;
|
|
}
|
|
}
|
|
|
|
while (*wild == '*')
|
|
{
|
|
wild++;
|
|
}
|
|
return !*wild;
|
|
}
|
|
|
|
// Q_ftoa: convert IEEE 754 float to a base-10 string with "infinite" decimal places
|
|
void Q_ftoa(char *str, float in)
|
|
{
|
|
unsigned int i = *((int *)&in);
|
|
|
|
int signbit = (i & 0x80000000) >> 31;
|
|
int exp = (signed int)((i & 0x7F800000) >> 23) - 127;
|
|
int mantissa = (i & 0x007FFFFF);
|
|
|
|
if (exp == 128) // 255(NaN/Infinity bits) - 127(bias)
|
|
{
|
|
if (signbit)
|
|
{
|
|
*str = '-';
|
|
str++;
|
|
}
|
|
if (mantissa == 0) // infinity
|
|
strcpy(str, "1.#INF");
|
|
else // NaN or indeterminate
|
|
strcpy(str, "1.#NAN");
|
|
return;
|
|
}
|
|
|
|
exp = -exp;
|
|
exp = (int)(exp * 0.30102999957f); // convert base 2 to base 10
|
|
exp += 8;
|
|
|
|
if (exp <= 0)
|
|
sprintf(str, "%.0f", in);
|
|
else
|
|
{
|
|
char tstr[8];
|
|
char *lsig = str - 1;
|
|
sprintf(tstr, "%%.%if", exp);
|
|
sprintf(str, tstr, in);
|
|
// find last significant digit and trim
|
|
while (*str)
|
|
{
|
|
if (*str >= '1' && *str <= '9')
|
|
lsig = str;
|
|
else if (*str == '.')
|
|
lsig = str - 1;
|
|
str++;
|
|
}
|
|
lsig[1] = '\0';
|
|
}
|
|
}
|
|
|
|
static int dehex(int i)
|
|
{
|
|
if (i >= '0' && i <= '9')
|
|
return (i-'0');
|
|
else if (i >= 'A' && i <= 'F')
|
|
return (i-'A'+10);
|
|
else
|
|
return (i-'a'+10);
|
|
}
|
|
|
|
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;
|
|
|
|
while(*str == ' ')
|
|
str++;
|
|
|
|
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;
|
|
}
|
|
|
|
/*
|
|
attempts to remove leet strange chars from a name
|
|
the resulting string is not intended to be visible to humans, but this functions results can be matched against each other.
|
|
*/
|
|
void deleetstring(char *result, const char *leet)
|
|
{
|
|
char *s = result;
|
|
const char *s2 = leet;
|
|
while(*s2)
|
|
{
|
|
if (*s2 == (char)0xff)
|
|
{
|
|
s2++;
|
|
continue;
|
|
}
|
|
*s = *s2 & ~128;
|
|
s2++;
|
|
if (*s == '3')
|
|
*s = 'e';
|
|
else if (*s == '4')
|
|
*s = 'a';
|
|
else if (*s == '0')
|
|
*s = 'o';
|
|
else if (*s == '1' || *s == '7')
|
|
*s = 'l';
|
|
else if (*s >= 18 && *s < 27)
|
|
*s = *s - 18 + '0';
|
|
else if (*s >= 'A' && *s <= 'Z')
|
|
*s = *s - 'A' + 'a';
|
|
else if (*s == '_' || *s == ' ' || *s == '~')
|
|
continue;
|
|
s++;
|
|
}
|
|
*s = '\0';
|
|
}
|
|
|
|
|
|
/*
|
|
============================================================================
|
|
|
|
qbyte ORDER FUNCTIONS
|
|
|
|
============================================================================
|
|
*/
|
|
|
|
qboolean bigendian;
|
|
|
|
short (*BigShort) (short l);
|
|
short (*LittleShort) (short l);
|
|
int (*BigLong) (int l);
|
|
int (*LittleLong) (int l);
|
|
float (*BigFloat) (float l);
|
|
float (*LittleFloat) (float l);
|
|
|
|
short ShortSwap (short l)
|
|
{
|
|
qbyte b1,b2;
|
|
|
|
b1 = l&255;
|
|
b2 = (l>>8)&255;
|
|
|
|
return (b1<<8) + b2;
|
|
}
|
|
|
|
short ShortNoSwap (short l)
|
|
{
|
|
return l;
|
|
}
|
|
|
|
int LongSwap (int l)
|
|
{
|
|
qbyte 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;
|
|
}
|
|
|
|
float FloatSwap (float f)
|
|
{
|
|
union
|
|
{
|
|
float f;
|
|
qbyte 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;
|
|
}
|
|
|
|
void COM_SwapLittleShortBlock (short *s, int size)
|
|
{
|
|
if (size <= 0)
|
|
return;
|
|
|
|
if (!bigendian)
|
|
return;
|
|
|
|
while (size)
|
|
{
|
|
*s = ShortSwap(*s);
|
|
s++;
|
|
size--;
|
|
}
|
|
}
|
|
|
|
void COM_CharBias (signed char *c, int size)
|
|
{
|
|
if (size <= 0)
|
|
return;
|
|
|
|
while (size)
|
|
{
|
|
*c = (*(unsigned char *)c) - 128;
|
|
c++;
|
|
size--;
|
|
}
|
|
}
|
|
|
|
/*
|
|
==============================================================================
|
|
|
|
MESSAGE IO FUNCTIONS
|
|
|
|
Handles qbyte ordering and avoids alignment errors
|
|
==============================================================================
|
|
*/
|
|
|
|
//
|
|
// writing functions
|
|
//
|
|
|
|
void MSG_WriteChar (sizebuf_t *sb, int c)
|
|
{
|
|
qbyte *buf;
|
|
|
|
#ifdef PARANOID
|
|
if (c < -128 || c > 127)
|
|
Sys_Error ("MSG_WriteChar: range error");
|
|
#endif
|
|
|
|
buf = (qbyte*)SZ_GetSpace (sb, 1);
|
|
buf[0] = c;
|
|
}
|
|
|
|
void MSG_WriteByte (sizebuf_t *sb, int c)
|
|
{
|
|
qbyte *buf;
|
|
|
|
#ifdef PARANOID
|
|
if (c < 0 || c > 255)
|
|
Sys_Error ("MSG_WriteByte: range error");
|
|
#endif
|
|
|
|
buf = (qbyte*)SZ_GetSpace (sb, 1);
|
|
buf[0] = c;
|
|
}
|
|
|
|
void MSG_WriteShort (sizebuf_t *sb, int c)
|
|
{
|
|
qbyte *buf;
|
|
|
|
#ifdef PARANOID
|
|
if (c < ((short)0x8000) || c > (short)0x7fff)
|
|
Sys_Error ("MSG_WriteShort: range error");
|
|
#endif
|
|
|
|
buf = (qbyte*)SZ_GetSpace (sb, 2);
|
|
buf[0] = c&0xff;
|
|
buf[1] = c>>8;
|
|
}
|
|
|
|
void MSG_WriteLong (sizebuf_t *sb, int c)
|
|
{
|
|
qbyte *buf;
|
|
|
|
buf = (qbyte*)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)
|
|
{
|
|
union
|
|
{
|
|
float f;
|
|
int l;
|
|
} dat;
|
|
|
|
|
|
dat.f = f;
|
|
dat.l = LittleLong (dat.l);
|
|
|
|
SZ_Write (sb, &dat.l, 4);
|
|
}
|
|
|
|
void MSG_WriteString (sizebuf_t *sb, const char *s)
|
|
{
|
|
if (!s)
|
|
SZ_Write (sb, "", 1);
|
|
else
|
|
SZ_Write (sb, s, Q_strlen(s)+1);
|
|
}
|
|
|
|
float MSG_FromCoord(coorddata c, int bytes)
|
|
{
|
|
switch(bytes)
|
|
{
|
|
case 2: //encode 1/8th precision, giving -4096 to 4096 map sizes
|
|
return LittleShort(c.b2)/8.0f;
|
|
case 3:
|
|
return LittleShort(c.b2) + (((unsigned char*)c.b)[2] * (1/255.0)); /*FIXME: RMQe uses 255, should be 256*/
|
|
case 4:
|
|
return LittleFloat(c.f);
|
|
default:
|
|
Sys_Error("MSG_ToCoord: not a sane coordsize");
|
|
return 0;
|
|
}
|
|
}
|
|
coorddata MSG_ToCoord(float f, int bytes) //return value should be treated as (char*)&ret;
|
|
{
|
|
coorddata r;
|
|
switch(bytes)
|
|
{
|
|
case 2:
|
|
r.b4 = 0;
|
|
if (f >= 0)
|
|
r.b2 = LittleShort((short)(f*8+0.5f));
|
|
else
|
|
r.b2 = LittleShort((short)(f*8-0.5f));
|
|
break;
|
|
case 4:
|
|
r.f = LittleFloat(f);
|
|
break;
|
|
default:
|
|
Sys_Error("MSG_ToCoord: not a sane coordsize");
|
|
r.b4 = 0;
|
|
}
|
|
|
|
return r;
|
|
}
|
|
|
|
coorddata MSG_ToAngle(float f, int bytes) //return value is NOT byteswapped.
|
|
{
|
|
coorddata r;
|
|
switch(bytes)
|
|
{
|
|
case 1:
|
|
r.b4 = 0;
|
|
if (f >= 0)
|
|
r.b[0] = (int)(f*(256.0f/360.0f) + 0.5f) & 255;
|
|
else
|
|
r.b[0] = (int)(f*(256.0f/360.0f) - 0.5f) & 255;
|
|
break;
|
|
case 2:
|
|
r.b4 = 0;
|
|
if (f >= 0)
|
|
r.b2 = LittleShort((int)(f*(65536.0f/360.0f) + 0.5f) & 65535);
|
|
else
|
|
r.b2 = LittleShort((int)(f*(65536.0f/360.0f) - 0.5f) & 65535);
|
|
break;
|
|
case 4:
|
|
r.f = LittleFloat(f);
|
|
break;
|
|
default:
|
|
Sys_Error("MSG_ToCoord: not a sane coordsize");
|
|
r.b4 = 0;
|
|
}
|
|
|
|
return r;
|
|
}
|
|
|
|
void MSG_WriteCoord (sizebuf_t *sb, float f)
|
|
{
|
|
coorddata i = MSG_ToCoord(f, sb->prim.coordsize);
|
|
SZ_Write (sb, (void*)&i, sb->prim.coordsize);
|
|
}
|
|
|
|
void MSG_WriteAngle16 (sizebuf_t *sb, float f)
|
|
{
|
|
if (f >= 0)
|
|
MSG_WriteShort (sb, (int)(f*(65536.0f/360.0f) + 0.5f) & 65535);
|
|
else
|
|
MSG_WriteShort (sb, (int)(f*(65536.0f/360.0f) - 0.5f) & 65535);
|
|
}
|
|
void MSG_WriteAngle8 (sizebuf_t *sb, float f)
|
|
{
|
|
if (f >= 0)
|
|
MSG_WriteByte (sb, (int)(f*(256.0f/360.0f) + 0.5f) & 255);
|
|
else
|
|
MSG_WriteByte (sb, (int)(f*(256.0f/360.0f) - 0.5f) & 255);
|
|
}
|
|
|
|
void MSG_WriteAngle (sizebuf_t *sb, float f)
|
|
{
|
|
if (sb->prim.anglesize==2)
|
|
MSG_WriteAngle16(sb, f);
|
|
else if (sb->prim.anglesize==4)
|
|
MSG_WriteFloat(sb, f);
|
|
else
|
|
MSG_WriteAngle8 (sb, f);
|
|
}
|
|
|
|
static unsigned int MSG_ReadEntity(void)
|
|
{
|
|
unsigned int num;
|
|
num = MSG_ReadShort();
|
|
if (num & 0x8000)
|
|
{
|
|
num = (num & 0x7fff) << 8;
|
|
num |= MSG_ReadByte();
|
|
}
|
|
return num;
|
|
}
|
|
//we use the high bit of the entity number to state that this is a large entity.
|
|
#ifndef CLIENTONLY
|
|
unsigned int MSGSV_ReadEntity(client_t *fromclient)
|
|
{
|
|
unsigned int num;
|
|
if (fromclient->fteprotocolextensions2 & PEXT2_REPLACEMENTDELTAS)
|
|
num = MSG_ReadEntity();
|
|
else
|
|
num = (unsigned short)(short)MSG_ReadEntity();
|
|
if (num >= sv.world.max_edicts)
|
|
{
|
|
Con_Printf("client %s sent invalid entity\n", fromclient->name);
|
|
fromclient->drop = true;
|
|
return 0;
|
|
}
|
|
return num;
|
|
}
|
|
#endif
|
|
#ifndef SERVERONLY
|
|
unsigned int MSGCL_ReadEntity(void)
|
|
{
|
|
unsigned int num;
|
|
if (cls.fteprotocolextensions2 & PEXT2_REPLACEMENTDELTAS)
|
|
num = MSG_ReadEntity();
|
|
else
|
|
num = (unsigned short)(short)MSG_ReadShort();
|
|
return num;
|
|
}
|
|
//compat for ktx/ezquake's railgun
|
|
unsigned int MSGCLF_ReadEntity(qboolean *flagged)
|
|
{
|
|
int s;
|
|
*flagged = false;
|
|
if (cls.fteprotocolextensions2 & PEXT2_REPLACEMENTDELTAS)
|
|
return MSG_ReadEntity();
|
|
else
|
|
{
|
|
s = MSG_ReadShort();
|
|
if (s < 0)
|
|
{
|
|
*flagged = true;
|
|
return -1 -s;
|
|
}
|
|
else
|
|
return s;
|
|
}
|
|
}
|
|
#endif
|
|
void MSG_WriteEntity(sizebuf_t *sb, unsigned int entnum)
|
|
{
|
|
if (entnum > MAX_EDICTS)
|
|
Host_EndGame("index %#x is not a valid entity\n", entnum);
|
|
|
|
if (entnum >= 0x8000)
|
|
{
|
|
MSG_WriteShort(sb, (entnum>>8) | 0x8000);
|
|
MSG_WriteByte(sb, entnum & 0xff);
|
|
}
|
|
else
|
|
MSG_WriteShort(sb, entnum);
|
|
}
|
|
|
|
void MSG_WriteDeltaUsercmd (sizebuf_t *buf, usercmd_t *from, usercmd_t *cmd)
|
|
{
|
|
int bits;
|
|
|
|
//
|
|
// send the movement message
|
|
//
|
|
bits = 0;
|
|
#ifdef Q2CLIENT
|
|
if (cls.protocol == CP_QUAKE2)
|
|
{
|
|
if (cmd->angles[0] != from->angles[0])
|
|
bits |= Q2CM_ANGLE1;
|
|
if (cmd->angles[1] != from->angles[1])
|
|
bits |= Q2CM_ANGLE2;
|
|
if (cmd->angles[2] != from->angles[2])
|
|
bits |= Q2CM_ANGLE3;
|
|
if (cmd->forwardmove != from->forwardmove)
|
|
bits |= Q2CM_FORWARD;
|
|
if (cmd->sidemove != from->sidemove)
|
|
bits |= Q2CM_SIDE;
|
|
if (cmd->upmove != from->upmove)
|
|
bits |= Q2CM_UP;
|
|
if (cmd->buttons != from->buttons)
|
|
bits |= Q2CM_BUTTONS;
|
|
if (cmd->impulse != from->impulse)
|
|
bits |= Q2CM_IMPULSE;
|
|
|
|
MSG_WriteByte (buf, bits);
|
|
|
|
if (bits & Q2CM_ANGLE1)
|
|
MSG_WriteShort (buf, cmd->angles[0]);
|
|
if (bits & Q2CM_ANGLE2)
|
|
MSG_WriteShort (buf, cmd->angles[1]);
|
|
if (bits & Q2CM_ANGLE3)
|
|
MSG_WriteShort (buf, cmd->angles[2]);
|
|
|
|
if (bits & Q2CM_FORWARD)
|
|
MSG_WriteShort (buf, cmd->forwardmove);
|
|
if (bits & Q2CM_SIDE)
|
|
MSG_WriteShort (buf, cmd->sidemove);
|
|
if (bits & Q2CM_UP)
|
|
MSG_WriteShort (buf, cmd->upmove);
|
|
|
|
if (bits & Q2CM_BUTTONS)
|
|
MSG_WriteByte (buf, cmd->buttons);
|
|
if (bits & Q2CM_IMPULSE)
|
|
MSG_WriteByte (buf, cmd->impulse);
|
|
MSG_WriteByte (buf, cmd->msec);
|
|
|
|
MSG_WriteByte (buf, cmd->lightlevel);
|
|
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
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_WriteShort (buf, cmd->angles[0]);
|
|
if (bits & CM_ANGLE2)
|
|
MSG_WriteShort (buf, cmd->angles[1]);
|
|
if (bits & CM_ANGLE3)
|
|
MSG_WriteShort (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&0xff);
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// reading functions
|
|
//
|
|
int msg_readcount;
|
|
qboolean msg_badread;
|
|
struct netprim_s msg_nullnetprim;
|
|
|
|
void MSG_BeginReading (struct netprim_s prim)
|
|
{
|
|
msg_readcount = 0;
|
|
msg_badread = false;
|
|
net_message.currentbit = 0;
|
|
net_message.packing = SZ_RAWBYTES;
|
|
net_message.prim = prim;
|
|
}
|
|
|
|
void MSG_ChangePrimitives(struct netprim_s prim)
|
|
{
|
|
net_message.prim = prim;
|
|
}
|
|
|
|
int MSG_GetReadCount(void)
|
|
{
|
|
return msg_readcount;
|
|
}
|
|
|
|
|
|
/*
|
|
============
|
|
MSG_ReadRawBytes
|
|
============
|
|
*/
|
|
static int MSG_ReadRawBytes(sizebuf_t *msg, int bits)
|
|
{
|
|
int bitmask = 0;
|
|
|
|
if (bits <= 8)
|
|
{
|
|
bitmask = (unsigned char)msg->data[msg_readcount];
|
|
msg_readcount++;
|
|
msg->currentbit += 8;
|
|
}
|
|
else if (bits <= 16)
|
|
{
|
|
bitmask = (unsigned short)(msg->data[msg_readcount]
|
|
+ (msg->data[msg_readcount+1] << 8));
|
|
msg_readcount += 2;
|
|
msg->currentbit += 16;
|
|
}
|
|
else if (bits <= 32)
|
|
{
|
|
bitmask = msg->data[msg_readcount]
|
|
+ (msg->data[msg_readcount+1] << 8)
|
|
+ (msg->data[msg_readcount+2] << 16)
|
|
+ (msg->data[msg_readcount+3] << 24);
|
|
msg_readcount += 4;
|
|
msg->currentbit += 32;
|
|
}
|
|
|
|
return bitmask;
|
|
}
|
|
|
|
/*
|
|
============
|
|
MSG_ReadRawBits
|
|
============
|
|
*/
|
|
static int MSG_ReadRawBits(sizebuf_t *msg, int bits)
|
|
{
|
|
int i;
|
|
int val;
|
|
int bitmask = 0;
|
|
|
|
for(i=0 ; i<bits ; i++)
|
|
{
|
|
val = msg->data[msg->currentbit >> 3] >> (msg->currentbit & 7);
|
|
msg->currentbit++;
|
|
bitmask |= (val & 1) << i;
|
|
}
|
|
|
|
return bitmask;
|
|
}
|
|
|
|
#ifdef HUFFNETWORK
|
|
/*
|
|
============
|
|
MSG_ReadHuffBits
|
|
============
|
|
*/
|
|
static int MSG_ReadHuffBits(sizebuf_t *msg, int bits)
|
|
{
|
|
int i;
|
|
int val;
|
|
int bitmask;
|
|
int remaining = bits & 7;
|
|
|
|
bitmask = MSG_ReadRawBits(msg, remaining);
|
|
|
|
for (i=0 ; i<bits-remaining ; i+=8)
|
|
{
|
|
val = Huff_GetByte(msg->data, &msg->currentbit);
|
|
bitmask |= val << (i + remaining);
|
|
}
|
|
|
|
msg_readcount = (msg->currentbit >> 3) + 1;
|
|
|
|
return bitmask;
|
|
}
|
|
#endif
|
|
|
|
int MSG_ReadBits(int bits)
|
|
{
|
|
int bitmask = 0;
|
|
qboolean extend = false;
|
|
|
|
#ifdef PARANOID
|
|
if (!bits || bits < -31 || bits > 32)
|
|
Host_EndGame("MSG_ReadBits: bad bits %i", bits );
|
|
#endif
|
|
|
|
if (bits < 0)
|
|
{
|
|
bits = -bits;
|
|
extend = true;
|
|
}
|
|
|
|
switch(net_message.packing)
|
|
{
|
|
default:
|
|
case SZ_BAD:
|
|
Sys_Error("MSG_ReadBits: bad net_message.packing");
|
|
break;
|
|
case SZ_RAWBYTES:
|
|
bitmask = MSG_ReadRawBytes(&net_message, bits);
|
|
break;
|
|
case SZ_RAWBITS:
|
|
bitmask = MSG_ReadRawBits(&net_message, bits);
|
|
break;
|
|
#ifdef HUFFNETWORK
|
|
case SZ_HUFFMAN:
|
|
bitmask = MSG_ReadHuffBits(&net_message, bits);
|
|
break;
|
|
#endif
|
|
}
|
|
|
|
if (extend)
|
|
{
|
|
if(bitmask & (1 << (bits - 1)))
|
|
{
|
|
bitmask |= ~((1 << bits) - 1);
|
|
}
|
|
}
|
|
|
|
return bitmask;
|
|
}
|
|
|
|
void MSG_ReadSkip(int bytes)
|
|
{
|
|
if (net_message.packing!=SZ_RAWBYTES)
|
|
{
|
|
while (bytes > 4)
|
|
{
|
|
MSG_ReadBits(32);
|
|
bytes-=4;
|
|
}
|
|
while (bytes > 0)
|
|
{
|
|
MSG_ReadBits(8);
|
|
bytes--;
|
|
}
|
|
}
|
|
if (msg_readcount+bytes > net_message.cursize)
|
|
{
|
|
msg_readcount = net_message.cursize;
|
|
msg_badread = true;
|
|
return;
|
|
}
|
|
msg_readcount += bytes;
|
|
}
|
|
|
|
|
|
// returns -1 and sets msg_badread if no more characters are available
|
|
int MSG_ReadChar (void)
|
|
{
|
|
int c;
|
|
|
|
if (net_message.packing!=SZ_RAWBYTES)
|
|
return (signed char)MSG_ReadBits(8);
|
|
|
|
if (msg_readcount+1 > net_message.cursize)
|
|
{
|
|
msg_badread = true;
|
|
return -1;
|
|
}
|
|
|
|
c = (signed char)net_message.data[msg_readcount];
|
|
msg_readcount++;
|
|
|
|
return c;
|
|
}
|
|
|
|
int MSG_ReadByte (void)
|
|
{
|
|
unsigned char c;
|
|
|
|
if (net_message.packing!=SZ_RAWBYTES)
|
|
return (unsigned char)MSG_ReadBits(8);
|
|
|
|
if (msg_readcount+1 > net_message.cursize)
|
|
{
|
|
msg_badread = true;
|
|
return -1;
|
|
}
|
|
|
|
c = (unsigned char)net_message.data[msg_readcount];
|
|
msg_readcount++;
|
|
|
|
return c;
|
|
}
|
|
|
|
int MSG_ReadShort (void)
|
|
{
|
|
int c;
|
|
|
|
if (net_message.packing!=SZ_RAWBYTES)
|
|
return (short)MSG_ReadBits(16);
|
|
|
|
if (msg_readcount+2 > net_message.cursize)
|
|
{
|
|
msg_badread = true;
|
|
return -1;
|
|
}
|
|
|
|
c = (short)(net_message.data[msg_readcount]
|
|
+ (net_message.data[msg_readcount+1]<<8));
|
|
|
|
msg_readcount += 2;
|
|
|
|
return c;
|
|
}
|
|
|
|
int MSG_ReadLong (void)
|
|
{
|
|
int c;
|
|
|
|
if (net_message.packing!=SZ_RAWBYTES)
|
|
return (int)MSG_ReadBits(32);
|
|
|
|
if (msg_readcount+4 > net_message.cursize)
|
|
{
|
|
msg_badread = true;
|
|
return -1;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
float MSG_ReadFloat (void)
|
|
{
|
|
union
|
|
{
|
|
qbyte b[4];
|
|
float f;
|
|
int l;
|
|
} dat;
|
|
|
|
if (net_message.packing!=SZ_RAWBYTES)
|
|
{
|
|
dat.l = MSG_ReadBits(32);
|
|
return dat.f;
|
|
}
|
|
|
|
if (msg_readcount+4 > net_message.cursize)
|
|
{
|
|
msg_badread = true;
|
|
return -1;
|
|
}
|
|
|
|
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;
|
|
|
|
dat.l = LittleLong (dat.l);
|
|
|
|
return dat.f;
|
|
}
|
|
|
|
char *MSG_ReadStringBuffer (char *out, size_t outsize)
|
|
{
|
|
int l,c;
|
|
|
|
l = 0;
|
|
do
|
|
{
|
|
c = MSG_ReadChar ();
|
|
if (msg_badread || c == 0)
|
|
break;
|
|
out[l] = c;
|
|
l++;
|
|
} while (l < outsize-1);
|
|
|
|
out[l] = 0;
|
|
|
|
return out;
|
|
}
|
|
char *MSG_ReadString (void)
|
|
{
|
|
static char string[8192];
|
|
int l,c;
|
|
|
|
l = 0;
|
|
do
|
|
{
|
|
c = MSG_ReadChar ();
|
|
if (msg_badread || c == 0)
|
|
break;
|
|
string[l] = c;
|
|
l++;
|
|
} while (l < sizeof(string)-1);
|
|
|
|
string[l] = 0;
|
|
|
|
return string;
|
|
}
|
|
|
|
char *MSG_ReadStringLine (void)
|
|
{
|
|
static char string[2048];
|
|
int l,c;
|
|
|
|
l = 0;
|
|
do
|
|
{
|
|
c = MSG_ReadChar ();
|
|
if (msg_badread || c == 0 || c == '\n')
|
|
break;
|
|
string[l] = c;
|
|
l++;
|
|
} while (l < sizeof(string)-1);
|
|
|
|
string[l] = 0;
|
|
|
|
return string;
|
|
}
|
|
|
|
float MSG_ReadCoord (void)
|
|
{
|
|
coorddata c = {{0}};
|
|
if (!net_message.prim.coordsize)
|
|
net_message.prim.coordsize = 2;
|
|
MSG_ReadData(&c, net_message.prim.coordsize);
|
|
return MSG_FromCoord(c, net_message.prim.coordsize);
|
|
}
|
|
|
|
void MSG_ReadPos (vec3_t pos)
|
|
{
|
|
pos[0] = MSG_ReadCoord();
|
|
pos[1] = MSG_ReadCoord();
|
|
pos[2] = MSG_ReadCoord();
|
|
}
|
|
|
|
#if defined(Q2SERVER) || !defined(SERVERONLY)
|
|
#define Q2NUMVERTEXNORMALS 162
|
|
vec3_t bytedirs[Q2NUMVERTEXNORMALS] =
|
|
{
|
|
#include "../client/q2anorms.h"
|
|
};
|
|
#endif
|
|
#ifndef SERVERONLY
|
|
void MSG_ReadDir (vec3_t dir)
|
|
{
|
|
int b;
|
|
|
|
b = MSG_ReadByte ();
|
|
if (b >= Q2NUMVERTEXNORMALS)
|
|
{
|
|
CL_DumpPacket();
|
|
Host_EndGame ("MSG_ReadDir: out of range");
|
|
}
|
|
VectorCopy (bytedirs[b], dir);
|
|
}
|
|
#endif
|
|
#if 1//def Q2SERVER
|
|
void MSG_WriteDir (sizebuf_t *sb, vec3_t dir)
|
|
{
|
|
int i, best;
|
|
float d, bestd;
|
|
|
|
if (!dir)
|
|
{
|
|
MSG_WriteByte (sb, 0);
|
|
return;
|
|
}
|
|
|
|
bestd = 0;
|
|
best = 0;
|
|
for (i=0 ; i<Q2NUMVERTEXNORMALS ; i++)
|
|
{
|
|
d = DotProduct (dir, bytedirs[i]);
|
|
if (d > bestd)
|
|
{
|
|
bestd = d;
|
|
best = i;
|
|
}
|
|
}
|
|
MSG_WriteByte (sb, best);
|
|
}
|
|
#endif
|
|
|
|
float MSG_ReadAngle16 (void)
|
|
{
|
|
return MSG_ReadShort() * (360.0/65536);
|
|
}
|
|
float MSG_ReadAngle (void)
|
|
{
|
|
if (!net_message.prim.anglesize)
|
|
net_message.prim.anglesize = 1;
|
|
|
|
switch(net_message.prim.anglesize)
|
|
{
|
|
case 2:
|
|
return MSG_ReadAngle16();
|
|
case 4:
|
|
return MSG_ReadFloat();
|
|
case 1:
|
|
return MSG_ReadChar() * (360.0/256);
|
|
default:
|
|
Host_Error("Bad angle size\n");
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
void MSG_ReadDeltaUsercmd (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_ReadShort ();
|
|
if (bits & CM_ANGLE2)
|
|
move->angles[1] = MSG_ReadShort ();
|
|
if (bits & CM_ANGLE3)
|
|
move->angles[2] = MSG_ReadShort ();
|
|
|
|
// 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 ();
|
|
}
|
|
|
|
void MSGQ2_ReadDeltaUsercmd (usercmd_t *from, usercmd_t *move)
|
|
{
|
|
int bits;
|
|
|
|
memcpy (move, from, sizeof(*move));
|
|
|
|
bits = MSG_ReadByte ();
|
|
|
|
// read current angles
|
|
if (bits & Q2CM_ANGLE1)
|
|
move->angles[0] = MSG_ReadShort ();
|
|
if (bits & Q2CM_ANGLE2)
|
|
move->angles[1] = MSG_ReadShort ();
|
|
if (bits & Q2CM_ANGLE3)
|
|
move->angles[2] = MSG_ReadShort ();
|
|
|
|
// read movement
|
|
if (bits & Q2CM_FORWARD)
|
|
move->forwardmove = MSG_ReadShort ();
|
|
if (bits & Q2CM_SIDE)
|
|
move->sidemove = MSG_ReadShort ();
|
|
if (bits & Q2CM_UP)
|
|
move->upmove = MSG_ReadShort ();
|
|
|
|
// read buttons
|
|
if (bits & Q2CM_BUTTONS)
|
|
move->buttons = MSG_ReadByte ();
|
|
move->buttons_compat = move->buttons & 0xff;
|
|
|
|
if (bits & Q2CM_IMPULSE)
|
|
move->impulse = MSG_ReadByte ();
|
|
|
|
// read time to run command
|
|
move->msec_compat = move->msec = MSG_ReadByte ();
|
|
|
|
move->lightlevel = MSG_ReadByte ();
|
|
}
|
|
|
|
void MSG_ReadData (void *data, int len)
|
|
{
|
|
int i;
|
|
|
|
for (i=0 ; i<len ; i++)
|
|
((qbyte *)data)[i] = MSG_ReadByte ();
|
|
}
|
|
|
|
|
|
//===========================================================================
|
|
|
|
void SZ_Clear (sizebuf_t *buf)
|
|
{
|
|
buf->cursize = 0;
|
|
buf->overflowed = false;
|
|
}
|
|
|
|
void *SZ_GetSpace (sizebuf_t *buf, int length)
|
|
{
|
|
void *data;
|
|
|
|
if (buf->cursize + length > buf->maxsize)
|
|
{
|
|
if (!buf->allowoverflow)
|
|
Sys_Error ("SZ_GetSpace: overflow without allowoverflow set (%d)", buf->maxsize);
|
|
|
|
if (length > buf->maxsize)
|
|
Sys_Error ("SZ_GetSpace: %i is > full buffer size", length);
|
|
|
|
Sys_Printf ("SZ_GetSpace: overflow (%i+%i bytes of %i)\n", buf->cursize, length, buf->maxsize); // because Con_Printf may be redirected
|
|
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)
|
|
{
|
|
Q_memcpy (SZ_GetSpace(buf,length),data,length);
|
|
}
|
|
|
|
void SZ_Print (sizebuf_t *buf, const char *data)
|
|
{
|
|
int len;
|
|
|
|
len = Q_strlen(data)+1;
|
|
|
|
if (!buf->cursize || buf->data[buf->cursize-1])
|
|
Q_memcpy ((qbyte *)SZ_GetSpace(buf, len),data,len); // no trailing 0
|
|
else
|
|
{
|
|
qbyte *msg;
|
|
msg = (qbyte*)SZ_GetSpace(buf, len-1);
|
|
if (msg == buf->data) //whoops. SZ_GetSpace can return buf->data if it overflowed.
|
|
msg++;
|
|
Q_memcpy (msg-1,data,len); // write over trailing 0
|
|
}
|
|
}
|
|
|
|
|
|
//============================================================================
|
|
|
|
char *COM_TrimString(char *str, char *buffer, int buffersize)
|
|
{
|
|
int i;
|
|
while (*str <= ' ' && *str>'\0')
|
|
str++;
|
|
|
|
for (i = 0; i < buffersize-1; i++)
|
|
{
|
|
if (*str <= ' ')
|
|
break;
|
|
buffer[i] = *str++;
|
|
}
|
|
buffer[i] = '\0';
|
|
return buffer;
|
|
}
|
|
|
|
/*
|
|
============
|
|
COM_SkipPath
|
|
============
|
|
*/
|
|
char *COM_SkipPath (const char *pathname)
|
|
{
|
|
const char *last;
|
|
|
|
last = pathname;
|
|
while (*pathname)
|
|
{
|
|
if (*pathname=='/' || *pathname == '\\')
|
|
last = pathname+1;
|
|
pathname++;
|
|
}
|
|
return (char *)last;
|
|
}
|
|
|
|
/*
|
|
============
|
|
COM_StripExtension
|
|
============
|
|
*/
|
|
void QDECL COM_StripExtension (const char *in, char *out, int outlen)
|
|
{
|
|
char *s;
|
|
|
|
if (out != in) //optimisation, most calls use the same buffer
|
|
Q_strncpyz(out, in, outlen);
|
|
|
|
s = out+strlen(out);
|
|
|
|
while(*s != '/' && s != out)
|
|
{
|
|
if (*s == '.')
|
|
{
|
|
*s = 0;
|
|
break;
|
|
}
|
|
|
|
s--;
|
|
}
|
|
}
|
|
|
|
void COM_StripAllExtensions (char *in, char *out, int outlen)
|
|
{
|
|
char *s;
|
|
|
|
if (out != in)
|
|
Q_strncpyz(out, in, outlen);
|
|
|
|
s = out+strlen(out);
|
|
|
|
while(*s != '/' && s != out)
|
|
{
|
|
if (*s == '.')
|
|
{
|
|
*s = 0;
|
|
}
|
|
|
|
s--;
|
|
}
|
|
}
|
|
|
|
/*
|
|
============
|
|
COM_FileExtension
|
|
============
|
|
*/
|
|
char *COM_FileExtension (const char *in, char *result, size_t sizeofresult)
|
|
{
|
|
int i;
|
|
const char *dot;
|
|
|
|
for (dot = in + strlen(in); dot >= in && *dot != '.'; dot--)
|
|
;
|
|
if (dot < in)
|
|
{
|
|
*result = 0;
|
|
return result;
|
|
}
|
|
in = dot;
|
|
|
|
in++;
|
|
for (i=0 ; i<sizeofresult-1 && *in ; i++,in++)
|
|
result[i] = *in;
|
|
result[i] = 0;
|
|
return result;
|
|
}
|
|
|
|
//Quake 2's tank model has a borked skin (or two).
|
|
void COM_CleanUpPath(char *str)
|
|
{
|
|
char *dots;
|
|
char *slash;
|
|
int critisize = 0;
|
|
for (dots = str; *dots; dots++)
|
|
{
|
|
if (*dots >= 'A' && *dots <= 'Z')
|
|
{
|
|
*dots = *dots - 'A' + 'a';
|
|
critisize = 1;
|
|
}
|
|
else if (*dots == '\\')
|
|
{
|
|
*dots = '/';
|
|
critisize = 2;
|
|
}
|
|
}
|
|
while ((dots = strstr(str, "..")))
|
|
{
|
|
critisize = 0;
|
|
for (slash = dots-2; slash >= str; slash--)
|
|
{
|
|
if (*slash == '/')
|
|
{
|
|
memmove(slash, dots+2, strlen(dots+2)+1);
|
|
critisize = 3;
|
|
break;
|
|
}
|
|
}
|
|
if (critisize != 3)
|
|
{
|
|
memmove(dots, dots+2, strlen(dots+2)+1);
|
|
critisize = 3;
|
|
}
|
|
}
|
|
while(*str == '/')
|
|
{
|
|
memmove(str, str+1, strlen(str+1)+1);
|
|
critisize = 4;
|
|
}
|
|
/* if(critisize)
|
|
{
|
|
if (critisize == 1) //not a biggy, so not red.
|
|
Con_Printf("Please fix file case on your files\n");
|
|
else if (critisize == 2) //you're evil.
|
|
Con_Printf("^1NEVER use backslash in a quake filename (we like portability)\n");
|
|
else if (critisize == 3) //compleatly stupid. The main reason why this function exists. Quake2 does it!
|
|
Con_Printf("You realise that relative paths are a waste of space?\n");
|
|
else if (critisize == 4) //AAAAHHHHH! (consider sys_error instead)
|
|
Con_Printf("^1AAAAAAAHHHH! An absolute path!\n");
|
|
}
|
|
*/
|
|
}
|
|
|
|
/*
|
|
============
|
|
COM_FileBase
|
|
============
|
|
*/
|
|
void COM_FileBase (const char *in, char *out, int outlen)
|
|
{
|
|
const char *s, *s2;
|
|
|
|
s = in + strlen(in) - 1;
|
|
|
|
while (s > in && *s != '.')
|
|
s--;
|
|
|
|
for (s2 = s ; s2 > in && *s2 && *s2 != '/' ; s2--)
|
|
;
|
|
|
|
if (s-s2 < 2)
|
|
{
|
|
if (s == s2)
|
|
Q_strncpyz(out, in, outlen);
|
|
else
|
|
Q_strncpyz(out,"?model?", outlen);
|
|
}
|
|
else
|
|
{
|
|
s--;
|
|
outlen--;
|
|
if (outlen > s-s2)
|
|
outlen = s-s2;
|
|
Q_strncpyS (out,s2+1, outlen);
|
|
out[outlen] = 0;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
==================
|
|
COM_DefaultExtension
|
|
==================
|
|
*/
|
|
void COM_DefaultExtension (char *path, char *extension, int maxlen)
|
|
{
|
|
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--;
|
|
}
|
|
|
|
if (*extension != '.')
|
|
Q_strncatz (path, ".", maxlen);
|
|
Q_strncatz (path, extension, maxlen);
|
|
}
|
|
|
|
//adds .ext only if it isn't already present (either case).
|
|
//extension *must* contain a leading . as this is really a requiresuffix rather than an actual extension
|
|
//returns false if truncated. will otherwise still succeed.
|
|
qboolean COM_RequireExtension(char *path, char *extension, int maxlen)
|
|
{
|
|
qboolean okay = true;
|
|
int plen = strlen(path);
|
|
int elen = strlen(extension);
|
|
|
|
//check if its aready suffixed
|
|
if (plen >= elen)
|
|
{
|
|
if (!Q_strcasecmp(path+plen-elen, extension))
|
|
return okay;
|
|
}
|
|
|
|
//truncate if required
|
|
if (plen+1+elen > maxlen)
|
|
{
|
|
if (elen+1 > maxlen)
|
|
Sys_Error("extension longer than path buffer");
|
|
okay = false;
|
|
plen = maxlen - 1+elen;
|
|
}
|
|
|
|
//do the copy
|
|
while(*extension)
|
|
path[plen++] = *extension++;
|
|
path[plen] = 0;
|
|
return okay;
|
|
}
|
|
|
|
//errors:
|
|
//1 sequence error
|
|
//2 over-long
|
|
//3 invalid unicode char
|
|
//4 invalid utf-16 lead/high surrogate
|
|
//5 invalid utf-16 tail/low surrogate
|
|
unsigned int utf8_decode(int *error, const void *in, char **out)
|
|
{
|
|
//uc is the output unicode char
|
|
unsigned int uc = 0xfffdu; //replacement character
|
|
//l is the length
|
|
unsigned int l = 1;
|
|
const unsigned char *str = in;
|
|
|
|
if ((*str & 0xe0) == 0xc0)
|
|
{
|
|
if ((str[1] & 0xc0) == 0x80)
|
|
{
|
|
l = 2;
|
|
uc = ((str[0] & 0x1f)<<6) | (str[1] & 0x3f);
|
|
if (!uc || uc >= (1u<<7)) //allow modified utf-8
|
|
*error = 0;
|
|
else
|
|
*error = 2;
|
|
}
|
|
else *error = 1;
|
|
}
|
|
else if ((*str & 0xf0) == 0xe0)
|
|
{
|
|
if ((str[1] & 0xc0) == 0x80 && (str[2] & 0xc0) == 0x80)
|
|
{
|
|
l = 3;
|
|
uc = ((str[0] & 0x0f)<<12) | ((str[1] & 0x3f)<<6) | ((str[2] & 0x3f)<<0);
|
|
if (uc >= (1u<<11))
|
|
*error = 0;
|
|
else
|
|
*error = 2;
|
|
}
|
|
else *error = 1;
|
|
}
|
|
else if ((*str & 0xf8) == 0xf0)
|
|
{
|
|
if ((str[1] & 0xc0) == 0x80 && (str[2] & 0xc0) == 0x80 && (str[3] & 0xc0) == 0x80)
|
|
{
|
|
l = 4;
|
|
uc = ((str[0] & 0x07)<<18) | ((str[1] & 0x3f)<<12) | ((str[2] & 0x3f)<<6) | ((str[3] & 0x3f)<<0);
|
|
if (uc >= (1u<<16))
|
|
*error = 0;
|
|
else
|
|
*error = 2;
|
|
}
|
|
else *error = 1;
|
|
}
|
|
else if ((*str & 0xfc) == 0xf8)
|
|
{
|
|
if ((str[1] & 0xc0) == 0x80 && (str[2] & 0xc0) == 0x80 && (str[3] & 0xc0) == 0x80 && (str[4] & 0xc0) == 0x80)
|
|
{
|
|
l = 5;
|
|
uc = ((str[0] & 0x03)<<24) | ((str[1] & 0x3f)<<18) | ((str[2] & 0x3f)<<12) | ((str[3] & 0x3f)<<6) | ((str[4] & 0x3f)<<0);
|
|
if (uc >= (1u<<21))
|
|
*error = 0;
|
|
else
|
|
*error = 2;
|
|
}
|
|
else *error = 1;
|
|
}
|
|
else if ((*str & 0xfe) == 0xfc)
|
|
{
|
|
//six bytes
|
|
if ((str[1] & 0xc0) == 0x80 && (str[2] & 0xc0) == 0x80 && (str[3] & 0xc0) == 0x80 && (str[4] & 0xc0) == 0x80)
|
|
{
|
|
l = 6;
|
|
uc = ((str[0] & 0x01)<<30) | ((str[1] & 0x3f)<<24) | ((str[2] & 0x3f)<<18) | ((str[3] & 0x3f)<<12) | ((str[4] & 0x3f)<<6) | ((str[5] & 0x3f)<<0);
|
|
if (uc >= (1u<<26))
|
|
*error = 0;
|
|
else
|
|
*error = 2;
|
|
}
|
|
else *error = 1;
|
|
}
|
|
//0xfe and 0xff, while plausable leading bytes, are not permitted.
|
|
#if 0
|
|
else if ((*str & 0xff) == 0xfe)
|
|
{
|
|
if ((str[1] & 0xc0) == 0x80 && (str[2] & 0xc0) == 0x80 && (str[3] & 0xc0) == 0x80 && (str[4] & 0xc0) == 0x80)
|
|
{
|
|
l = 7;
|
|
uc = 0 | ((str[1] & 0x3f)<<30) | ((str[2] & 0x3f)<<24) | ((str[3] & 0x3f)<<18) | ((str[4] & 0x3f)<<12) | ((str[5] & 0x3f)<<6) | ((str[6] & 0x3f)<<0);
|
|
if (uc >= (1u<<31))
|
|
*error = 0;
|
|
else
|
|
*error = 2;
|
|
}
|
|
else *error = 1;
|
|
}
|
|
else if ((*str & 0xff) == 0xff)
|
|
{
|
|
if ((str[1] & 0xc0) == 0x80 && (str[2] & 0xc0) == 0x80 && (str[3] & 0xc0) == 0x80 && (str[4] & 0xc0) == 0x80)
|
|
{
|
|
l = 8;
|
|
uc = 0 | ((str[1] & 0x3f)<<36) | ((str[2] & 0x3f)<<30) | ((str[3] & 0x3f)<<24) | ((str[4] & 0x3f)<<18) | ((str[5] & 0x3f)<<12) | ((str[6] & 0x3f)<<6) | ((str[7] & 0x3f)<<0);
|
|
if (uc >= (1llu<<36))
|
|
*error = false;
|
|
else
|
|
*error = 2;
|
|
}
|
|
else *error = 1;
|
|
}
|
|
#endif
|
|
else if (*str & 0x80)
|
|
{
|
|
//sequence error
|
|
*error = 1;
|
|
uc = 0xe000u + *str;
|
|
}
|
|
else
|
|
{
|
|
//ascii char
|
|
*error = 0;
|
|
uc = *str;
|
|
}
|
|
|
|
*out = (void*)(str + l);
|
|
|
|
if (!*error)
|
|
{
|
|
//try to deal with surrogates by decoding the low if we see a high.
|
|
if (uc >= 0xd800u && uc < 0xdc00u)
|
|
{
|
|
#if 1
|
|
//cesu-8
|
|
char *lowend;
|
|
unsigned int lowsur = utf8_decode(error, str + l, &lowend);
|
|
if (*error == 4)
|
|
{
|
|
*out = lowend;
|
|
uc = (((uc&0x3ffu) << 10) | (lowsur&0x3ffu)) + 0x10000;
|
|
*error = false;
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
*error = 3; //bad - lead surrogate without tail.
|
|
}
|
|
}
|
|
if (uc >= 0xdc00u && uc < 0xe000u)
|
|
*error = 4; //bad - tail surrogate
|
|
|
|
//these are meant to be illegal too
|
|
if (uc == 0xfffeu || uc == 0xffffu || uc > 0x10ffffu)
|
|
*error = 2; //illegal code
|
|
}
|
|
|
|
return uc;
|
|
}
|
|
|
|
unsigned int unicode_decode(int *error, const void *in, char **out, qboolean markup)
|
|
{
|
|
unsigned int charcode;
|
|
if (markup && ((char*)in)[0] == '^' && ((char*)in)[1] == 'U' && ishexcode(((char*)in)[2]) && ishexcode(((char*)in)[3]) && ishexcode(((char*)in)[4]) && ishexcode(((char*)in)[5]))
|
|
{
|
|
*out = (char*)in + 6;
|
|
charcode = (dehex(((char*)in)[2]) << 12) | (dehex(((char*)in)[2]) << 8) | (dehex(((char*)in)[2]) << 4) | (dehex(((char*)in)[2]) << 0);
|
|
}
|
|
else if (markup && ((char*)in)[0] == '^' && ((char*)in)[1] == '{')
|
|
{
|
|
*out = (char*)in + 2;
|
|
charcode = 0;
|
|
while (ishexcode(**out))
|
|
{
|
|
charcode <<= 4;
|
|
charcode |= dehex(**out);
|
|
*out+=1;
|
|
}
|
|
if (**out == '}')
|
|
*out+=1;
|
|
}
|
|
else if (com_parseutf8.ival > 0)
|
|
charcode = utf8_decode(error, in, out);
|
|
else if (com_parseutf8.ival)
|
|
{
|
|
*error = 0;
|
|
charcode = *(unsigned char*)in; //iso8859-1
|
|
*out = (char*)in + 1;
|
|
}
|
|
else
|
|
{ //quake
|
|
*error = 0;
|
|
charcode = *(unsigned char*)in;
|
|
if (charcode && charcode != '\n' && charcode != '\t' && charcode != '\r' && (charcode < ' ' || charcode > 127))
|
|
charcode |= 0xe000;
|
|
*out = (char*)in + 1;
|
|
}
|
|
|
|
return charcode;
|
|
}
|
|
|
|
unsigned int utf8_encode(void *out, unsigned int unicode, int maxlen)
|
|
{
|
|
unsigned int bcount = 1;
|
|
unsigned int lim = 0x80;
|
|
unsigned int shift;
|
|
if (!unicode)
|
|
{ //modified utf-8 encodes encapsulated nulls as over-long.
|
|
bcount = 2;
|
|
}
|
|
else
|
|
{
|
|
while (unicode >= lim)
|
|
{
|
|
if (bcount == 1)
|
|
lim <<= 4;
|
|
else if (bcount < 7)
|
|
lim <<= 5;
|
|
else
|
|
lim <<= 6;
|
|
bcount++;
|
|
}
|
|
}
|
|
|
|
//error if needed
|
|
if (maxlen < bcount)
|
|
return 0;
|
|
|
|
//output it.
|
|
if (bcount == 1)
|
|
{
|
|
*((unsigned char *)out) = (unsigned char)(unicode&0x7f);
|
|
out = (char*)out + 1;
|
|
}
|
|
else
|
|
{
|
|
shift = bcount*6;
|
|
shift = shift-6;
|
|
*((unsigned char *)out) = (unsigned char)((unicode>>shift)&(0x0000007f>>bcount)) | ((0xffffff00 >> bcount) & 0xff);
|
|
out = (char*)out + 1;
|
|
do
|
|
{
|
|
shift = shift-6;
|
|
*((unsigned char *)out) = (unsigned char)((unicode>>shift)&0x3f) | 0x80;
|
|
out = (char*)out + 1;
|
|
}
|
|
while(shift);
|
|
}
|
|
return bcount;
|
|
}
|
|
|
|
unsigned int qchar_encode(char *out, unsigned int unicode, int maxlen, qboolean markup)
|
|
{
|
|
static const char hex[16] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
|
|
//FIXME: is it a bug that we can't distinguish between true ascii and 0xe0XX ?
|
|
//ntrv are considered special by parsefunstring and are not remapped back to the quake glyphs, so try to keep them as quake glyphs where possible
|
|
if (((unicode >= 32 || unicode == '\n' || unicode == '\t' || unicode == '\r') && unicode < 128) || (unicode >= 0xe000 && unicode <= 0xe0ff && unicode != (0xe000|'\n') && unicode != (0xe000|'\t') && unicode != (0xe000|'\r') && unicode != (0xe000|'\v')))
|
|
{ //quake compatible chars
|
|
if (maxlen < 1)
|
|
return 0;
|
|
*out++ = unicode & 0xff;
|
|
return 1;
|
|
}
|
|
else if (!markup)
|
|
{
|
|
if (maxlen < 1)
|
|
return 0;
|
|
*out++ = '?';
|
|
return 1;
|
|
}
|
|
else if (unicode > 0xffff)
|
|
{ //chars longer than 16 bits
|
|
char *o = out;
|
|
if (maxlen < 11)
|
|
return 0;
|
|
*out++ = '^';
|
|
*out++ = '{';
|
|
if (unicode > 0xfffffff)
|
|
*out++ = hex[(unicode>>28)&15];
|
|
if (unicode > 0xffffff)
|
|
*out++ = hex[(unicode>>24)&15];
|
|
if (unicode > 0xfffff)
|
|
*out++ = hex[(unicode>>20)&15];
|
|
if (unicode > 0xffff)
|
|
*out++ = hex[(unicode>>16)&15];
|
|
if (unicode > 0xfff)
|
|
*out++ = hex[(unicode>>12)&15];
|
|
if (unicode > 0xff)
|
|
*out++ = hex[(unicode>>8)&15];
|
|
if (unicode > 0xf)
|
|
*out++ = hex[(unicode>>4)&15];
|
|
if (unicode > 0x0)
|
|
*out++ = hex[(unicode>>0)&15];
|
|
*out++ = '}';
|
|
return out - o;
|
|
}
|
|
else
|
|
{ //16bit chars
|
|
if (maxlen < 6)
|
|
return 0;
|
|
*out++ = '^';
|
|
*out++ = 'U';
|
|
*out++ = hex[(unicode>>12)&15];
|
|
*out++ = hex[(unicode>>8)&15];
|
|
*out++ = hex[(unicode>>4)&15];
|
|
*out++ = hex[(unicode>>0)&15];
|
|
return 6;
|
|
}
|
|
}
|
|
|
|
unsigned int iso88591_encode(char *out, unsigned int unicode, int maxlen, qboolean markup)
|
|
{
|
|
static const char hex[16] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
|
|
if (unicode < 256 || (unicode >= 0xe020 && unicode < 0xe080))
|
|
{ //iso8859-1 compatible chars
|
|
if (maxlen < 1)
|
|
return 0;
|
|
*out++ = unicode;
|
|
return 1;
|
|
}
|
|
else if (!markup)
|
|
{
|
|
if (maxlen < 1)
|
|
return 0;
|
|
*out++ = '?';
|
|
return 1;
|
|
}
|
|
else if (unicode > 0xffff)
|
|
{ //chars longer than 16 bits
|
|
char *o = out;
|
|
if (maxlen < 11)
|
|
return 0;
|
|
*out++ = '^';
|
|
*out++ = '{';
|
|
if (unicode > 0xfffffff)
|
|
*out++ = hex[(unicode>>28)&15];
|
|
if (unicode > 0xffffff)
|
|
*out++ = hex[(unicode>>24)&15];
|
|
if (unicode > 0xfffff)
|
|
*out++ = hex[(unicode>>20)&15];
|
|
if (unicode > 0xffff)
|
|
*out++ = hex[(unicode>>16)&15];
|
|
if (unicode > 0xfff)
|
|
*out++ = hex[(unicode>>12)&15];
|
|
if (unicode > 0xff)
|
|
*out++ = hex[(unicode>>8)&15];
|
|
if (unicode > 0xf)
|
|
*out++ = hex[(unicode>>4)&15];
|
|
if (unicode > 0x0)
|
|
*out++ = hex[(unicode>>0)&15];
|
|
*out++ = '}';
|
|
return out - o;
|
|
}
|
|
else
|
|
{ //16bit chars
|
|
if (maxlen < 6)
|
|
return 0;
|
|
*out++ = '^';
|
|
*out++ = 'U';
|
|
*out++ = hex[(unicode>>12)&15];
|
|
*out++ = hex[(unicode>>8)&15];
|
|
*out++ = hex[(unicode>>4)&15];
|
|
*out++ = hex[(unicode>>0)&15];
|
|
return 6;
|
|
}
|
|
}
|
|
|
|
unsigned int unicode_encode(char *out, unsigned int unicode, int maxlen, qboolean markup)
|
|
{
|
|
if (com_parseutf8.ival > 0)
|
|
return utf8_encode(out, unicode, maxlen);
|
|
else if (com_parseutf8.ival)
|
|
return iso88591_encode(out, unicode, maxlen, markup);
|
|
else
|
|
return qchar_encode(out, unicode, maxlen, markup);
|
|
}
|
|
|
|
//char-based strlen.
|
|
unsigned int unicode_charcount(const char *in, size_t buffersize, qboolean markup)
|
|
{
|
|
int error;
|
|
const char *end = in + buffersize;
|
|
int chars = 0;
|
|
for(chars = 0; in < end && *in; chars+=1)
|
|
{
|
|
unicode_decode(&error, in, (char**)&in, markup);
|
|
|
|
if (in > end)
|
|
break; //exceeded buffer size uncleanly
|
|
}
|
|
return chars;
|
|
}
|
|
|
|
//handy hacky function.
|
|
unsigned int unicode_byteofsfromcharofs(const char *str, unsigned int charofs, qboolean markup)
|
|
{
|
|
const char *in = str;
|
|
int error;
|
|
int chars;
|
|
for(chars = 0; *in; chars+=1)
|
|
{
|
|
if (chars >= charofs)
|
|
return in - str;
|
|
|
|
unicode_decode(&error, in, (char**)&in, markup);
|
|
}
|
|
return in - str;
|
|
}
|
|
//handy hacky function.
|
|
unsigned int unicode_charofsfrombyteofs(const char *str, unsigned int byteofs, qboolean markup)
|
|
{
|
|
int error;
|
|
const char *end = str + byteofs;
|
|
int chars = 0;
|
|
for(chars = 0; str < end && *str; chars+=1)
|
|
{
|
|
unicode_decode(&error, str, (char**)&str, markup);
|
|
|
|
if (str > end)
|
|
break; //exceeded buffer size uncleanly
|
|
}
|
|
return chars;
|
|
}
|
|
|
|
#ifdef FTE_TARGET_WEB
|
|
//targets that don't support towupper/towlower...
|
|
#define towupper Q_towupper
|
|
#define towlower Q_towlower
|
|
int towupper(int c)
|
|
{
|
|
if (c < 128)
|
|
return toupper(c);
|
|
return c;
|
|
}
|
|
int towlower(int c)
|
|
{
|
|
if (c < 128)
|
|
return tolower(c);
|
|
return c;
|
|
}
|
|
#endif
|
|
|
|
size_t unicode_strtoupper(const char *in, char *out, size_t outsize, qboolean markup)
|
|
{
|
|
//warning: towupper is locale-specific (eg: turkish has both I and dotted-I and thus i should transform to dotted-I rather than to I).
|
|
//also it can't easily cope with accent prefixes.
|
|
int error;
|
|
unsigned int c;
|
|
size_t l = 0;
|
|
outsize -= 1;
|
|
|
|
while(*in)
|
|
{
|
|
c = unicode_decode(&error, in, (char**)&in, markup);
|
|
if (c >= 0xe020 && c <= 0xe07f) //quake-char-aware.
|
|
c = towupper(c & 0x7f) + (c & 0xff80);
|
|
else
|
|
c = towupper(c);
|
|
l = unicode_encode(out, c, outsize - l, markup);
|
|
out += l;
|
|
}
|
|
*out = 0;
|
|
|
|
return l;
|
|
}
|
|
|
|
size_t unicode_strtolower(const char *in, char *out, size_t outsize, qboolean markup)
|
|
{
|
|
//warning: towlower is locale-specific (eg: turkish has both i and dotless-i and thus I should transform to dotless-i rather than to i).
|
|
//also it can't easily cope with accent prefixes.
|
|
int error;
|
|
unsigned int c;
|
|
size_t l = 0;
|
|
outsize -= 1;
|
|
|
|
while(*in)
|
|
{
|
|
c = unicode_decode(&error, in, (char**)&in, markup);
|
|
if (c >= 0xe020 && c <= 0xe07f) //quake-char-aware.
|
|
c = towlower(c & 0x7f) + (c & 0xff80);
|
|
else
|
|
c = towlower(c);
|
|
l = unicode_encode(out, c, outsize - l, markup);
|
|
out += l;
|
|
}
|
|
*out = 0;
|
|
|
|
return l;
|
|
}
|
|
|
|
///=====================================
|
|
|
|
// This is the standard RGBI palette used in CGA text mode
|
|
consolecolours_t consolecolours[MAXCONCOLOURS] = {
|
|
{0, 0, 0 }, // black
|
|
{0, 0, 0.67}, // blue
|
|
{0, 0.67, 0 }, // green
|
|
{0, 0.67, 0.67}, // cyan
|
|
{0.67, 0, 0 }, // red
|
|
{0.67, 0, 0.67}, // magenta
|
|
{0.67, 0.33, 0 }, // brown
|
|
{0.67, 0.67, 0.67}, // light gray
|
|
{0.33, 0.33, 0.33}, // dark gray
|
|
{0.33, 0.33, 1 }, // light blue
|
|
{0.33, 1, 0.33}, // light green
|
|
{0.33, 1, 1 }, // light cyan
|
|
{1, 0.33, 0.33}, // light red
|
|
{1, 0.33, 1 }, // light magenta
|
|
{1, 1, 0.33}, // yellow
|
|
{1, 1, 1 } // white
|
|
};
|
|
|
|
// This is for remapping the Q3 color codes to character masks, including ^9
|
|
conchar_t q3codemasks[MAXQ3COLOURS] = {
|
|
0x00000000, // 0, black
|
|
0x0c000000, // 1, red
|
|
0x0a000000, // 2, green
|
|
0x0e000000, // 3, yellow
|
|
0x09000000, // 4, blue
|
|
0x0b000000, // 5, cyan
|
|
0x0d000000, // 6, magenta
|
|
0x0f000000, // 7, white
|
|
0x0f100000, // 8, half-alpha white (BX_COLOREDTEXT)
|
|
0x07000000 // 9, "half-intensity" (BX_COLOREDTEXT)
|
|
};
|
|
|
|
//Converts a conchar_t string into a char string. returns the null terminator. pass NULL for stop to calc it
|
|
char *COM_DeFunString(conchar_t *str, conchar_t *stop, char *out, int outsize, qboolean ignoreflags)
|
|
{
|
|
if (!stop)
|
|
{
|
|
for (stop = str; *stop; stop++)
|
|
;
|
|
}
|
|
#ifdef _DEBUG
|
|
if (!outsize)
|
|
Sys_Error("COM_DeFunString given outsize=0");
|
|
#endif
|
|
|
|
/*if (ignoreflags)
|
|
{
|
|
while(str < stop)
|
|
{
|
|
if (!--outsize)
|
|
break;
|
|
*out++ = (unsigned char)(*str++&255);
|
|
}
|
|
*out = 0;
|
|
}
|
|
else*/
|
|
{
|
|
int fl, d;
|
|
unsigned int c;
|
|
int prelinkflags = CON_WHITEMASK; //if used, its already an error.
|
|
//FIXME: TEST!
|
|
|
|
fl = CON_WHITEMASK;
|
|
while(str < stop)
|
|
{
|
|
if ((*str & CON_HIDDEN) && ignoreflags)
|
|
{
|
|
str++;
|
|
continue;
|
|
}
|
|
if (*str == CON_LINKSTART)
|
|
{
|
|
if (!ignoreflags)
|
|
{
|
|
if (outsize<=2)
|
|
break;
|
|
outsize -= 2;
|
|
*out++ = '^';
|
|
*out++ = '[';
|
|
}
|
|
prelinkflags = fl;
|
|
fl = COLOR_RED << CON_FGSHIFT;
|
|
str++;
|
|
continue;
|
|
}
|
|
else if (*str == CON_LINKEND)
|
|
{
|
|
if (!ignoreflags)
|
|
{
|
|
if (outsize<=2)
|
|
break;
|
|
outsize -= 2;
|
|
*out++ = '^';
|
|
*out++ = ']';
|
|
}
|
|
fl = prelinkflags;
|
|
str++;
|
|
continue;
|
|
}
|
|
else if ((*str & CON_FLAGSMASK) != fl && !ignoreflags)
|
|
{
|
|
d = fl^(*str & CON_FLAGSMASK);
|
|
// if (fl & CON_NONCLEARBG) //not represented.
|
|
if (d & CON_BLINKTEXT)
|
|
{
|
|
if (outsize<=2)
|
|
break;
|
|
outsize -= 2;
|
|
*out++ = '^';
|
|
*out++ = 'b';
|
|
}
|
|
if (d & CON_2NDCHARSETTEXT)
|
|
{
|
|
if (outsize<=2)
|
|
break;
|
|
outsize -= 2;
|
|
*out++ = '^';
|
|
*out++ = 'a';
|
|
}
|
|
if (d & CON_HALFALPHA)
|
|
{
|
|
if (outsize<=2)
|
|
break;
|
|
outsize -= 2;
|
|
*out++ = '^';
|
|
*out++ = 'h';
|
|
}
|
|
|
|
if (d & (CON_FGMASK | CON_BGMASK | CON_NONCLEARBG))
|
|
{
|
|
static char q3[16] = { '0', 0, 0, 0,
|
|
0, 0, 0, 0,
|
|
0, '4', '2', '5',
|
|
'1', '6', '3', '7'};
|
|
if (!(d & (CON_BGMASK | CON_NONCLEARBG)) && q3[(*str & CON_FGMASK) >> CON_FGSHIFT] && !((d|fl) & CON_HALFALPHA))
|
|
{
|
|
if (outsize<=2)
|
|
break;
|
|
outsize -= 2;
|
|
|
|
d = (*str & CON_FLAGSMASK);
|
|
*out++ = '^';
|
|
*out++ = q3[(*str & CON_FGMASK) >> CON_FGSHIFT];
|
|
}
|
|
else
|
|
{
|
|
if (outsize<=4)
|
|
break;
|
|
outsize -= 4;
|
|
|
|
d = (*str & CON_FLAGSMASK);
|
|
*out++ = '^';
|
|
*out++ = '&';
|
|
if ((d & CON_FGMASK) == CON_WHITEMASK)
|
|
*out = '-';
|
|
else
|
|
sprintf(out, "%X", d>>24);
|
|
out++;
|
|
if (d & CON_NONCLEARBG)
|
|
sprintf(out, "%X", d>>28);
|
|
else
|
|
*out = '-';
|
|
out++;
|
|
}
|
|
}
|
|
|
|
fl = (*str & CON_FLAGSMASK);
|
|
}
|
|
|
|
//don't magically show hidden text
|
|
if (ignoreflags && (*str & CON_HIDDEN))
|
|
continue;
|
|
|
|
c = unicode_encode(out, (*str++ & CON_CHARMASK), outsize-1, !ignoreflags);
|
|
if (!c)
|
|
break;
|
|
outsize -= c;
|
|
out += c;
|
|
}
|
|
*out = 0;
|
|
}
|
|
return out;
|
|
}
|
|
|
|
static unsigned int koi2wc (unsigned char uc)
|
|
{
|
|
static const char koi2wc_table[64] =
|
|
{
|
|
0x4e,0x30,0x31,0x46,0x34,0x35,0x44,0x33,0x45,0x38,0x39,0x3a,0x3b,0x3c,0x3d,0x3e,
|
|
0x3f,0x4f,0x40,0x41,0x42,0x43,0x36,0x32,0x4c,0x4b,0x37,0x48,0x4d,0x49,0x47,0x4a,
|
|
0x2e,0x10,0x11,0x26,0x14,0x15,0x24,0x13,0x25,0x18,0x19,0x1a,0x1b,0x1c,0x1d,0x1e,
|
|
0x1f,0x2f,0x20,0x21,0x22,0x23,0x16,0x12,0x2c,0x2b,0x17,0x28,0x2d,0x29,0x27,0x2a
|
|
};
|
|
if (uc >= 192 /* && (unsigned char)c <= 255 */)
|
|
return koi2wc_table[uc - 192] + 0x400;
|
|
else if (uc == '#' + 128)
|
|
return 0x0451; // russian small yo
|
|
else if (uc == '3' + 128)
|
|
return 0x0401; // russian capital yo
|
|
else if (uc == '4' + 128)
|
|
return 0x0404; // ukrainian capital round E
|
|
else if (uc == '$' + 128)
|
|
return 0x0454; // ukrainian small round E
|
|
else if (uc == '6' + 128)
|
|
return 0x0406; // ukrainian capital I
|
|
else if (uc == '&' + 128)
|
|
return 0x0456; // ukrainian small i
|
|
else if (uc == '7' + 128)
|
|
return 0x0407; // ukrainian capital I with two dots
|
|
else if (uc == '\'' + 128)
|
|
return 0x0457; // ukrainian small i with two dots
|
|
else if (uc == '>' + 128)
|
|
return 0x040e; // belarusian Y
|
|
else if (uc == '.' + 128)
|
|
return 0x045e; // belarusian y
|
|
else if (uc == '/' + 128)
|
|
return 0x042a; // russian capital hard sign
|
|
else
|
|
return uc;
|
|
}
|
|
|
|
enum
|
|
{
|
|
BIDI_NEUTRAL,
|
|
BIDI_LTR,
|
|
BIDI_RTL,
|
|
};
|
|
static char *bidi_chartype;
|
|
static unsigned int bidi_charcount;
|
|
|
|
|
|
//semi-colon delimited tokens
|
|
char *COM_ParseStringSetSep (const char *data, char sep)
|
|
{
|
|
int c;
|
|
size_t len;
|
|
|
|
len = 0;
|
|
com_token[0] = 0;
|
|
|
|
if (data)
|
|
for (;*data;)
|
|
{
|
|
if (len >= sizeof(com_token)-1)
|
|
{
|
|
com_token[len] = 0;
|
|
return (char*)data;
|
|
}
|
|
c = *data++;
|
|
if (c == ';')
|
|
break;
|
|
com_token[len++] = c;
|
|
}
|
|
|
|
com_token[len] = 0;
|
|
return (char*)data;
|
|
}
|
|
void COM_BiDi_Shutdown(void)
|
|
{
|
|
bidi_charcount = 0;
|
|
BZ_Free(bidi_chartype);
|
|
bidi_chartype = NULL;
|
|
}
|
|
static void COM_BiDi_Setup(void)
|
|
{
|
|
char *file;
|
|
char *line;
|
|
char *end;
|
|
char *tok;
|
|
unsigned int c;
|
|
qofs_t size;
|
|
|
|
file = FS_MallocFile("bidi.dat", FS_ROOT, &size);
|
|
if (file)
|
|
{
|
|
bidi_chartype = file;
|
|
bidi_charcount = size;
|
|
return;
|
|
}
|
|
|
|
file = FS_MallocFile("UnicodeData.txt", FS_ROOT, NULL);
|
|
if (!file)
|
|
return;
|
|
|
|
bidi_charcount = 0xffff;
|
|
bidi_chartype = BZ_Malloc(bidi_charcount);
|
|
if (!bidi_chartype)
|
|
bidi_charcount = 0;
|
|
else
|
|
{
|
|
for (c = 0; c < bidi_charcount; c++)
|
|
bidi_chartype[c] = BIDI_NEUTRAL;
|
|
for(line = file; line; line = end)
|
|
{
|
|
end = strchr(line, '\n');
|
|
if (end)
|
|
*end++ = 0;
|
|
|
|
tok = COM_ParseStringSetSep(line,';'); //number
|
|
c = strtoul(com_token, NULL, 16);
|
|
tok = COM_ParseStringSetSep(tok,';'); //name
|
|
tok = COM_ParseStringSetSep(tok,';'); //class?
|
|
tok = COM_ParseStringSetSep(tok,';'); //?
|
|
tok = COM_ParseStringSetSep(tok,';'); //bidi
|
|
if (c < bidi_charcount)
|
|
{
|
|
if (!Q_strcasecmp(com_token, "R") || !Q_strcasecmp(com_token, "AL"))
|
|
bidi_chartype[c] = BIDI_RTL;
|
|
else if (!Q_strcasecmp(com_token, "L"))
|
|
bidi_chartype[c] = BIDI_LTR;
|
|
else
|
|
bidi_chartype[c] = BIDI_NEUTRAL;
|
|
}
|
|
}
|
|
|
|
//trim
|
|
while(bidi_charcount>0 && bidi_chartype[bidi_charcount-1] == BIDI_NEUTRAL)
|
|
bidi_charcount--;
|
|
FS_WriteFile("bidi.dat", bidi_chartype, bidi_charcount, FS_ROOT);
|
|
}
|
|
BZ_Free(file);
|
|
}
|
|
//bi-direction text is fun.
|
|
//the text is specified in input order. the first in the string is the first entered on the keyboard.
|
|
//this makes switching direction mid-line quite awkward. so lets hope you don't do that too often, mmkay?
|
|
static void COM_BiDi_Parse(conchar_t *fte_restrict start, size_t length)
|
|
{
|
|
char fl[2048], next, run, prev, para = BIDI_LTR;
|
|
size_t i, runstart, j, k;
|
|
unsigned int c;
|
|
conchar_t swap;
|
|
if (!bidi_charcount || !length || length > sizeof(fl))
|
|
return;
|
|
|
|
for (i = 0; i < length; i++)
|
|
{
|
|
c = start[i] & CON_CHARMASK;
|
|
if (c >= bidi_charcount)
|
|
fl[i] = BIDI_NEUTRAL;
|
|
else
|
|
fl[i] = bidi_chartype[c];
|
|
}
|
|
|
|
//de-neutralise it
|
|
prev = fl[0];
|
|
for (i = 0; i < length; )
|
|
{
|
|
if (fl[i] == BIDI_NEUTRAL)
|
|
{
|
|
next = prev; //trailing weak chars can just use the first side
|
|
for (runstart = i; i < length; i++)
|
|
{
|
|
next = fl[i];
|
|
if (next != BIDI_NEUTRAL)
|
|
{
|
|
i--;
|
|
break;
|
|
}
|
|
}
|
|
//this can happen if the only text is neutral
|
|
if (prev == BIDI_NEUTRAL)
|
|
run = next;
|
|
//if the strong cars are the same direction on both side, we can just use that direction
|
|
else if (prev == next)
|
|
run = prev;
|
|
//if the strong chars differ, we revert to the paragraph's direction.
|
|
else
|
|
run = para;
|
|
|
|
while(runstart <= i)
|
|
fl[runstart++] = run;
|
|
i++;
|
|
}
|
|
else
|
|
{
|
|
prev = fl[i];
|
|
i++;
|
|
}
|
|
}
|
|
|
|
for (run = para, runstart = 0, i = 0; i <= length; i++)
|
|
{
|
|
if (i >= length)
|
|
next = para;
|
|
else
|
|
next = fl[i];
|
|
if (next != run)
|
|
{
|
|
if (run == BIDI_NEUTRAL)
|
|
break;
|
|
if (run == BIDI_RTL)
|
|
{ //now swap the rtl text
|
|
k = (i-runstart)/2;
|
|
for (j = 0; j < k; j++)
|
|
{
|
|
//FIXME: ( -> ) and vice versa.
|
|
swap = start[runstart+j];
|
|
start[runstart+j] = start[i-j-1];
|
|
start[i-j-1] = swap;
|
|
}
|
|
}
|
|
run = next;
|
|
runstart = i;
|
|
}
|
|
}
|
|
}
|
|
|
|
//Takes a q3-style fun string, and returns an expanded string-with-flags (actual return value is the null terminator)
|
|
//outsize parameter is in _BYTES_ (so sizeof is safe).
|
|
conchar_t *COM_ParseFunString(conchar_t defaultflags, const char *str, conchar_t *out, int outsize, int flags)
|
|
{
|
|
conchar_t extstack[4];
|
|
int extstackdepth = 0;
|
|
unsigned int uc;
|
|
int utf8 = com_parseutf8.ival;
|
|
conchar_t linkinitflags = CON_WHITEMASK;/*doesn't need the init, but msvc is stupid*/
|
|
qboolean keepmarkup = !!(flags & PFS_KEEPMARKUP);
|
|
qboolean linkkeep = keepmarkup;
|
|
qboolean ezquakemess = false;
|
|
conchar_t *linkstart = NULL;
|
|
|
|
conchar_t ext;
|
|
conchar_t *oldout = out;
|
|
|
|
if (flags & PFS_EZQUAKEMARKUP)
|
|
{
|
|
ezquakemess = true;
|
|
utf8 = 0;
|
|
}
|
|
if (flags & PFS_FORCEUTF8)
|
|
utf8 = 2;
|
|
|
|
outsize /= sizeof(conchar_t);
|
|
if (!outsize)
|
|
return out;
|
|
//then outsize is decremented then checked before each write, so the trailing null has space
|
|
|
|
#if 0
|
|
while(*str)
|
|
{
|
|
*out++ = CON_WHITEMASK|(unsigned char)*str++;
|
|
}
|
|
*out = 0;
|
|
return out;
|
|
#endif
|
|
|
|
if (*str == 1 || *str == 2)
|
|
{
|
|
defaultflags ^= CON_2NDCHARSETTEXT;
|
|
str++;
|
|
}
|
|
|
|
ext = defaultflags;
|
|
|
|
while(*str)
|
|
{
|
|
if ((*str & 0x80) && utf8 > 0)
|
|
{ //check for utf-8
|
|
int decodeerror;
|
|
char *end;
|
|
uc = utf8_decode(&decodeerror, str, &end);
|
|
if (decodeerror && !(utf8 & 2))
|
|
{
|
|
utf8 &= ~1;
|
|
//malformed encoding we just drop through and stop trying to decode.
|
|
//if its just a malformed or overlong string, we end up with a chunk of 'red' chars.
|
|
}
|
|
else
|
|
{
|
|
if (uc > CON_CHARMASK)
|
|
uc = 0xfffd;
|
|
if (!--outsize)
|
|
break;
|
|
*out++ = uc | ext;
|
|
str = end;
|
|
continue;
|
|
}
|
|
}
|
|
if (ezquakemess && *str == '^')
|
|
{
|
|
str++;
|
|
uc = (unsigned char)(*str++);
|
|
*out++ = (uc | ext) ^ CON_2NDCHARSETTEXT;
|
|
continue;
|
|
}
|
|
else if (*str == '^' && !(flags & PFS_NOMARKUP))
|
|
{
|
|
if (str[1] >= '0' && str[1] <= '9')
|
|
{ //q3 colour codes
|
|
if (ext & CON_RICHFORECOLOUR)
|
|
ext = (COLOR_WHITE << CON_FGSHIFT) | (ext&~(CON_RICHFOREMASK|CON_RICHFORECOLOUR));
|
|
ext = q3codemasks[str[1]-'0'] | (ext&~CON_Q3MASK); //change colour only.
|
|
}
|
|
else if (str[1] == '&') // extended code
|
|
{
|
|
if (isextendedcode(str[2]) && isextendedcode(str[3]))
|
|
{
|
|
if (ext & CON_RICHFORECOLOUR)
|
|
ext = (COLOR_WHITE << CON_FGSHIFT) | (ext&~(CON_RICHFOREMASK|CON_RICHFORECOLOUR));
|
|
|
|
// foreground char
|
|
if (str[2] == '-') // default for FG
|
|
ext = (COLOR_WHITE << CON_FGSHIFT) | (ext&~CON_FGMASK);
|
|
else if (str[2] >= 'A')
|
|
ext = ((str[2] - ('A' - 10)) << CON_FGSHIFT) | (ext&~CON_FGMASK);
|
|
else
|
|
ext = ((str[2] - '0') << CON_FGSHIFT) | (ext&~CON_FGMASK);
|
|
// background char
|
|
if (str[3] == '-') // default (clear) for BG
|
|
ext &= ~CON_BGMASK & ~CON_NONCLEARBG;
|
|
else if (str[3] >= 'A')
|
|
ext = ((str[3] - ('A' - 10)) << CON_BGSHIFT) | (ext&~CON_BGMASK) | CON_NONCLEARBG;
|
|
else
|
|
ext = ((str[3] - '0') << CON_BGSHIFT) | (ext&~CON_BGMASK) | CON_NONCLEARBG;
|
|
|
|
if (!keepmarkup)
|
|
{
|
|
str += 4;
|
|
continue;
|
|
}
|
|
}
|
|
// else invalid code
|
|
goto messedup;
|
|
}
|
|
else if (str[1] == '[' && !linkstart)
|
|
{
|
|
if (keepmarkup)
|
|
{
|
|
if (!--outsize)
|
|
break;
|
|
*out++ = '^' | CON_HIDDEN;
|
|
}
|
|
if (!--outsize)
|
|
break;
|
|
|
|
//preserved flags and reset to white. links must contain their own colours.
|
|
linkinitflags = ext;
|
|
ext = COLOR_RED << CON_FGSHIFT;
|
|
linkstart = out;
|
|
*out++ = '[';
|
|
|
|
//never keep the markup
|
|
linkkeep = keepmarkup;
|
|
keepmarkup = false;
|
|
str+=2;
|
|
continue;
|
|
}
|
|
else if (str[1] == ']' && linkstart)
|
|
{
|
|
if (keepmarkup)
|
|
{
|
|
if (!--outsize)
|
|
break;
|
|
*out++ = '^' | CON_HIDDEN;
|
|
}
|
|
|
|
if (!--outsize)
|
|
break;
|
|
|
|
*out++ = ']'|CON_HIDDEN|CON_LINKSPECIAL;
|
|
|
|
//its a valid link, so we can hide it all now
|
|
*linkstart++ |= CON_HIDDEN|CON_LINKSPECIAL; //leading [ is hidden
|
|
while(linkstart < out-1 && (*linkstart&CON_CHARMASK) != '\\') //link text is NOT hidden
|
|
linkstart++;
|
|
while(linkstart < out) //but the infostring behind it is, as well as the terminator
|
|
*linkstart++ |= CON_HIDDEN;
|
|
|
|
//reset colours to how they used to be
|
|
ext = linkinitflags;
|
|
linkstart = NULL;
|
|
keepmarkup = linkkeep;
|
|
|
|
//never keep the markup
|
|
str+=2;
|
|
continue;
|
|
}
|
|
else if (str[1] == 'a')
|
|
{
|
|
ext ^= CON_2NDCHARSETTEXT;
|
|
}
|
|
else if (str[1] == 'b')
|
|
{
|
|
ext ^= CON_BLINKTEXT;
|
|
}
|
|
else if (str[1] == 'd')
|
|
{
|
|
if (linkstart)
|
|
ext = COLOR_RED << CON_FGSHIFT;
|
|
else
|
|
ext = defaultflags;
|
|
}
|
|
else if (str[1] == 'm')
|
|
ext ^= CON_2NDCHARSETTEXT;
|
|
else if (str[1] == 'h')
|
|
ext ^= CON_HALFALPHA;
|
|
else if (str[1] == 's') //store on stack (it's great for names)
|
|
{
|
|
if (extstackdepth < sizeof(extstack)/sizeof(extstack[0]))
|
|
{
|
|
extstack[extstackdepth] = ext;
|
|
extstackdepth++;
|
|
}
|
|
}
|
|
else if (str[1] == 'r') //restore from stack (it's great for names)
|
|
{
|
|
if (extstackdepth)
|
|
{
|
|
extstackdepth--;
|
|
ext = extstack[extstackdepth];
|
|
}
|
|
}
|
|
else if (str[1] == 'U') //unicode (16bit) char ^Uxxxx
|
|
{
|
|
if (!keepmarkup)
|
|
{
|
|
uc = 0;
|
|
uc |= dehex(str[2])<<12;
|
|
uc |= dehex(str[3])<<8;
|
|
uc |= dehex(str[4])<<4;
|
|
uc |= dehex(str[5])<<0;
|
|
|
|
if (!--outsize)
|
|
break;
|
|
*out++ = uc | ext;
|
|
str += 6;
|
|
|
|
continue;
|
|
}
|
|
}
|
|
else if (str[1] == '{') //unicode (Xbit) char ^{xxxx}
|
|
{
|
|
if (!keepmarkup)
|
|
{
|
|
int len;
|
|
uc = 0;
|
|
for (len = 2; ishexcode(str[len]); len++)
|
|
{
|
|
uc <<= 4;
|
|
uc |= dehex(str[len]);
|
|
}
|
|
|
|
//and eat the close too. oh god I hope its there.
|
|
if (str[len] == '}')
|
|
len++;
|
|
|
|
if (uc > CON_CHARMASK)
|
|
uc = 0xfffd;
|
|
|
|
if (!--outsize)
|
|
break;
|
|
*out++ = uc | ext;
|
|
str += len;
|
|
|
|
continue;
|
|
}
|
|
}
|
|
else if (str[1] == 'x') //RGB colours
|
|
{
|
|
if (ishexcode(str[2]) && ishexcode(str[3]) && ishexcode(str[4]))
|
|
{
|
|
int r, g, b;
|
|
r = dehex(str[2]);
|
|
g = dehex(str[3]);
|
|
b = dehex(str[4]);
|
|
|
|
ext = (ext & ~CON_RICHFOREMASK) | CON_RICHFORECOLOUR;
|
|
ext |= r<<CON_RICHRSHIFT;
|
|
ext |= g<<CON_RICHGSHIFT;
|
|
ext |= b<<CON_RICHBSHIFT;
|
|
|
|
if (!keepmarkup)
|
|
{
|
|
str += 5;
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
else if (str[1] == '^')
|
|
{
|
|
if (keepmarkup)
|
|
{
|
|
if (!--outsize)
|
|
break;
|
|
*out++ = (unsigned char)(*str) | ext;
|
|
}
|
|
str++;
|
|
|
|
if (*str)
|
|
goto messedup;
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
goto messedup;
|
|
}
|
|
|
|
if (!keepmarkup)
|
|
{
|
|
str+=2;
|
|
continue;
|
|
}
|
|
}
|
|
else if (*str == '&' && str[1] == 'c' && !(flags & PFS_NOMARKUP))
|
|
{
|
|
// ezQuake color codes
|
|
|
|
if (ishexcode(str[2]) && ishexcode(str[3]) && ishexcode(str[4]))
|
|
{
|
|
int r, g, b;
|
|
r = dehex(str[2]);
|
|
g = dehex(str[3]);
|
|
b = dehex(str[4]);
|
|
|
|
ext = (ext & ~CON_RICHFOREMASK) | CON_RICHFORECOLOUR;
|
|
ext |= r<<CON_RICHRSHIFT;
|
|
ext |= g<<CON_RICHGSHIFT;
|
|
ext |= b<<CON_RICHBSHIFT;
|
|
|
|
if (!keepmarkup)
|
|
{
|
|
str += 5;
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
else if (*str == '&' && str[1] == 'r' && !(flags & PFS_NOMARKUP))
|
|
{
|
|
//ezquake revert
|
|
ext = (COLOR_WHITE << CON_FGSHIFT) | (ext&~(CON_RICHFOREMASK|CON_RICHFORECOLOUR));
|
|
if (!keepmarkup)
|
|
{
|
|
str+=2;
|
|
continue;
|
|
}
|
|
}
|
|
else if (str[0] == '=' && str[1] == '`' && str[2] == 'k' && str[3] == '8' && str[4] == ':' && !keepmarkup)
|
|
{
|
|
//ezquake compat: koi8 compat for crazy russian people.
|
|
//we parse for compat but don't generate (they'll see utf-8 from us).
|
|
//this code can just recurse. saves affecting the rest of the code with weird encodings.
|
|
int l;
|
|
char temp[1024];
|
|
str += 5;
|
|
while(*str)
|
|
{
|
|
l = 0;
|
|
while (*str && l < sizeof(temp)-32 && !(str[0] == '`' && str[1] == '='))
|
|
l += utf8_encode(temp+l, koi2wc(*str++), sizeof(temp)-1);
|
|
//recurse
|
|
temp[l] = 0;
|
|
l = COM_ParseFunString(ext, temp, out, outsize, PFS_FORCEUTF8) - out;
|
|
outsize -= l;
|
|
out += l;
|
|
if (str[0] == '`' && str[1] == '=')
|
|
{
|
|
str+=2;
|
|
break;
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
else if (str[0] == '=' && str[1] == '`' && str[2] == 'u' && str[3] == '8' && str[4] == ':' && !keepmarkup)
|
|
{
|
|
int l;
|
|
char temp[1024];
|
|
str += 5;
|
|
while(*str)
|
|
{
|
|
l = 0;
|
|
while (*str && l < sizeof(temp)-32 && !(str[0] == '`' && str[1] == '='))
|
|
temp[l++] = *str++;
|
|
//recurse
|
|
temp[l] = 0;
|
|
l = COM_ParseFunString(ext, temp, out, outsize, PFS_FORCEUTF8) - out;
|
|
outsize -= l;
|
|
out += l;
|
|
if (str[0] == '`' && str[1] == '=')
|
|
{
|
|
str+=2;
|
|
break;
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
|
|
/*
|
|
else if ((str[0] == 'h' && str[1] == 't' && str[2] == 't' && str[3] == 'p' && str[4] == ':' && !linkstart && !(flags & (PFS_NOMARKUP|PFS_KEEPMARKUP))) ||
|
|
(str[0] == 'h' && str[1] == 't' && str[2] == 't' && str[3] == 'p' && str[4] == 's' && str[5] == ':' && !linkstart && !(flags & (PFS_NOMARKUP|PFS_KEEPMARKUP))))
|
|
{
|
|
//this code can just recurse. saves affecting the rest of the code with weird encodings.
|
|
int l;
|
|
char temp[1024];
|
|
conchar_t *ls, *le;
|
|
l = 0;
|
|
while (*str && l < sizeof(temp)-32 && (
|
|
(*str >= 'a' && *str <= 'z') ||
|
|
(*str >= 'A' && *str <= 'Z') ||
|
|
(*str >= '0' && *str <= '9') ||
|
|
*str == '.' || *str == '/' || *str == '&' || *str == '=' || *str == '_' || *str == '%' || *str == '?' || *str == ':'))
|
|
l += utf8_encode(temp+l, *str++, sizeof(temp)-1);
|
|
//recurse
|
|
temp[l] = 0;
|
|
|
|
if (!--outsize)
|
|
break;
|
|
*out++ = CON_LINKSTART;
|
|
ls = out;
|
|
l = COM_ParseFunString(COLOR_BLUE << CON_FGSHIFT, temp, out, outsize, PFS_FORCEUTF8|PFS_NOMARKUP) - out;
|
|
outsize -= l;
|
|
out += l;
|
|
le = out;
|
|
|
|
*out++ = '\\' | CON_HIDDEN;
|
|
*out++ = 'u' | CON_HIDDEN;
|
|
*out++ = 'r' | CON_HIDDEN;
|
|
*out++ = 'l' | CON_HIDDEN;
|
|
*out++ = '\\' | CON_HIDDEN;
|
|
while (ls < le)
|
|
*out++ = (*ls++ & CON_CHARMASK) | CON_HIDDEN;
|
|
*out++ = CON_LINKEND;
|
|
|
|
if (!--outsize)
|
|
break;
|
|
*out++ = CON_LINKEND;
|
|
continue;
|
|
}
|
|
*/
|
|
messedup:
|
|
if (!--outsize)
|
|
break;
|
|
uc = (unsigned char)(*str++);
|
|
if (utf8)
|
|
{
|
|
//utf8/iso8859-1 has it easy.
|
|
*out++ = uc | ext;
|
|
}
|
|
else
|
|
{
|
|
if (uc == '\n' || uc == '\r' || uc == '\t' || uc == '\v' || uc == ' ')
|
|
*out++ = uc | ext;
|
|
else if (uc >= 32 && uc < 127)
|
|
*out++ = uc | ext;
|
|
else if (uc >= 0x80+32 && uc <= 0xff) //anything using high chars is ascii, with the second charset
|
|
*out++ = ((uc&127) | ext) | CON_2NDCHARSETTEXT;
|
|
else //(other) control chars are regular printables in quake, and are not ascii. These ALWAYS use the bitmap/fallback font.
|
|
*out++ = uc | ext | 0xe000;
|
|
}
|
|
}
|
|
*out = 0;
|
|
|
|
COM_BiDi_Parse(oldout, out - oldout);
|
|
return out;
|
|
}
|
|
|
|
//remaps conchar_t character values to something valid in unicode, such that it is likely to be printable with standard char sets.
|
|
//unicode-to-ascii is not provided. you're expected to utf-8 the result or something.
|
|
//does not handle colour codes or hidden chars. add your own escape sequences if you need that.
|
|
//does not guarentee removal of control codes if eg the code was specified as an explicit unicode char.
|
|
unsigned int COM_DeQuake(conchar_t chr)
|
|
{
|
|
chr &= CON_CHARMASK;
|
|
|
|
/*only this range are quake chars*/
|
|
if (chr >= 0xe000 && chr < 0xe100)
|
|
{
|
|
chr &= 0xff;
|
|
if (chr >= 146 && chr < 156)
|
|
chr = chr - 146 + '0';
|
|
if (chr >= 0x12 && chr <= 0x1b)
|
|
chr = chr - 0x12 + '0';
|
|
if (chr == 143)
|
|
chr = '.';
|
|
if (chr == 128 || chr == 129 || chr == 130 || chr == 157 || chr == 158 || chr == 159)
|
|
chr = '-';
|
|
if (chr >= 128)
|
|
chr -= 128;
|
|
if (chr == 16)
|
|
chr = '[';
|
|
if (chr == 17)
|
|
chr = ']';
|
|
if (chr == 0x1c)
|
|
chr = 249;
|
|
}
|
|
/*this range contains pictograms*/
|
|
if (chr >= 0xe100 && chr < 0xe200)
|
|
{
|
|
chr = '?';
|
|
}
|
|
return chr;
|
|
}
|
|
|
|
//============================================================================
|
|
|
|
#define TOKENSIZE sizeof(com_token)
|
|
char com_token[TOKENSIZE];
|
|
int com_argc;
|
|
const char **com_argv;
|
|
|
|
com_tokentype_t com_tokentype;
|
|
|
|
|
|
/*
|
|
==============
|
|
COM_Parse
|
|
|
|
Parse a token out of a string
|
|
==============
|
|
*/
|
|
#ifndef COM_Parse
|
|
char *COM_Parse (const char *data)
|
|
{
|
|
int c;
|
|
int len;
|
|
|
|
if (out == com_token)
|
|
COM_AssertMainThread("COM_ParseOut: com_token");
|
|
|
|
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=='/')
|
|
{
|
|
if (data[1] == '/')
|
|
{
|
|
while (*data && *data != '\n')
|
|
data++;
|
|
goto skipwhite;
|
|
}
|
|
}
|
|
|
|
|
|
// handle quoted strings specially
|
|
if (c == '\"')
|
|
{
|
|
data++;
|
|
while (1)
|
|
{
|
|
if (len >= TOKENSIZE-1)
|
|
return (char*)data;
|
|
|
|
c = *data++;
|
|
if (c=='\"' || !c)
|
|
{
|
|
com_token[len] = 0;
|
|
return (char*)data;
|
|
}
|
|
com_token[len] = c;
|
|
len++;
|
|
}
|
|
}
|
|
|
|
// parse a regular word
|
|
do
|
|
{
|
|
if (len >= TOKENSIZE-1)
|
|
return (char*)data;
|
|
|
|
com_token[len] = c;
|
|
data++;
|
|
len++;
|
|
c = *data;
|
|
} while (c>32);
|
|
|
|
com_token[len] = 0;
|
|
return (char*)data;
|
|
}
|
|
#endif
|
|
|
|
//semi-colon delimited tokens
|
|
char *COM_ParseStringSet (const char *data, char *out, size_t outsize)
|
|
{
|
|
int c;
|
|
int len;
|
|
|
|
if (out == com_token)
|
|
COM_AssertMainThread("COM_ParseOut: com_token");
|
|
|
|
len = 0;
|
|
out[0] = 0;
|
|
|
|
if (!data)
|
|
return NULL;
|
|
|
|
// skip whitespace and semicolons
|
|
while ( (c = *data) <= ' ' || c == ';' )
|
|
{
|
|
if (c == 0)
|
|
return NULL; // end of file;
|
|
data++;
|
|
}
|
|
|
|
// parse a regular word
|
|
do
|
|
{
|
|
if (len >= outsize-1)
|
|
{
|
|
out[len] = 0;
|
|
return (char*)data;
|
|
}
|
|
|
|
out[len] = c;
|
|
data++;
|
|
len++;
|
|
c = *(unsigned char*)data;
|
|
} while (c>32 && c != ';');
|
|
|
|
out[len] = 0;
|
|
return (char*)data;
|
|
}
|
|
|
|
|
|
char *COM_ParseType (const char *data, char *out, int outlen, com_tokentype_t *toktype)
|
|
{
|
|
int c;
|
|
int len;
|
|
|
|
if (out == com_token)
|
|
COM_AssertMainThread("COM_ParseOut: com_token");
|
|
|
|
len = 0;
|
|
out[0] = 0;
|
|
if (toktype)
|
|
*toktype = TTP_EOF;
|
|
|
|
if (!data)
|
|
return NULL;
|
|
|
|
// skip whitespace
|
|
skipwhite:
|
|
while ( (c = *data) <= ' ')
|
|
{
|
|
if (c == 0)
|
|
return NULL; // end of file;
|
|
data++;
|
|
}
|
|
|
|
// skip // comments
|
|
if (c=='/')
|
|
{
|
|
if (data[1] == '/')
|
|
{
|
|
while (*data && *data != '\n')
|
|
data++;
|
|
goto skipwhite;
|
|
}
|
|
}
|
|
|
|
//skip / * comments
|
|
if (c == '/' && data[1] == '*')
|
|
{
|
|
data+=2;
|
|
while(*data)
|
|
{
|
|
if (*data == '*' && data[1] == '/')
|
|
{
|
|
data+=2;
|
|
goto skipwhite;
|
|
}
|
|
data++;
|
|
}
|
|
goto skipwhite;
|
|
}
|
|
|
|
// handle quoted strings specially
|
|
if (c == '\"')
|
|
{
|
|
if (toktype)
|
|
*toktype = TTP_STRING;
|
|
|
|
data++;
|
|
while (1)
|
|
{
|
|
if (len >= outlen-1)
|
|
{
|
|
out[len] = 0;
|
|
return (char*)data;
|
|
}
|
|
|
|
c = *data++;
|
|
if (c=='\"' || !c)
|
|
{
|
|
out[len] = 0;
|
|
return (char*)data;
|
|
}
|
|
out[len] = c;
|
|
len++;
|
|
}
|
|
}
|
|
|
|
// parse a regular word
|
|
if (toktype)
|
|
*toktype = TTP_RAWTOKEN;
|
|
do
|
|
{
|
|
if (len >= outlen-1)
|
|
{
|
|
out[len] = 0;
|
|
return (char*)data;
|
|
}
|
|
|
|
out[len] = c;
|
|
data++;
|
|
len++;
|
|
c = *data;
|
|
} while (c>32);
|
|
|
|
out[len] = 0;
|
|
return (char*)data;
|
|
}
|
|
|
|
//same as COM_Parse, but parses two quotes next to each other as a single quote as part of the string
|
|
char *COM_StringParse (const char *data, char *token, unsigned int tokenlen, qboolean expandmacros, qboolean qctokenize)
|
|
{
|
|
int c;
|
|
int len;
|
|
char *s;
|
|
|
|
len = 0;
|
|
token[0] = 0;
|
|
|
|
if (token == com_token)
|
|
COM_AssertMainThread("COM_ParseOut: com_token");
|
|
|
|
if (!data)
|
|
return NULL;
|
|
|
|
// skip whitespace
|
|
skipwhite:
|
|
while ( (c = *data), (unsigned)c <= ' ' && c != '\n')
|
|
{
|
|
if (c == 0)
|
|
return NULL; // end of file;
|
|
data++;
|
|
}
|
|
if (c == '\n')
|
|
{
|
|
token[len++] = c;
|
|
token[len] = 0;
|
|
return (char*)data+1;
|
|
}
|
|
|
|
// skip // comments
|
|
if (c=='/')
|
|
{
|
|
if (data[1] == '/')
|
|
{
|
|
while (*data && *data != '\n')
|
|
data++;
|
|
goto skipwhite;
|
|
}
|
|
}
|
|
|
|
//skip / * comments
|
|
if (c == '/' && data[1] == '*' && !qctokenize)
|
|
{
|
|
data+=2;
|
|
while(*data)
|
|
{
|
|
if (*data == '*' && data[1] == '/')
|
|
{
|
|
data+=2;
|
|
goto skipwhite;
|
|
}
|
|
data++;
|
|
}
|
|
goto skipwhite;
|
|
}
|
|
|
|
if (c == '\\' && data[1] == '\"')
|
|
{
|
|
return COM_ParseCString(data+1, token, tokenlen, NULL);
|
|
}
|
|
|
|
// handle quoted strings specially
|
|
if (c == '\"')
|
|
{
|
|
data++;
|
|
while (1)
|
|
{
|
|
if (len >= tokenlen-1)
|
|
{
|
|
token[len] = '\0';
|
|
return (char*)data;
|
|
}
|
|
|
|
|
|
c = *data++;
|
|
if (c=='\"')
|
|
{
|
|
c = *(data);
|
|
if (c!='\"')
|
|
{
|
|
token[len] = 0;
|
|
return (char*)data;
|
|
}
|
|
data++;
|
|
/* while (c=='\"')
|
|
{
|
|
token[len] = c;
|
|
len++;
|
|
c = *++data;
|
|
}
|
|
*/
|
|
}
|
|
if (!c)
|
|
{
|
|
token[len] = 0;
|
|
return (char*)data-1;
|
|
}
|
|
token[len] = c;
|
|
len++;
|
|
}
|
|
}
|
|
|
|
// handle quoted strings specially
|
|
if (c == '\'' && qctokenize)
|
|
{
|
|
data++;
|
|
while (1)
|
|
{
|
|
if (len >= tokenlen-1)
|
|
{
|
|
token[len] = '\0';
|
|
return (char*)data;
|
|
}
|
|
|
|
|
|
c = *data++;
|
|
if (c=='\'')
|
|
{
|
|
c = *(data);
|
|
if (c!='\'')
|
|
{
|
|
token[len] = 0;
|
|
return (char*)data;
|
|
}
|
|
while (c=='\'')
|
|
{
|
|
token[len] = c;
|
|
len++;
|
|
data++;
|
|
c = *(data+1);
|
|
}
|
|
}
|
|
if (!c)
|
|
{
|
|
token[len] = 0;
|
|
return (char*)data;
|
|
}
|
|
token[len] = c;
|
|
len++;
|
|
}
|
|
}
|
|
|
|
if (qctokenize && (c == '\n' || c == '{' || c == '}' || c == ')' || c == '(' || c == ']' || c == '[' || c == '\'' || c == ':' || c == ',' || c == ';'))
|
|
{
|
|
// single character
|
|
token[len++] = c;
|
|
token[len] = 0;
|
|
return (char*)data+1;
|
|
}
|
|
|
|
// parse a regular word
|
|
do
|
|
{
|
|
if (len >= tokenlen-1)
|
|
{
|
|
token[len] = '\0';
|
|
return (char*)data;
|
|
}
|
|
|
|
token[len] = c;
|
|
data++;
|
|
len++;
|
|
c = *data;
|
|
} while ((unsigned)c>32 && !(qctokenize && (c == '\n' || c == '{' || c == '}' || c == ')' || c == '(' || c == ']' || c == '[' || c == '\'' || c == ':' || c == ',' || c == ';')));
|
|
|
|
token[len] = 0;
|
|
|
|
if (!expandmacros)
|
|
return (char*)data;
|
|
|
|
//now we check for macros.
|
|
for (s = token, c= 0; c < len; c++, s++) //this isn't a quoted token by the way.
|
|
{
|
|
if (*s == '$')
|
|
{
|
|
cvar_t *macro;
|
|
char name[64];
|
|
int i;
|
|
|
|
for (i = 1; i < sizeof(name); i++)
|
|
{
|
|
if (((unsigned char*)s)[i] <= ' ' || s[i] == '$')
|
|
break;
|
|
}
|
|
|
|
Q_strncpyz(name, s+1, i);
|
|
i-=1;
|
|
|
|
macro = Cvar_FindVar(name);
|
|
if (macro) //got one...
|
|
{
|
|
if (len+strlen(macro->string)-(i+1) >= tokenlen-1) //give up.
|
|
{
|
|
token[len] = '\0';
|
|
return (char*)data;
|
|
}
|
|
memmove(s+strlen(macro->string), s+i+1, len-c-i);
|
|
memcpy(s, macro->string, strlen(macro->string));
|
|
s+=strlen(macro->string);
|
|
len+=strlen(macro->string)-(i+1);
|
|
}
|
|
}
|
|
}
|
|
|
|
return (char*)data;
|
|
}
|
|
|
|
#define DEFAULT_PUNCTUATION "(,{})(\':;=!><&|+"
|
|
char *COM_ParseToken (const char *data, const char *punctuation)
|
|
{
|
|
int c;
|
|
int len;
|
|
|
|
if (!punctuation)
|
|
punctuation = DEFAULT_PUNCTUATION;
|
|
|
|
COM_AssertMainThread("COM_ParseOut: com_token");
|
|
|
|
len = 0;
|
|
com_token[0] = 0;
|
|
|
|
if (!data)
|
|
{
|
|
com_tokentype = TTP_UNKNOWN;
|
|
return NULL;
|
|
}
|
|
|
|
// skip whitespace
|
|
skipwhite:
|
|
while ( (c = *(unsigned char*)data) <= ' ' && c != '\r' && c != '\n')
|
|
{
|
|
if (c == 0)
|
|
{
|
|
com_tokentype = TTP_UNKNOWN;
|
|
return NULL; // end of file;
|
|
}
|
|
data++;
|
|
}
|
|
|
|
//if windows, ignore the \r.
|
|
if (c == '\r' && data[1] == '\n')
|
|
c = *(unsigned char*)data++;
|
|
|
|
if (c == '\r' || c == '\n')
|
|
{
|
|
com_tokentype = TTP_LINEENDING;
|
|
com_token[0] = '\n';
|
|
com_token[1] = '\0';
|
|
data++;
|
|
return (char*)data;
|
|
}
|
|
|
|
// skip // comments
|
|
if (c=='/')
|
|
{
|
|
if (data[1] == '/')
|
|
{
|
|
while (*data && *data != '\n')
|
|
data++;
|
|
goto skipwhite;
|
|
}
|
|
else if (data[1] == '*')
|
|
{
|
|
data+=2;
|
|
while (*data && (*data != '*' || data[1] != '/'))
|
|
data++;
|
|
if (*data)
|
|
data++;
|
|
if (*data)
|
|
data++;
|
|
goto skipwhite;
|
|
}
|
|
}
|
|
|
|
// handle quoted strings specially
|
|
if (c == '\"')
|
|
{
|
|
com_tokentype = TTP_STRING;
|
|
data++;
|
|
while (1)
|
|
{
|
|
if (len >= TOKENSIZE-1)
|
|
{
|
|
com_token[len] = '\0';
|
|
return (char*)data;
|
|
}
|
|
c = *data++;
|
|
if (c=='\"' || !c)
|
|
{
|
|
com_token[len] = 0;
|
|
return (char*)data;
|
|
}
|
|
com_token[len] = c;
|
|
len++;
|
|
}
|
|
}
|
|
|
|
com_tokentype = TTP_UNKNOWN;
|
|
|
|
// parse single characters
|
|
if (strchr(punctuation, c))
|
|
{
|
|
com_token[len] = c;
|
|
len++;
|
|
com_token[len] = 0;
|
|
return (char*)(data+1);
|
|
}
|
|
|
|
// parse a regular word
|
|
do
|
|
{
|
|
if (len >= TOKENSIZE-1)
|
|
break;
|
|
com_token[len] = c;
|
|
data++;
|
|
len++;
|
|
c = *data;
|
|
if (strchr(punctuation, c))
|
|
break;
|
|
} while (c>32);
|
|
|
|
com_token[len] = 0;
|
|
return (char*)data;
|
|
}
|
|
|
|
const char *COM_QuotedString(const char *string, char *buf, int buflen, qboolean omitquotes)
|
|
{
|
|
const char *result = buf;
|
|
if (strchr(string, '\r') || strchr(string, '\n') || strchr(string, '\"'))
|
|
{
|
|
if (!omitquotes)
|
|
{
|
|
*buf++ = '\\'; //prefix so the reader knows its a quoted string.
|
|
*buf++ = '\"'; //opening quote
|
|
}
|
|
buflen -= 4;
|
|
while(*string && buflen >= 2)
|
|
{
|
|
switch(*string)
|
|
{
|
|
case '\n':
|
|
*buf++ = '\\';
|
|
*buf++ = 'n';
|
|
break;
|
|
case '\r':
|
|
*buf++ = '\\';
|
|
*buf++ = 'r';
|
|
break;
|
|
case '\t':
|
|
*buf++ = '\\';
|
|
*buf++ = 't';
|
|
break;
|
|
case '\'':
|
|
*buf++ = '\\';
|
|
*buf++ = '\'';
|
|
break;
|
|
case '\"':
|
|
*buf++ = '\\';
|
|
*buf++ = '\"';
|
|
break;
|
|
case '\\':
|
|
*buf++ = '\\';
|
|
*buf++ = '\\';
|
|
break;
|
|
case '$':
|
|
*buf++ = '\\';
|
|
*buf++ = '$';
|
|
break;
|
|
default:
|
|
*buf++ = *string;
|
|
break;
|
|
}
|
|
string++;
|
|
}
|
|
if (!omitquotes)
|
|
*buf++ = '\"'; //closing quote
|
|
*buf++ = 0;
|
|
return result;
|
|
}
|
|
else
|
|
{
|
|
if (!omitquotes)
|
|
*buf++ = '\"'; //opening quote
|
|
buflen -= 3;
|
|
while(*string && buflen >= 0)
|
|
{
|
|
*buf++ = *string++;
|
|
}
|
|
if (!omitquotes)
|
|
*buf++ = '\"'; //closing quote
|
|
*buf++ = 0;
|
|
return result;
|
|
}
|
|
}
|
|
|
|
char *COM_ParseCString (const char *data, char *token, size_t sizeoftoken, size_t *lengthwritten)
|
|
{
|
|
int c;
|
|
size_t len;
|
|
|
|
len = 0;
|
|
token[0] = 0;
|
|
|
|
if (token == com_token)
|
|
COM_AssertMainThread("COM_ParseCString: com_token");
|
|
|
|
if (lengthwritten)
|
|
*lengthwritten = 0;
|
|
|
|
if (!data)
|
|
return NULL;
|
|
|
|
// skip whitespace
|
|
skipwhite:
|
|
while ( (c = *data) <= ' ')
|
|
{
|
|
if (c == 0)
|
|
return NULL; // end of file;
|
|
data++;
|
|
}
|
|
|
|
// skip // comments
|
|
if (c=='/')
|
|
{
|
|
if (data[1] == '/')
|
|
{
|
|
while (*data && *data != '\n')
|
|
data++;
|
|
goto skipwhite;
|
|
}
|
|
}
|
|
|
|
|
|
// handle quoted strings specially
|
|
if (c == '\"')
|
|
{
|
|
data++;
|
|
while (1)
|
|
{
|
|
if (len >= sizeoftoken-2)
|
|
{
|
|
token[len] = '\0';
|
|
if (lengthwritten)
|
|
*lengthwritten = len;
|
|
return (char*)data;
|
|
}
|
|
|
|
c = *data++;
|
|
if (!c)
|
|
{
|
|
token[len] = 0;
|
|
if (lengthwritten)
|
|
*lengthwritten = len;
|
|
return (char*)data-1;
|
|
}
|
|
if (c == '\\')
|
|
{
|
|
c = *data++;
|
|
switch(c)
|
|
{
|
|
case '\r':
|
|
if (*data == '\n')
|
|
data++;
|
|
case '\n':
|
|
continue;
|
|
case 'n':
|
|
c = '\n';
|
|
break;
|
|
case 't':
|
|
c = '\t';
|
|
break;
|
|
case 'r':
|
|
c = '\r';
|
|
break;
|
|
case '$':
|
|
case '\\':
|
|
case '\'':
|
|
break;
|
|
case '"':
|
|
c = '"';
|
|
token[len] = c;
|
|
len++;
|
|
continue;
|
|
default:
|
|
c = '?';
|
|
break;
|
|
}
|
|
}
|
|
if (c=='\"' || !c)
|
|
{
|
|
token[len] = 0;
|
|
if (lengthwritten)
|
|
*lengthwritten = len;
|
|
return (char*)data;
|
|
}
|
|
token[len] = c;
|
|
len++;
|
|
}
|
|
}
|
|
|
|
// parse a regular word
|
|
do
|
|
{
|
|
if (len >= sizeoftoken-1)
|
|
break;
|
|
token[len] = c;
|
|
data++;
|
|
len++;
|
|
c = *data;
|
|
} while (c>32);
|
|
|
|
token[len] = 0;
|
|
if (lengthwritten)
|
|
*lengthwritten = len;
|
|
return (char*)data;
|
|
}
|
|
|
|
|
|
/*
|
|
================
|
|
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
|
|
================
|
|
*/
|
|
|
|
int COM_CheckNextParm (const char *parm, int last)
|
|
{
|
|
int i = last+1;
|
|
|
|
for ( ; i<com_argc ; i++)
|
|
{
|
|
if (!com_argv[i])
|
|
continue; // NEXTSTEP sometimes clears appkit vars.
|
|
if (!Q_strcmp (parm,com_argv[i]))
|
|
return i;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int COM_CheckParm (const char *parm)
|
|
{
|
|
return COM_CheckNextParm(parm, 0);
|
|
}
|
|
|
|
/*
|
|
===============
|
|
COM_ParsePlusSets
|
|
|
|
Looks for +set blah blah on the commandline, and creates cvars so that engine
|
|
functions may use the cvar before anything's loaded.
|
|
This isn't really needed, but might make some thing nicer.
|
|
===============
|
|
*/
|
|
void COM_ParsePlusSets (qboolean docbuf)
|
|
{
|
|
int i;
|
|
for (i=1 ; i<com_argc-2 ; i++)
|
|
{
|
|
if (!com_argv[i])
|
|
continue; // NEXTSTEP sometimes clears appkit vars.
|
|
if (!com_argv[i+1])
|
|
continue;
|
|
if (!com_argv[i+2])
|
|
continue;
|
|
|
|
if (*com_argv[i+1] == '-' || *com_argv[i+1] == '+')
|
|
continue; //erm
|
|
if (*com_argv[i+2] == '-' || *com_argv[i+2] == '+')
|
|
continue; //erm
|
|
|
|
if (docbuf)
|
|
{
|
|
if (!strcmp(com_argv[i], "+set") || !strcmp(com_argv[i], "+seta"))
|
|
{
|
|
Cbuf_AddText(com_argv[i]+1, RESTRICT_LOCAL);
|
|
Cbuf_AddText(" ", RESTRICT_LOCAL);
|
|
Cbuf_AddText(com_argv[i+1], RESTRICT_LOCAL);
|
|
Cbuf_AddText(" ", RESTRICT_LOCAL);
|
|
Cbuf_AddText(com_argv[i+2], RESTRICT_LOCAL);
|
|
Cbuf_AddText("\n", RESTRICT_LOCAL);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (!strcmp(com_argv[i], "+set"))
|
|
Cvar_Get(com_argv[i+1], com_argv[i+2], 0, "Cvars set on commandline");
|
|
else if (!strcmp(com_argv[i], "+seta"))
|
|
Cvar_Get(com_argv[i+1], com_argv[i+2], CVAR_ARCHIVE, "Cvars set on commandline");
|
|
}
|
|
i+=2;
|
|
}
|
|
}
|
|
|
|
void Cvar_DefaultFree(char *str);
|
|
/*
|
|
================
|
|
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)
|
|
{
|
|
char *newdef;
|
|
vfsfile_t *h;
|
|
|
|
h = FS_OpenVFS("gfx/pop.lmp", "rb", FS_GAME);
|
|
|
|
if (h)
|
|
{
|
|
static_registered = true;
|
|
VFS_CLOSE(h);
|
|
}
|
|
else
|
|
static_registered = false;
|
|
|
|
|
|
newdef = static_registered?"1":"0";
|
|
|
|
if (strcmp(registered.enginevalue, newdef))
|
|
{
|
|
if (registered.defaultstr != registered.enginevalue)
|
|
{
|
|
Cvar_DefaultFree(registered.defaultstr);
|
|
registered.defaultstr = NULL;
|
|
}
|
|
registered.enginevalue = newdef;
|
|
registered.defaultstr = newdef;
|
|
Cvar_ForceSet(®istered, newdef);
|
|
if (static_registered)
|
|
Con_TPrintf ("Playing registered version.\n");
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
================
|
|
COM_InitArgv
|
|
================
|
|
*/
|
|
void COM_InitArgv (int argc, const char **argv) //not allowed to tprint
|
|
{
|
|
qboolean safe;
|
|
int i;
|
|
size_t result;
|
|
|
|
#if !defined(NACL) && !defined(FTE_TARGET_WEB)
|
|
FILE *f;
|
|
|
|
if (argv && argv[0])
|
|
f = fopen(va("%s_p.txt", argv[0]), "rb");
|
|
else
|
|
f = NULL;
|
|
if (f)
|
|
{
|
|
char *buffer;
|
|
int len;
|
|
fseek(f, 0, SEEK_END);
|
|
len = ftell(f);
|
|
fseek(f, 0, SEEK_SET);
|
|
|
|
buffer = (char*)malloc(len+1);
|
|
result = fread(buffer, 1, len, f); // do something with result
|
|
|
|
if (result != len)
|
|
Con_Printf("COM_InitArgv() fread: Filename: %s, expected %i, result was %u (%s)\n",va("%s_p.txt", argv[0]),len,(unsigned int)result,strerror(errno));
|
|
|
|
buffer[len] = '\0';
|
|
|
|
while (*buffer && (argc < MAX_NUM_ARGVS))
|
|
{
|
|
while (*buffer && ((*buffer <= 32) || (*buffer > 126)))
|
|
buffer++;
|
|
|
|
if (*buffer)
|
|
{
|
|
argv[argc] = buffer;
|
|
argc++;
|
|
|
|
while (*buffer && ((*buffer > 32) && (*buffer <= 126)))
|
|
buffer++;
|
|
|
|
if (*buffer)
|
|
{
|
|
*buffer = 0;
|
|
buffer++;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
|
|
fclose(f);
|
|
}
|
|
#endif
|
|
|
|
safe = false;
|
|
|
|
for (com_argc=0 ; (com_argc<MAX_NUM_ARGVS) && (com_argc < argc) ;
|
|
com_argc++)
|
|
{
|
|
largv[com_argc] = argv[com_argc];
|
|
if (!Q_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;
|
|
}
|
|
|
|
/*
|
|
================
|
|
COM_AddParm
|
|
|
|
Adds the given string at the end of the current argument list
|
|
================
|
|
*/
|
|
void COM_AddParm (const char *parm)
|
|
{
|
|
largv[com_argc++] = parm;
|
|
}
|
|
|
|
/*
|
|
=======================
|
|
COM_Version_f
|
|
======================
|
|
*/
|
|
void COM_Version_f (void)
|
|
{
|
|
Con_Printf("%s\n", version_string());
|
|
|
|
Con_TPrintf ("Exe: %s %s\n", __DATE__, __TIME__);
|
|
|
|
#ifdef SVNREVISION
|
|
if (strcmp(STRINGIFY(SVNREVISION), "-"))
|
|
Con_Printf("SVN Revision: %s\n",STRINGIFY(SVNREVISION));
|
|
#endif
|
|
|
|
#ifdef _DEBUG
|
|
Con_Printf("debug build\n");
|
|
#endif
|
|
#ifdef MINIMAL
|
|
Con_Printf("minimal build\n");
|
|
#endif
|
|
#ifdef CLIENTONLY
|
|
Con_Printf("client-only build\n");
|
|
#endif
|
|
#ifdef SERVERONLY
|
|
Con_Printf("dedicated server build\n");
|
|
#else
|
|
Con_Printf("Renderers:");
|
|
#ifdef GLQUAKE
|
|
#ifdef GLESONLY
|
|
Con_Printf(" OpenGLES");
|
|
#else
|
|
Con_Printf(" OpenGL");
|
|
#endif
|
|
#ifdef GLSLONLY
|
|
Con_Printf("(GLSL)");
|
|
#endif
|
|
#endif
|
|
#ifdef D3D9QUAKE
|
|
Con_Printf(" Direct3D9");
|
|
#endif
|
|
#ifdef D3D11QUAKE
|
|
Con_Printf(" Direct3D11");
|
|
#endif
|
|
#ifdef SWQUAKE
|
|
Con_Printf(" Software");
|
|
#endif
|
|
Con_Printf("\n");
|
|
#endif
|
|
|
|
#ifdef QCJIT
|
|
Con_Printf("QuakeC just-in-time compiler (QCJIT) enabled\n");
|
|
#endif
|
|
|
|
#ifdef FTE_SDL
|
|
Con_Printf("SDL version: %d.%d.%d\n", SDL_MAJOR_VERSION, SDL_MINOR_VERSION, SDL_PATCHLEVEL);
|
|
#endif
|
|
|
|
// Don't print both as a 64bit MinGW built client
|
|
#if defined(__MINGW32__)
|
|
Con_Printf("Compiled with MinGW32/64 version: %i.%i\n",__MINGW32_MAJOR_VERSION, __MINGW32_MINOR_VERSION);
|
|
#endif
|
|
|
|
#ifdef __CYGWIN__
|
|
Con_Printf("Compiled with Cygwin\n");
|
|
#endif
|
|
|
|
#ifdef __clang__
|
|
Con_Printf("Compiled with clang version: %i.%i.%i (%s)\n",__clang_major__, __clang_minor__, __clang_patchlevel__, __VERSION__);
|
|
#elif defined(__GNUC__)
|
|
Con_Printf("Compiled with GCC version: %i.%i.%i (%s)\n",__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__, __VERSION__);
|
|
|
|
#ifdef __OPTIMIZE__
|
|
#ifdef __OPTIMIZE_SIZE__
|
|
Con_Printf("Optimized for size\n");
|
|
#else
|
|
Con_Printf("Optimized for speed\n");
|
|
#endif
|
|
#endif
|
|
|
|
#ifdef __NO_INLINE__
|
|
Con_Printf("GCC Optimization: Functions currently not inlined into their callers\n");
|
|
#else
|
|
Con_Printf("GCC Optimization: Functions currently inlined into their callers\n");
|
|
#endif
|
|
#endif
|
|
|
|
#ifdef _WIN64
|
|
Con_Printf("Compiled for 64bit windows\n");
|
|
#endif
|
|
#if defined(_M_AMD64) || defined(__amd64__)
|
|
Con_Printf("Compiled for AMD64 compatible cpus\n");
|
|
#endif
|
|
|
|
#ifdef _M_IX86
|
|
Con_Printf("x86 optimized for: ");
|
|
|
|
if (_M_IX86 == 600) { Con_Printf("Blend or Pentium Pro, Pentium II and Pentium III"); }
|
|
else if (_M_IX86 == 500) { Con_Printf("Pentium"); }
|
|
else if (_M_IX86 == 400) { Con_Printf("486"); }
|
|
else if (_M_IX86 == 300) { Con_Printf("386"); }
|
|
else
|
|
{
|
|
Con_Printf("Unknown (%i)\n",_M_IX86);
|
|
}
|
|
|
|
Con_Printf("\n");
|
|
#endif
|
|
|
|
#ifdef _M_IX86_FP
|
|
if (_M_IX86_FP == 0) { Con_Printf("SSE & SSE2 instructions disabled\n"); }
|
|
else if (_M_IX86_FP == 1) { Con_Printf("SSE instructions enabled\n"); }
|
|
else if (_M_IX86_FP == 2) { Con_Printf("SSE2 instructions enabled\n"); }
|
|
else
|
|
{
|
|
Con_Printf("Unknown Arch specified: %i\n",_M_IX86_FP);
|
|
}
|
|
#endif
|
|
|
|
#ifdef _MSC_VER
|
|
if (_MSC_VER == 600) { Con_Printf("C Compiler version 6.0\n"); }
|
|
else if (_MSC_VER == 700) { Con_Printf("C/C++ compiler version 7.0\n"); }
|
|
else if (_MSC_VER == 800) { Con_Printf("Visual C++, Windows, version 1.0 or Visual C++, 32-bit, version 1.0\n"); }
|
|
else if (_MSC_VER == 900) { Con_Printf("Visual C++, Windows, version 2.0 or Visual C++, 32-bit, version 2.x\n"); }
|
|
else if (_MSC_VER == 1000) { Con_Printf("Visual C++, 32-bit, version 4.0\n"); }
|
|
else if (_MSC_VER == 1020) { Con_Printf("Visual C++, 32-bit, version 4.2\n"); }
|
|
else if (_MSC_VER == 1100) { Con_Printf("Visual C++, 32-bit, version 5.0\n"); }
|
|
else if (_MSC_VER == 1200) { Con_Printf("Visual C++, 32-bit, version 6.0\n"); }
|
|
else if (_MSC_VER == 1300) { Con_Printf("Visual C++, version 7.0\n"); }
|
|
else if (_MSC_VER == 1310) { Con_Printf("Visual C++ 2003, version 7.1\n"); }
|
|
else if (_MSC_VER == 1400) { Con_Printf("Visual C++ 2005, version 8.0\n"); }
|
|
else if (_MSC_VER == 1500) { Con_Printf("Visual C++ 2008, version 9.0\n"); }
|
|
else if (_MSC_VER == 1600) { Con_Printf("Visual C++ 2010, version 10.0\n"); }
|
|
else
|
|
{
|
|
#ifdef _MSC_BUILD
|
|
Con_Printf("Unknown Microsoft C++ compiler: %i %i %i\n",_MSC_VER, _MSC_FULL_VER, _MSC_BUILD);
|
|
#else
|
|
Con_Printf("Unknown Microsoft C++ compiler: %i %i\n",_MSC_VER, _MSC_FULL_VER);
|
|
#endif
|
|
}
|
|
#endif
|
|
|
|
#ifdef MULTITHREAD
|
|
#ifdef LOADERTHREAD
|
|
Con_Printf("multithreading: enabled (loader enabled)\n");
|
|
#else
|
|
Con_Printf("multithreading: enabled (no loader)\n");
|
|
#endif
|
|
#else
|
|
Con_Printf("multithreading: disabled\n");
|
|
#endif
|
|
|
|
//print out which libraries are disabled
|
|
#ifndef AVAIL_ZLIB
|
|
Con_Printf("zlib disabled\n");
|
|
#else
|
|
Con_Printf("zlib: %s\n", ZLIB_VERSION);
|
|
#endif
|
|
|
|
|
|
#ifndef SERVERONLY
|
|
//but print client ones only if we're not dedicated
|
|
#ifndef AVAIL_PNGLIB
|
|
Con_Printf("libpng disabled\n");
|
|
#else
|
|
Con_Printf("libPNG %s -%s", PNG_LIBPNG_VER_STRING, PNG_HEADER_VERSION_STRING);
|
|
#endif
|
|
#ifndef AVAIL_JPEGLIB
|
|
Con_Printf("libjpeg disabled\n");
|
|
#else
|
|
Con_Printf("libjpeg: %i (%d series)\n", JPEG_LIB_VERSION, ( JPEG_LIB_VERSION / 10 ) );
|
|
#endif
|
|
|
|
Con_Printf("VoiceChat:");
|
|
#if !defined(VOICECHAT)
|
|
Con_Printf(" disabled");
|
|
#else
|
|
#ifdef SPEEX_STATIC
|
|
Con_Printf(" speex(static)");
|
|
#else
|
|
Con_Printf(" speex(dynamic)");
|
|
#endif
|
|
#ifdef OPUS_STATIC
|
|
Con_Printf(" opus(static)");
|
|
#else
|
|
Con_Printf(" opus(dynamic)");
|
|
#endif
|
|
#endif
|
|
Con_Printf("\n");
|
|
|
|
Con_Printf("Audio Decoders:");
|
|
#ifndef AVAIL_OGGVORBIS
|
|
Con_Printf(" ^h(disabled: Ogg Vorbis)^7");
|
|
#elif defined(LIBVORBISFILE_STATIC)
|
|
Con_Printf(" Ogg Vorbis(static)");
|
|
#else
|
|
Con_Printf(" Ogg Vorbis(dynamic)");
|
|
#endif
|
|
#if defined(_WIN32) && !defined(WINRT) && !defined(NOMEDIA)
|
|
Con_Printf(" mp3(system)");
|
|
#endif
|
|
Con_Printf("\n");
|
|
#endif
|
|
|
|
#ifdef SQL
|
|
Con_Printf("Databases:");
|
|
#ifdef USE_MYSQL
|
|
Con_Printf(" mySQL(dynamic)");
|
|
#else
|
|
Con_Printf(" ^h(disabled: mySQL)^7");
|
|
#endif
|
|
#ifdef USE_SQLITE
|
|
Con_Printf(" sqlite(dynamic)");
|
|
#else
|
|
Con_Printf(" ^h(disabled: sqlite)^7");
|
|
#endif
|
|
Con_Printf("\n");
|
|
#endif
|
|
|
|
Con_Printf("Misc:");
|
|
#ifdef SUBSERVERS
|
|
Con_Printf(" mapcluster(enabled)");
|
|
#else
|
|
Con_Printf(" ^h(disabled: mapcluster)^7");
|
|
#endif
|
|
#ifndef SERVERONLY
|
|
#ifdef AVAIL_FREETYPE
|
|
Con_Printf(" freetype2");
|
|
#else
|
|
Con_Printf(" ^h(disabled: freetype2)^7");
|
|
#endif
|
|
#ifdef AVAIL_OPENAL
|
|
Con_Printf(" openal");
|
|
#else
|
|
Con_Printf(" ^h(disabled: openal)^7");
|
|
#endif
|
|
#endif
|
|
Con_Printf("\n");
|
|
|
|
#ifdef _WIN32
|
|
#ifndef AVAIL_DINPUT
|
|
Con_Printf("DirectInput disabled\n");
|
|
#endif
|
|
#ifndef AVAIL_DSOUND
|
|
Con_Printf("DirectSound disabled\n");
|
|
#endif
|
|
#ifndef AVAIL_D3D
|
|
Con_Printf("Direct3D disabled\n");
|
|
#endif
|
|
#ifndef AVAIL_DDRAW
|
|
Con_Printf("DirectDraw disabled\n");
|
|
#endif
|
|
#endif
|
|
|
|
Con_Printf("Games:");
|
|
#if defined(Q3SERVER) && defined(Q3CLIENT)
|
|
Con_Printf(" Quake3");
|
|
#elif defined(Q3SERVER)
|
|
Con_Printf(" Quake3(server)");
|
|
#elif defined(Q3CLIENT)
|
|
Con_Printf(" Quake3(client)");
|
|
#elif defined(Q3BSPS)
|
|
Con_Printf(" Quake3(bsp only)");
|
|
#else
|
|
Con_Printf(" ^h(disabled: Quake3)^7");
|
|
#endif
|
|
#if defined(Q2SERVER) && defined(Q2CLIENT)
|
|
Con_Printf(" Quake2");
|
|
#elif defined(Q2SERVER)
|
|
Con_Printf(" Quake2(server)");
|
|
#elif defined(Q2CLIENT)
|
|
Con_Printf(" Quake2(client)");
|
|
#elif defined(Q2BSPS)
|
|
Con_Printf(" Quake2(bsp only)");
|
|
#else
|
|
Con_Printf(" ^h(disabled: Quake2)^7");
|
|
#endif
|
|
#if defined(HEXEN2)
|
|
Con_Printf(" Hexen2");
|
|
#else
|
|
Con_Printf(" ^h(disabled: Hexen2)^7");
|
|
#endif
|
|
#if defined(NQPROT)
|
|
Con_Printf(" NetQuake");
|
|
#else
|
|
Con_Printf(" ^h(disabled: NetQuake)");
|
|
#endif
|
|
#if defined(VM_Q1)
|
|
Con_Printf(" ssq1qvm");
|
|
#endif
|
|
#if defined(VM_LUA)
|
|
Con_Printf(" ssq1lua(dynamic)");
|
|
#endif
|
|
#if defined(MENU_DAT)
|
|
Con_Printf(" menuqc");
|
|
#endif
|
|
#if defined(CSQC_DAT)
|
|
Con_Printf(" csqc");
|
|
#endif
|
|
#ifndef CLIENTONLY
|
|
Con_Printf(" ssqc");
|
|
#endif
|
|
Con_Printf("\n");
|
|
}
|
|
|
|
void COM_CrashMe_f(void)
|
|
{
|
|
int *crashaddr = (int*)0x05;
|
|
|
|
*crashaddr = 0;
|
|
}
|
|
|
|
void COM_ErrorMe_f(void)
|
|
{
|
|
Sys_Error("\"errorme\" command used");
|
|
}
|
|
|
|
|
|
|
|
#ifdef LOADERTHREAD
|
|
#define WORKERTHREADS (1+1+4)
|
|
/*multithreading worker thread stuff*/
|
|
static void *com_workercondition[WORKERTHREADS];
|
|
static qboolean com_workerdone[WORKERTHREADS];
|
|
static void *com_workerthread[WORKERTHREADS];
|
|
static unsigned int mainthreadid;
|
|
qboolean com_fatalerror;
|
|
static struct com_work_s
|
|
{
|
|
struct com_work_s *next;
|
|
void(*func)(void *ctx, void *data, size_t a, size_t b);
|
|
void *ctx;
|
|
void *data;
|
|
size_t a;
|
|
size_t b;
|
|
} *com_work_head[WORKERTHREADS], *com_work_tail[WORKERTHREADS];
|
|
static void Sys_ErrorThread(void *ctx, void *data, size_t a, size_t b)
|
|
{
|
|
Sys_Error(data);
|
|
}
|
|
void COM_WorkerAbort(char *message)
|
|
{
|
|
struct com_work_s work;
|
|
com_fatalerror = true;
|
|
if (Sys_IsMainThread())
|
|
return;
|
|
|
|
if (!com_workercondition[0])
|
|
return; //Sys_IsMainThread was probably called too early...
|
|
|
|
work.func = Sys_ErrorThread;
|
|
work.ctx = NULL;
|
|
work.data = message;
|
|
work.a = 0;
|
|
work.b = 0;
|
|
|
|
Sys_LockConditional(com_workercondition[0]);
|
|
if (com_work_tail[0])
|
|
{
|
|
com_work_tail[0]->next = &work;
|
|
com_work_tail[0] = &work;
|
|
}
|
|
else
|
|
com_work_head[0] = com_work_tail[0] = &work;
|
|
Sys_ConditionSignal(com_workercondition[0]);
|
|
Sys_UnlockConditional(com_workercondition[0]);
|
|
|
|
while(com_fatalerror)
|
|
Sys_Sleep(0.1);
|
|
Sys_ThreadAbort();
|
|
}
|
|
//return if there's *any* loading that needs to be done anywhere.
|
|
qboolean COM_HasWork(void)
|
|
{
|
|
unsigned int i;
|
|
for (i = 0; i < WORKERTHREADS-1; i++)
|
|
{
|
|
if (com_work_head[i])
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
//thread==0 is main thread, thread==1 is a worker thread
|
|
void COM_AddWork(int thread, void(*func)(void *ctx, void *data, size_t a, size_t b), void *ctx, void *data, size_t a, size_t b)
|
|
{
|
|
struct com_work_s *work;
|
|
|
|
//no worker there, just do it immediately on this thread instead of pushing it to the worker.
|
|
if (thread && (!com_workerthread[thread] || com_fatalerror))
|
|
{
|
|
func(ctx, data, a, b);
|
|
return;
|
|
}
|
|
|
|
//build the work
|
|
work = Z_Malloc(sizeof(*work));
|
|
work->func = func;
|
|
work->ctx = ctx;
|
|
work->data = data;
|
|
work->a = a;
|
|
work->b = b;
|
|
|
|
//queue it (fifo)
|
|
Sys_LockConditional(com_workercondition[thread]);
|
|
if (com_work_tail[thread])
|
|
{
|
|
com_work_tail[thread]->next = work;
|
|
com_work_tail[thread] = work;
|
|
}
|
|
else
|
|
com_work_head[thread] = com_work_tail[thread] = work;
|
|
|
|
// Sys_Printf("%x: Queued work %p (%s)\n", thread, work->ctx, work->ctx?(char*)work->ctx:"?");
|
|
|
|
Sys_ConditionSignal(com_workercondition[thread]);
|
|
Sys_UnlockConditional(com_workercondition[thread]);
|
|
|
|
// if (!com_workerthread[thread])
|
|
// while(COM_DoWork(thread, false))
|
|
// ;
|
|
}
|
|
//leavelocked = false == poll mode.
|
|
//leavelocked = true == safe sleeping
|
|
qboolean COM_DoWork(int thread, qboolean leavelocked)
|
|
{
|
|
struct com_work_s *work;
|
|
if (!leavelocked)
|
|
{
|
|
//skip the locks if it looks like we can be lazy.
|
|
if (!com_work_head[thread])
|
|
return false;
|
|
Sys_LockConditional(com_workercondition[thread]);
|
|
}
|
|
work = com_work_head[thread];
|
|
if (work)
|
|
com_work_head[thread] = work->next;
|
|
if (!com_work_head[thread])
|
|
com_work_head[thread] = com_work_tail[thread] = NULL;
|
|
|
|
if (work)
|
|
{
|
|
// Sys_Printf("%x: Doing work %p (%s)\n", thread, work->ctx, work->ctx?(char*)work->ctx:"?");
|
|
Sys_UnlockConditional(com_workercondition[thread]);
|
|
|
|
work->func(work->ctx, work->data, work->a, work->b);
|
|
Z_Free(work);
|
|
|
|
if (leavelocked)
|
|
Sys_LockConditional(com_workercondition[thread]);
|
|
|
|
return true; //did something, check again
|
|
}
|
|
|
|
if (!leavelocked)
|
|
Sys_UnlockConditional(com_workercondition[thread]);
|
|
|
|
//nothing going on, if leavelocked then noone can add anything until we sleep.
|
|
return false;
|
|
}
|
|
static void COM_WorkerSync_StopWorker(void *ctx, void *data, size_t a, size_t b)
|
|
{
|
|
com_workerdone[a] = true;
|
|
}
|
|
static void COM_WorkerSync_SignalMain(void *ctx, void *data, size_t a, size_t b)
|
|
{
|
|
Sys_LockConditional(com_workercondition[a]);
|
|
com_workerdone[a] = true;
|
|
Sys_ConditionSignal(com_workercondition[a]);
|
|
Sys_UnlockConditional(com_workercondition[a]);
|
|
}
|
|
static int COM_WorkerThread(void *arg)
|
|
{
|
|
int thread = (void**)arg - com_workerthread;
|
|
Sys_LockConditional(com_workercondition[thread]);
|
|
do
|
|
{
|
|
while(COM_DoWork(thread, true))
|
|
;
|
|
if (com_workerdone[thread])
|
|
break;
|
|
} while (Sys_ConditionWait(com_workercondition[thread]));
|
|
Sys_UnlockConditional(com_workercondition[thread]);
|
|
|
|
//no more work please...
|
|
*(void**)arg = NULL;
|
|
//and wake up main thread
|
|
COM_WorkerSync_SignalMain(NULL, NULL, 0, 0);
|
|
return 0;
|
|
}
|
|
|
|
#ifndef COM_AssertMainThread
|
|
void COM_AssertMainThread(const char *msg)
|
|
{
|
|
if (com_resourcemutex && !Sys_IsMainThread())
|
|
{
|
|
Sys_Error("Not on main thread: %s", msg);
|
|
}
|
|
}
|
|
#endif
|
|
void COM_DestroyWorkerThread(void)
|
|
{
|
|
int i;
|
|
com_fatalerror = false;
|
|
for (i = 0; i < WORKERTHREADS; i++)
|
|
{
|
|
if (com_workerthread[i])
|
|
{
|
|
void *thread = com_workerthread[i];
|
|
com_workerdone[0] = false;
|
|
//send it the terminate message
|
|
COM_AddWork(i, COM_WorkerSync_StopWorker, NULL, NULL, i, 0);
|
|
|
|
//wait for the response while servicing anything that it might be waiting for.
|
|
Sys_LockConditional(com_workercondition[0]);
|
|
do
|
|
{
|
|
if (com_fatalerror)
|
|
break;
|
|
while(COM_DoWork(0, true))
|
|
;
|
|
if (com_workerdone[0])
|
|
break;
|
|
} while (Sys_ConditionWait(com_workercondition[0]));
|
|
Sys_UnlockConditional(com_workercondition[0]);
|
|
|
|
//and now that we know its going down and will not wait any more, we can block for its final moments
|
|
Sys_WaitOnThread(thread);
|
|
|
|
//finish any work that got posted to it that it neglected to finish.
|
|
while(COM_DoWork(i, true))
|
|
;
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < WORKERTHREADS; i++)
|
|
{
|
|
if (com_workercondition[i])
|
|
Sys_DestroyConditional(com_workercondition[i]);
|
|
com_workercondition[i] = NULL;
|
|
}
|
|
|
|
if (com_resourcemutex)
|
|
Sys_DestroyMutex(com_resourcemutex);
|
|
com_resourcemutex = NULL;
|
|
}
|
|
|
|
//fully flushes ALL pending work.
|
|
void COM_WorkerFullSync(void)
|
|
{
|
|
qboolean repeat;
|
|
int i;
|
|
|
|
for (i = 1; i < WORKERTHREADS; i++)
|
|
{
|
|
if (!com_workerthread[i])
|
|
continue;
|
|
|
|
//main thread asks worker thread to set main thread's 'done' flag.
|
|
//the worker might be posting work to the main thread and back (shaders with texures) so make sure that the only work we do before the reply is the reply itself.
|
|
do
|
|
{
|
|
int cmds = 0;
|
|
com_workerdone[0] = false;
|
|
repeat = COM_HasWork();
|
|
COM_AddWork(i, COM_WorkerSync_SignalMain, NULL, NULL, 0, 0);
|
|
Sys_LockConditional(com_workercondition[0]);
|
|
do
|
|
{
|
|
if (com_fatalerror)
|
|
break;
|
|
while(COM_DoWork(0, true))
|
|
cmds++;
|
|
if (com_workerdone[0])
|
|
break;
|
|
} while (Sys_ConditionWait(com_workercondition[0]));
|
|
Sys_UnlockConditional(com_workercondition[0]);
|
|
if (com_fatalerror)
|
|
break;
|
|
if (cmds > 1)
|
|
repeat = true;
|
|
} while (COM_DoWork(0, false) || repeat); //outer loop ensures there isn't anything pingponging between
|
|
}
|
|
}
|
|
|
|
//main thread wants a specific object to be prioritised.
|
|
//an ancestor of the work must be pending on either the main thread or the worker thread.
|
|
//typically the worker gives us a signal to handle the final activation of the object.
|
|
//the address should be the load status. the value is the current value.
|
|
//the work that we're waiting for will be considered complete when the address is no longer set to value.
|
|
void COM_WorkerPartialSync(void *priorityctx, int *address, int value)
|
|
{
|
|
struct com_work_s **link, *work, *prev;
|
|
double time1 = Sys_DoubleTime();
|
|
|
|
// Con_Printf("waiting for %p %s\n", priorityctx, priorityctx);
|
|
|
|
//boost the priority of the object that we're waiting for on the other thread, if we can find it.
|
|
//this avoids waiting for everything.
|
|
//if we can't find it, then its probably currently being processed anyway.
|
|
//main thread is meant to do all loadstate value changes anyway, ensuring that we're woken up properly in this case.
|
|
if (priorityctx)
|
|
{
|
|
unsigned int thread;
|
|
qboolean found = false;
|
|
for (thread = 1; thread < WORKERTHREADS && !found; thread++)
|
|
{
|
|
Sys_LockConditional(com_workercondition[thread]);
|
|
for (link = &com_work_head[thread], work = NULL; *link; link = &(*link)->next)
|
|
{
|
|
prev = work;
|
|
work = *link;
|
|
if (work->ctx == priorityctx)
|
|
{ //unlink it
|
|
|
|
*link = work->next;
|
|
if (!work->next)
|
|
com_work_tail[thread] = prev;
|
|
//link it in at the head, so its the next thing seen.
|
|
work->next = com_work_head[thread];
|
|
com_work_head[thread] = work;
|
|
if (!work->next)
|
|
com_work_tail[thread] = work;
|
|
found = true;
|
|
|
|
break; //found it, nothing else to do.
|
|
}
|
|
}
|
|
//we've not actually added any work, so no need to signal
|
|
Sys_UnlockConditional(com_workercondition[thread]);
|
|
}
|
|
if (!found)
|
|
Con_DPrintf("Might be in for a long wait for %s\n", priorityctx);
|
|
}
|
|
|
|
Sys_LockConditional(com_workercondition[0]);
|
|
do
|
|
{
|
|
if (com_fatalerror)
|
|
break;
|
|
while(COM_DoWork(0, true))
|
|
{
|
|
//give up as soon as we're done
|
|
if (*address != value)
|
|
break;
|
|
}
|
|
//if our object's state has changed, we're done
|
|
if (*address != value)
|
|
break;
|
|
} while (Sys_ConditionWait(com_workercondition[0]));
|
|
Sys_UnlockConditional(com_workercondition[0]);
|
|
|
|
// Con_Printf("Waited %f for %s\n", Sys_DoubleTime() - time1, priorityctx);
|
|
}
|
|
|
|
static void COM_WorkerPing(void *ctx, void *data, size_t a, size_t b)
|
|
{
|
|
double *timestamp = data;
|
|
if (!b)
|
|
COM_AddWork(0, COM_WorkerPing, ctx, data, 0, 1);
|
|
else
|
|
{
|
|
Con_Printf("Ping: %g\n", Sys_DoubleTime() - *timestamp);
|
|
}
|
|
}
|
|
static void COM_WorkerTest_f(void)
|
|
{
|
|
if (com_workerthread)
|
|
{
|
|
double *timestamp = Z_Malloc(sizeof(*timestamp));
|
|
*timestamp = Sys_DoubleTime();
|
|
COM_AddWork(1, COM_WorkerPing, NULL, timestamp, 0, 0);
|
|
}
|
|
else
|
|
Con_Printf("Worker is not active.\n");
|
|
}
|
|
|
|
|
|
cvar_t worker_flush = CVARD("worker_flush", "1", "Is set, process the entire load queue, loading stuff faster but at the risk of stalling.");
|
|
static void COM_InitWorkerThread(void)
|
|
{
|
|
int i;
|
|
|
|
//in theory, we could run multiple workers, signalling a different one in turn for each bit of work.
|
|
com_resourcemutex = Sys_CreateMutex();
|
|
for (i = 0; i < WORKERTHREADS; i++)
|
|
{
|
|
com_workercondition[i] = Sys_CreateConditional();
|
|
}
|
|
if (!COM_CheckParm("-noworker"))
|
|
{
|
|
for (i = 1; i < WORKERTHREADS; i++)
|
|
{
|
|
com_workerthread[i] = Sys_CreateThread(va("loadworker_%i", i), COM_WorkerThread, &com_workerthread[i], 0, 256*1024);
|
|
}
|
|
}
|
|
|
|
Cmd_AddCommand ("worker_test", COM_WorkerTest_f);
|
|
Cvar_Register(&worker_flush, NULL);
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
================
|
|
COM_Init
|
|
================
|
|
*/
|
|
void COM_Init (void)
|
|
{
|
|
qbyte swaptest[2] = {1,0};
|
|
|
|
wantquit = false;
|
|
|
|
// set the qbyte swapping variables in a portable manner
|
|
if ( *(short *)swaptest == 1)
|
|
{
|
|
bigendian = false;
|
|
BigShort = ShortSwap;
|
|
LittleShort = ShortNoSwap;
|
|
BigLong = LongSwap;
|
|
LittleLong = LongNoSwap;
|
|
BigFloat = FloatSwap;
|
|
LittleFloat = FloatNoSwap;
|
|
}
|
|
else
|
|
{
|
|
bigendian = true;
|
|
BigShort = ShortNoSwap;
|
|
LittleShort = ShortSwap;
|
|
BigLong = LongNoSwap;
|
|
LittleLong = LongSwap;
|
|
BigFloat = FloatNoSwap;
|
|
LittleFloat = FloatSwap;
|
|
}
|
|
|
|
#ifdef MULTITHREAD
|
|
Sys_ThreadsInit();
|
|
#endif
|
|
#ifdef LOADERTHREAD
|
|
COM_InitWorkerThread();
|
|
#endif
|
|
|
|
Cmd_AddCommand ("path", COM_Path_f); //prints a list of current search paths.
|
|
Cmd_AddCommand ("dir", COM_Dir_f); //q3 like
|
|
Cmd_AddCommand ("flocate", COM_Locate_f); //prints the pak or whatever where this file can be found.
|
|
Cmd_AddCommand ("version", COM_Version_f); //prints the pak or whatever where this file can be found.
|
|
|
|
Cmd_AddCommand ("crashme", COM_CrashMe_f);
|
|
Cmd_AddCommand ("errorme", COM_ErrorMe_f);
|
|
COM_InitFilesystem ();
|
|
|
|
Cvar_Register (&sys_platform, "Gamecode");
|
|
Cvar_Register (®istered, "Copy protection");
|
|
Cvar_Register (&gameversion, "Gamecode");
|
|
Cvar_Register (&gameversion_min, "Gamecode");
|
|
Cvar_Register (&gameversion_max, "Gamecode");
|
|
Cvar_Register (&com_nogamedirnativecode, "Gamecode");
|
|
Cvar_Register (&com_parseutf8, "Internationalisation");
|
|
Cvar_Register (&com_parseezquake, NULL);
|
|
Cvar_Register (&com_highlightcolor, "Internationalisation");
|
|
com_parseutf8.ival = 1;
|
|
|
|
TranslateInit();
|
|
|
|
COM_BiDi_Setup();
|
|
|
|
|
|
nullentitystate.hexen2flags = SCALE_ORIGIN_ORIGIN;
|
|
nullentitystate.colormod[0] = 32;
|
|
nullentitystate.colormod[1] = 32;
|
|
nullentitystate.colormod[2] = 32;
|
|
nullentitystate.glowmod[0] = 32;
|
|
nullentitystate.glowmod[1] = 32;
|
|
nullentitystate.glowmod[2] = 32;
|
|
nullentitystate.trans = 255;
|
|
nullentitystate.scale = 16;
|
|
nullentitystate.solid = 0;//ES_SOLID_BSP;
|
|
}
|
|
|
|
|
|
/*
|
|
============
|
|
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 *VARGS va(const char *format, ...)
|
|
{
|
|
#define VA_BUFFERS 2 //power of two
|
|
va_list argptr;
|
|
static char string[VA_BUFFERS][1024];
|
|
static int bufnum;
|
|
|
|
COM_AssertMainThread("va");
|
|
|
|
bufnum++;
|
|
bufnum &= (VA_BUFFERS-1);
|
|
|
|
va_start (argptr, format);
|
|
vsnprintf (string[bufnum],sizeof(string[bufnum])-1, format,argptr);
|
|
va_end (argptr);
|
|
|
|
return string[bufnum];
|
|
}
|
|
|
|
|
|
/// just for debugging
|
|
int memsearch (qbyte *start, int count, int search)
|
|
{
|
|
int i;
|
|
|
|
for (i=0 ; i<count ; i++)
|
|
if (start[i] == search)
|
|
return i;
|
|
return -1;
|
|
}
|
|
|
|
/*
|
|
struct effectinfo_s
|
|
{
|
|
struct effectinfo_s *next;
|
|
int index;
|
|
|
|
char name[1];
|
|
};
|
|
static struct effectinfo_s *effectinfo;
|
|
static unsigned int lasteffectinfoid;
|
|
|
|
void COM_Effectinfo_Clear(void)
|
|
{
|
|
struct effectinfo_s *n;
|
|
while(effectinfo)
|
|
{
|
|
n = effectinfo->next;
|
|
Z_Free(effectinfo);
|
|
effectinfo = n;
|
|
}
|
|
lasteffectinfoid = 0;
|
|
}
|
|
|
|
int COM_Effectinfo_Add(const char *effectname)
|
|
{
|
|
struct effectinfo_s *n;
|
|
for (n = effectinfo; n; n = n->next)
|
|
{
|
|
if (!strcmp(effectname, n->name))
|
|
return 0; //already known
|
|
}
|
|
|
|
|
|
n = Z_Malloc(sizeof(*n) + strlen(effectname));
|
|
n->next = effectinfo;
|
|
n->index = ++lasteffectinfoid;
|
|
effectinfo = n;
|
|
strcpy(n->name, effectname);
|
|
|
|
return n->index;
|
|
}
|
|
|
|
void COM_Effectinfo_Reload(void)
|
|
{
|
|
int i;
|
|
char *f, *buf;
|
|
static const char *dpnames[] =
|
|
{
|
|
"TE_GUNSHOT",
|
|
"TE_GUNSHOTQUAD",
|
|
"TE_SPIKE",
|
|
"TE_SPIKEQUAD",
|
|
"TE_SUPERSPIKE",
|
|
"TE_SUPERSPIKEQUAD",
|
|
"TE_WIZSPIKE",
|
|
"TE_KNIGHTSPIKE",
|
|
"TE_EXPLOSION",
|
|
"TE_EXPLOSIONQUAD",
|
|
"TE_TAREXPLOSION",
|
|
"TE_TELEPORT",
|
|
"TE_LAVASPLASH",
|
|
"TE_SMALLFLASH",
|
|
"TE_FLAMEJET",
|
|
"EF_FLAME",
|
|
"TE_BLOOD",
|
|
"TE_SPARK",
|
|
"TE_PLASMABURN",
|
|
"TE_TEI_G3",
|
|
"TE_TEI_SMOKE",
|
|
"TE_TEI_BIGEXPLOSION",
|
|
"TE_TEI_PLASMAHIT",
|
|
"EF_STARDUST",
|
|
"TR_ROCKET",
|
|
"TR_GRENADE",
|
|
"TR_BLOOD",
|
|
"TR_WIZSPIKE",
|
|
"TR_SLIGHTBLOOD",
|
|
"TR_KNIGHTSPIKE",
|
|
"TR_VORESPIKE",
|
|
"TR_NEHAHRASMOKE",
|
|
"TR_NEXUIZPLASMA",
|
|
"TR_GLOWTRAIL",
|
|
"SVC_PARTICLE",
|
|
NULL
|
|
};
|
|
|
|
COM_Effectinfo_Clear();
|
|
|
|
for (i = 0; dpnames[i]; i++)
|
|
COM_Effectinfo_Add(dpnames[i]);
|
|
|
|
|
|
FS_LoadFile("effectinfo.txt", (void **)&f);
|
|
if (!f)
|
|
return;
|
|
buf = f;
|
|
while (f && *f)
|
|
{
|
|
f = COM_ParseToken(f, NULL);
|
|
if (strcmp(com_token, "\n"))
|
|
{
|
|
if (!strcmp(com_token, "effect"))
|
|
{
|
|
f = COM_ParseToken(f, NULL);
|
|
|
|
COM_Effectinfo_Add(com_token);
|
|
}
|
|
|
|
do
|
|
{
|
|
f = COM_ParseToken(f, NULL);
|
|
} while(f && *f && strcmp(com_token, "\n"));
|
|
}
|
|
}
|
|
FS_FreeFile(buf);
|
|
}
|
|
|
|
unsigned int COM_Effectinfo_ForName(const char *efname)
|
|
{
|
|
struct effectinfo_s *e;
|
|
|
|
if (!effectinfo)
|
|
COM_Effectinfo_Reload();
|
|
|
|
for (e = effectinfo; e; e = e->next)
|
|
{
|
|
if (!strcmp(efname, e->name))
|
|
return e->index;
|
|
}
|
|
return COM_Effectinfo_Add(efname);
|
|
}
|
|
|
|
char *COM_Effectinfo_ForNumber(unsigned int efnum)
|
|
{
|
|
struct effectinfo_s *e;
|
|
|
|
if (!effectinfo)
|
|
COM_Effectinfo_Reload();
|
|
|
|
for (e = effectinfo; e; e = e->next)
|
|
{
|
|
if (e->index == efnum)
|
|
return e->name;
|
|
}
|
|
return "";
|
|
}
|
|
*/
|
|
/*************************************************************************/
|
|
|
|
/*remaps map checksums from known non-cheat GPL maps to authentic id1 maps*/
|
|
unsigned int COM_RemapMapChecksum(unsigned int checksum)
|
|
{
|
|
static const struct {
|
|
char *name;
|
|
unsigned int gpl2;
|
|
unsigned int id11;
|
|
unsigned int id12;
|
|
} sums[] =
|
|
{
|
|
{"maps/start.bsp", -603735309, 714749795, 493454459},
|
|
|
|
{"maps/e1m1.bsp", -1213097692, 523840258, -1391994750},
|
|
{"maps/e1m2.bsp", -2134038629, 1561595172, 1729102119},
|
|
{"maps/e1m3.bsp", 526593427, 1008794158, 893792842},
|
|
{"maps/e1m4.bsp", -1218723400, -442162482, -304478603},
|
|
{"maps/e1m5.bsp", 1709090059, 1856217547, -1473504118},
|
|
{"maps/e1m6.bsp", 1014375998, 1304756164, 738207971},
|
|
{"maps/e1m7.bsp", 1375393448, -1396746908, -1747518694},
|
|
{"maps/e1m8.bsp", 1470379688, -163803419, 79095617},
|
|
|
|
{"maps/e2m1.bsp", -1725230579, -797758554, -587894734},
|
|
{"maps/e2m2.bsp", -1573837115, -355822557, -1349116595},
|
|
{"maps/e2m3.bsp", 156655662, 1203005272, -57072303},
|
|
{"maps/e2m4.bsp", -1530012474, -1629664024, -1021928503},
|
|
{"maps/e3m5.bsp", -594001393, -1405673977, -1854273999},
|
|
{"maps/e2m6.bsp", 1041933133, 583875451, -1851573375},
|
|
{"maps/e2m7.bsp", -1583122652, 1814005234, 2051006488},
|
|
|
|
{"maps/e3m1.bsp", -1118143869, -457270773, -1867379423},
|
|
{"maps/e3m2.bsp", -469484146, 723435606, -1670613704},
|
|
{"maps/e3m3.bsp", -300762423, -540030088, -1009754856},
|
|
{"maps/e3m4.bsp", -214067894, 1107310161, -1317466952},
|
|
{"maps/e3m5.bsp", -594001393, -1405673977, -1854273999},
|
|
{"maps/e3m6.bsp", -1664550468, 1631142730, 767655416},
|
|
{"maps/e3m7.bsp", 781051658, -1513131760, 272220593},
|
|
|
|
{"maps/e4m1.bsp", 1548541253, 1254243660, -1141873840},
|
|
{"maps/e4m2.bsp", -1400585206, 92253388, -472296},
|
|
{"maps/e4m3.bsp", -1230693918, 1961442781, 1505685644},
|
|
{"maps/e4m4.bsp", 842253404, -374904516, 758847551},
|
|
{"maps/e4m5.bsp", -439098147, 389110272, 1771890676},
|
|
{"maps/e4m6.bsp", 1518024640, 1714857656, 102825880},
|
|
{"maps/e4m7.bsp", -381063035, -585362206, -1645477460},
|
|
{"maps/e4m8.bsp", 844770132, 1063417045, 1018457175},
|
|
|
|
{"maps/gpl_dm1.bsp", 2100781454, -1548219590, -976758093},
|
|
{"maps/gpl_dm2.bsp", 2066969664, 392410074, 1710634548},
|
|
{"maps/gpl_dm3.bsp", -1859681874, 2060033246, 367136248},
|
|
{"maps/gpl_dm4.bsp", -1015750775, 326737183, -1670388545},
|
|
{"maps/gpl_dm5.bsp", 2009758949, 766929852, -1339209475},
|
|
{"maps/gpl_dm6.bsp", 537693021, 247150701, 1376311851},
|
|
|
|
{"maps/end.bsp", -124054866, -1503553320, -1143688027}
|
|
};
|
|
unsigned int i;
|
|
for (i = 0; i < sizeof(sums)/sizeof(sums[0]); i++)
|
|
{
|
|
if (checksum == sums[i].gpl2)
|
|
return sums[i].id12;
|
|
}
|
|
return checksum;
|
|
}
|
|
|
|
/*
|
|
=====================================================================
|
|
|
|
INFO STRINGS
|
|
|
|
=====================================================================
|
|
*/
|
|
|
|
/*
|
|
===============
|
|
Info_ValueForKey
|
|
|
|
Searches the string for the given
|
|
key and returns the associated value, or an empty string.
|
|
===============
|
|
*/
|
|
char *Info_ValueForKey (const char *s, const char *key)
|
|
{
|
|
char pkey[1024];
|
|
static char value[4][1024]; // use two buffers so compares
|
|
// work without stomping on each other
|
|
static int valueindex;
|
|
char *o;
|
|
|
|
COM_AssertMainThread("Info_ValueForKey");
|
|
|
|
valueindex = (valueindex + 1) % 4;
|
|
if (*s == '\\')
|
|
s++;
|
|
while (1)
|
|
{
|
|
o = pkey;
|
|
while (*s != '\\')
|
|
{
|
|
if (!*s)
|
|
{
|
|
*value[valueindex]='\0';
|
|
return value[valueindex];
|
|
}
|
|
*o++ = *s++;
|
|
if (o+2 >= pkey+sizeof(pkey)) //hrm. hackers at work..
|
|
{
|
|
*value[valueindex]='\0';
|
|
return value[valueindex];
|
|
}
|
|
}
|
|
*o = 0;
|
|
s++;
|
|
|
|
o = value[valueindex];
|
|
|
|
while (*s != '\\' && *s)
|
|
{
|
|
if (!*s)
|
|
{
|
|
*value[valueindex]='\0';
|
|
return value[valueindex];
|
|
}
|
|
*o++ = *s++;
|
|
|
|
if (o+2 >= value[valueindex]+sizeof(value[valueindex])) //hrm. hackers at work..
|
|
{
|
|
*value[valueindex]='\0';
|
|
return value[valueindex];
|
|
}
|
|
}
|
|
*o = 0;
|
|
|
|
if (!strcmp (key, pkey) )
|
|
return value[valueindex];
|
|
|
|
if (!*s)
|
|
{
|
|
*value[valueindex]='\0';
|
|
return value[valueindex];
|
|
}
|
|
s++;
|
|
}
|
|
}
|
|
|
|
char *Info_KeyForNumber (char *s, int num)
|
|
{
|
|
static char pkey[1024];
|
|
char *o;
|
|
|
|
if (*s == '\\')
|
|
s++;
|
|
while (1)
|
|
{
|
|
o = pkey;
|
|
while (*s != '\\')
|
|
{
|
|
if (!*s)
|
|
{
|
|
*pkey='\0';
|
|
return pkey;
|
|
}
|
|
*o++ = *s++;
|
|
if (o+2 >= pkey+sizeof(pkey)) //hrm. hackers at work..
|
|
{
|
|
*pkey='\0';
|
|
return pkey;
|
|
}
|
|
}
|
|
*o = 0;
|
|
s++;
|
|
|
|
while (*s != '\\' && *s)
|
|
{
|
|
if (!*s)
|
|
{
|
|
*pkey='\0';
|
|
return pkey;
|
|
}
|
|
s++;
|
|
}
|
|
|
|
if (!num--)
|
|
return pkey; //found the right one
|
|
|
|
if (!*s)
|
|
{
|
|
*pkey='\0';
|
|
return pkey;
|
|
}
|
|
s++;
|
|
}
|
|
}
|
|
|
|
void Info_RemoveKey (char *s, const char *key)
|
|
{
|
|
char *start;
|
|
char pkey[1024];
|
|
char value[1024];
|
|
char *o;
|
|
|
|
if (strstr (key, "\\"))
|
|
{
|
|
Con_Printf ("Can't use a key with a \\\n");
|
|
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) )
|
|
{
|
|
//strip out the value by copying the next string over the top of this one
|
|
//(we were using strcpy, but valgrind moaned)
|
|
while(*s)
|
|
*start++ = *s++;
|
|
*start = 0;
|
|
return;
|
|
}
|
|
|
|
if (!*s)
|
|
return;
|
|
}
|
|
|
|
}
|
|
|
|
void Info_RemovePrefixedKeys (char *start, char prefix)
|
|
{
|
|
char *s;
|
|
char pkey[1024];
|
|
char value[1024];
|
|
char *o;
|
|
|
|
s = start;
|
|
|
|
while (1)
|
|
{
|
|
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 (pkey[0] == prefix)
|
|
{
|
|
Info_RemoveKey (start, pkey);
|
|
s = start;
|
|
}
|
|
|
|
if (!*s)
|
|
return;
|
|
}
|
|
|
|
}
|
|
|
|
void Info_RemoveNonStarKeys (char *start)
|
|
{
|
|
char *s;
|
|
char pkey[1024];
|
|
char value[1024];
|
|
char *o;
|
|
|
|
s = start;
|
|
|
|
while (1)
|
|
{
|
|
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 (pkey[0] != '*')
|
|
{
|
|
Info_RemoveKey (start, pkey);
|
|
s = start;
|
|
}
|
|
|
|
if (!*s)
|
|
return;
|
|
}
|
|
|
|
}
|
|
|
|
void Info_SetValueForStarKey (char *s, const char *key, const char *value, int maxsize)
|
|
{
|
|
char newv[1024], *v;
|
|
int c;
|
|
#ifdef SERVERONLY
|
|
extern cvar_t sv_highchars;
|
|
#endif
|
|
|
|
if (strstr (key, "\\") || strstr (value, "\\") )
|
|
{
|
|
Con_Printf ("Can't use a key with a \\\n");
|
|
return;
|
|
}
|
|
|
|
if (strstr (key, "\"") || strstr (value, "\"") )
|
|
{
|
|
Con_Printf ("Can't use a key with a \"\n");
|
|
return;
|
|
}
|
|
|
|
if (strlen(key) >= MAX_INFO_KEY)// || strlen(value) >= MAX_INFO_KEY)
|
|
{
|
|
Con_Printf ("Keys and values must be < %i characters.\n", MAX_INFO_KEY);
|
|
return;
|
|
}
|
|
|
|
// this next line is kinda trippy
|
|
if (*(v = Info_ValueForKey(s, key)))
|
|
{
|
|
// key exists, make sure we have enough room for new value, if we don't,
|
|
// don't change it!
|
|
if (strlen(value) - strlen(v) + strlen(s) + 1 > maxsize)
|
|
{
|
|
if (*Info_ValueForKey(s, "*ver")) //quick hack to kill off unneeded info on overflow. We can't simply increase the quantity of this stuff.
|
|
{
|
|
Info_RemoveKey(s, "*ver");
|
|
Info_SetValueForStarKey (s, key, value, maxsize);
|
|
return;
|
|
}
|
|
Con_Printf ("Info string length exceeded on addition of %s\n", key);
|
|
return;
|
|
}
|
|
}
|
|
Info_RemoveKey (s, key);
|
|
if (!value || !strlen(value))
|
|
return;
|
|
|
|
snprintf (newv, sizeof(newv), "\\%s\\%s", key, value);
|
|
|
|
if ((int)(strlen(newv) + strlen(s) + 1) > maxsize)
|
|
{
|
|
Con_Printf ("Info string length exceeded on addition of %s\n", key);
|
|
return;
|
|
}
|
|
|
|
// only copy ascii values
|
|
s += strlen(s);
|
|
v = newv;
|
|
while (*v)
|
|
{
|
|
c = (unsigned char)*v++;
|
|
#ifndef SERVERONLY
|
|
// client only allows highbits on name
|
|
// if (stricmp(key, "name") != 0) {
|
|
// c &= 127;
|
|
// if (c < 32 || c > 127)
|
|
// continue;
|
|
// // auto lowercase team
|
|
// if (stricmp(key, "team") == 0)
|
|
// c = tolower(c);
|
|
// }
|
|
#else
|
|
if (!sv_highchars.value) {
|
|
c &= 127;
|
|
if (c < 32 || c > 127)
|
|
continue;
|
|
}
|
|
#endif
|
|
// c &= 127; // strip high bits
|
|
if (c > 13) // && c < 127)
|
|
*s++ = c;
|
|
}
|
|
*s = 0;
|
|
}
|
|
|
|
void Info_SetValueForKey (char *s, const char *key, const char *value, int maxsize)
|
|
{
|
|
if (key[0] == '*')
|
|
{
|
|
Con_Printf ("Can't set * keys\n");
|
|
return;
|
|
}
|
|
|
|
Info_SetValueForStarKey (s, key, value, maxsize);
|
|
}
|
|
|
|
void Info_Print (char *s, char *lineprefix)
|
|
{
|
|
char key[1024];
|
|
char value[1024];
|
|
char *o;
|
|
int l;
|
|
|
|
if (*s == '\\')
|
|
s++;
|
|
while (*s)
|
|
{
|
|
o = key;
|
|
while (*s && *s != '\\')
|
|
*o++ = *s++;
|
|
|
|
l = o - key;
|
|
if (l < 20)
|
|
{
|
|
memset (o, ' ', 20-l);
|
|
key[20] = 0;
|
|
}
|
|
else
|
|
*o = 0;
|
|
Con_Printf ("%s%s", lineprefix, key);
|
|
|
|
if (!*s)
|
|
{
|
|
//should never happen.
|
|
Con_Printf ("<no value>\n");
|
|
return;
|
|
}
|
|
|
|
o = value;
|
|
s++;
|
|
while (*s && *s != '\\')
|
|
*o++ = *s++;
|
|
*o = 0;
|
|
|
|
if (*s)
|
|
s++;
|
|
Con_Printf ("%s\n", value);
|
|
}
|
|
}
|
|
|
|
void Info_WriteToFile(vfsfile_t *f, char *info, char *commandname, int cvarflags)
|
|
{
|
|
const char *quotedvalue;
|
|
char buffer[1024];
|
|
char *command;
|
|
char *value, t;
|
|
cvar_t *var;
|
|
|
|
while(*info == '\\')
|
|
{
|
|
command = info+1;
|
|
value = strchr(command, '\\');
|
|
info = strchr(value+1, '\\');
|
|
if (!info) //eot..
|
|
info = value+strlen(value);
|
|
|
|
if (*command == '*') //unsettable, so don't write it for later setting.
|
|
continue;
|
|
|
|
if (cvarflags)
|
|
{
|
|
var = Cvar_FindVar(command);
|
|
if (var && var->flags & cvarflags)
|
|
continue; //this is saved via a cvar.
|
|
}
|
|
|
|
VFS_WRITE(f, commandname, strlen(commandname));
|
|
VFS_WRITE(f, " ", 1);
|
|
VFS_WRITE(f, command, value-command);
|
|
VFS_WRITE(f, " ", 1);
|
|
t = *info;
|
|
*info = 0;
|
|
quotedvalue = COM_QuotedString(value+1, buffer, sizeof(buffer), false);
|
|
VFS_WRITE(f, quotedvalue, strlen(quotedvalue));
|
|
*info = t;
|
|
VFS_WRITE(f, "\n", 1);
|
|
}
|
|
}
|
|
|
|
|
|
static qbyte chktbl[1024 + 4] = {
|
|
0x78,0xd2,0x94,0xe3,0x41,0xec,0xd6,0xd5,0xcb,0xfc,0xdb,0x8a,0x4b,0xcc,0x85,0x01,
|
|
0x23,0xd2,0xe5,0xf2,0x29,0xa7,0x45,0x94,0x4a,0x62,0xe3,0xa5,0x6f,0x3f,0xe1,0x7a,
|
|
0x64,0xed,0x5c,0x99,0x29,0x87,0xa8,0x78,0x59,0x0d,0xaa,0x0f,0x25,0x0a,0x5c,0x58,
|
|
0xfb,0x00,0xa7,0xa8,0x8a,0x1d,0x86,0x80,0xc5,0x1f,0xd2,0x28,0x69,0x71,0x58,0xc3,
|
|
0x51,0x90,0xe1,0xf8,0x6a,0xf3,0x8f,0xb0,0x68,0xdf,0x95,0x40,0x5c,0xe4,0x24,0x6b,
|
|
0x29,0x19,0x71,0x3f,0x42,0x63,0x6c,0x48,0xe7,0xad,0xa8,0x4b,0x91,0x8f,0x42,0x36,
|
|
0x34,0xe7,0x32,0x55,0x59,0x2d,0x36,0x38,0x38,0x59,0x9b,0x08,0x16,0x4d,0x8d,0xf8,
|
|
0x0a,0xa4,0x52,0x01,0xbb,0x52,0xa9,0xfd,0x40,0x18,0x97,0x37,0xff,0xc9,0x82,0x27,
|
|
0xb2,0x64,0x60,0xce,0x00,0xd9,0x04,0xf0,0x9e,0x99,0xbd,0xce,0x8f,0x90,0x4a,0xdd,
|
|
0xe1,0xec,0x19,0x14,0xb1,0xfb,0xca,0x1e,0x98,0x0f,0xd4,0xcb,0x80,0xd6,0x05,0x63,
|
|
0xfd,0xa0,0x74,0xa6,0x86,0xf6,0x19,0x98,0x76,0x27,0x68,0xf7,0xe9,0x09,0x9a,0xf2,
|
|
0x2e,0x42,0xe1,0xbe,0x64,0x48,0x2a,0x74,0x30,0xbb,0x07,0xcc,0x1f,0xd4,0x91,0x9d,
|
|
0xac,0x55,0x53,0x25,0xb9,0x64,0xf7,0x58,0x4c,0x34,0x16,0xbc,0xf6,0x12,0x2b,0x65,
|
|
0x68,0x25,0x2e,0x29,0x1f,0xbb,0xb9,0xee,0x6d,0x0c,0x8e,0xbb,0xd2,0x5f,0x1d,0x8f,
|
|
0xc1,0x39,0xf9,0x8d,0xc0,0x39,0x75,0xcf,0x25,0x17,0xbe,0x96,0xaf,0x98,0x9f,0x5f,
|
|
0x65,0x15,0xc4,0x62,0xf8,0x55,0xfc,0xab,0x54,0xcf,0xdc,0x14,0x06,0xc8,0xfc,0x42,
|
|
0xd3,0xf0,0xad,0x10,0x08,0xcd,0xd4,0x11,0xbb,0xca,0x67,0xc6,0x48,0x5f,0x9d,0x59,
|
|
0xe3,0xe8,0x53,0x67,0x27,0x2d,0x34,0x9e,0x9e,0x24,0x29,0xdb,0x69,0x99,0x86,0xf9,
|
|
0x20,0xb5,0xbb,0x5b,0xb0,0xf9,0xc3,0x67,0xad,0x1c,0x9c,0xf7,0xcc,0xef,0xce,0x69,
|
|
0xe0,0x26,0x8f,0x79,0xbd,0xca,0x10,0x17,0xda,0xa9,0x88,0x57,0x9b,0x15,0x24,0xba,
|
|
0x84,0xd0,0xeb,0x4d,0x14,0xf5,0xfc,0xe6,0x51,0x6c,0x6f,0x64,0x6b,0x73,0xec,0x85,
|
|
0xf1,0x6f,0xe1,0x67,0x25,0x10,0x77,0x32,0x9e,0x85,0x6e,0x69,0xb1,0x83,0x00,0xe4,
|
|
0x13,0xa4,0x45,0x34,0x3b,0x40,0xff,0x41,0x82,0x89,0x79,0x57,0xfd,0xd2,0x8e,0xe8,
|
|
0xfc,0x1d,0x19,0x21,0x12,0x00,0xd7,0x66,0xe5,0xc7,0x10,0x1d,0xcb,0x75,0xe8,0xfa,
|
|
0xb6,0xee,0x7b,0x2f,0x1a,0x25,0x24,0xb9,0x9f,0x1d,0x78,0xfb,0x84,0xd0,0x17,0x05,
|
|
0x71,0xb3,0xc8,0x18,0xff,0x62,0xee,0xed,0x53,0xab,0x78,0xd3,0x65,0x2d,0xbb,0xc7,
|
|
0xc1,0xe7,0x70,0xa2,0x43,0x2c,0x7c,0xc7,0x16,0x04,0xd2,0x45,0xd5,0x6b,0x6c,0x7a,
|
|
0x5e,0xa1,0x50,0x2e,0x31,0x5b,0xcc,0xe8,0x65,0x8b,0x16,0x85,0xbf,0x82,0x83,0xfb,
|
|
0xde,0x9f,0x36,0x48,0x32,0x79,0xd6,0x9b,0xfb,0x52,0x45,0xbf,0x43,0xf7,0x0b,0x0b,
|
|
0x19,0x19,0x31,0xc3,0x85,0xec,0x1d,0x8c,0x20,0xf0,0x3a,0xfa,0x80,0x4d,0x2c,0x7d,
|
|
0xac,0x60,0x09,0xc0,0x40,0xee,0xb9,0xeb,0x13,0x5b,0xe8,0x2b,0xb1,0x20,0xf0,0xce,
|
|
0x4c,0xbd,0xc6,0x04,0x86,0x70,0xc6,0x33,0xc3,0x15,0x0f,0x65,0x19,0xfd,0xc2,0xd3,
|
|
|
|
// map checksum goes here
|
|
0x00,0x00,0x00,0x00
|
|
};
|
|
|
|
#if 0
|
|
|
|
static qbyte chkbuf[16 + 60 + 4];
|
|
|
|
static unsigned last_mapchecksum = 0;
|
|
|
|
|
|
/*
|
|
====================
|
|
COM_BlockSequenceCheckByte
|
|
|
|
For proxy protecting
|
|
====================
|
|
*/
|
|
qbyte COM_BlockSequenceCheckByte (qbyte *base, int length, int sequence, unsigned mapchecksum)
|
|
{
|
|
int checksum;
|
|
qbyte *p;
|
|
|
|
if (last_mapchecksum != mapchecksum) {
|
|
last_mapchecksum = mapchecksum;
|
|
chktbl[1024] = (mapchecksum & 0xff000000) >> 24;
|
|
chktbl[1025] = (mapchecksum & 0x00ff0000) >> 16;
|
|
chktbl[1026] = (mapchecksum & 0x0000ff00) >> 8;
|
|
chktbl[1027] = (mapchecksum & 0x000000ff);
|
|
|
|
Com_BlockFullChecksum (chktbl, sizeof(chktbl), chkbuf);
|
|
}
|
|
|
|
p = chktbl + (sequence % (sizeof(chktbl) - 8));
|
|
|
|
if (length > 60)
|
|
length = 60;
|
|
memcpy (chkbuf + 16, base, length);
|
|
|
|
length += 16;
|
|
|
|
chkbuf[length] = (sequence & 0xff) ^ p[0];
|
|
chkbuf[length+1] = p[1];
|
|
chkbuf[length+2] = ((sequence>>8) & 0xff) ^ p[2];
|
|
chkbuf[length+3] = p[3];
|
|
|
|
length += 4;
|
|
|
|
checksum = LittleLong(Com_BlockChecksum (chkbuf, length));
|
|
|
|
checksum &= 0xff;
|
|
|
|
return checksum;
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
====================
|
|
COM_BlockSequenceCRCByte
|
|
|
|
For proxy protecting
|
|
====================
|
|
*/
|
|
qbyte COM_BlockSequenceCRCByte (qbyte *base, int length, int sequence)
|
|
{
|
|
unsigned short crc;
|
|
qbyte *p;
|
|
qbyte chkb[60 + 4];
|
|
|
|
p = chktbl + (sequence % (sizeof(chktbl) - 8));
|
|
|
|
if (length > 60)
|
|
length = 60;
|
|
memcpy (chkb, base, length);
|
|
|
|
chkb[length] = (sequence & 0xff) ^ p[0];
|
|
chkb[length+1] = p[1];
|
|
chkb[length+2] = ((sequence>>8) & 0xff) ^ p[2];
|
|
chkb[length+3] = p[3];
|
|
|
|
length += 4;
|
|
|
|
crc = QCRC_Block(chkb, length);
|
|
|
|
crc &= 0xff;
|
|
|
|
return crc;
|
|
}
|
|
|
|
|
|
#if defined(Q2CLIENT) || defined(Q2SERVER)
|
|
static qbyte q2chktbl[1024] = {
|
|
0x84, 0x47, 0x51, 0xc1, 0x93, 0x22, 0x21, 0x24, 0x2f, 0x66, 0x60, 0x4d, 0xb0, 0x7c, 0xda,
|
|
0x88, 0x54, 0x15, 0x2b, 0xc6, 0x6c, 0x89, 0xc5, 0x9d, 0x48, 0xee, 0xe6, 0x8a, 0xb5, 0xf4,
|
|
0xcb, 0xfb, 0xf1, 0x0c, 0x2e, 0xa0, 0xd7, 0xc9, 0x1f, 0xd6, 0x06, 0x9a, 0x09, 0x41, 0x54,
|
|
0x67, 0x46, 0xc7, 0x74, 0xe3, 0xc8, 0xb6, 0x5d, 0xa6, 0x36, 0xc4, 0xab, 0x2c, 0x7e, 0x85,
|
|
0xa8, 0xa4, 0xa6, 0x4d, 0x96, 0x19, 0x19, 0x9a, 0xcc, 0xd8, 0xac, 0x39, 0x5e, 0x3c, 0xf2,
|
|
0xf5, 0x5a, 0x72, 0xe5, 0xa9, 0xd1, 0xb3, 0x23, 0x82, 0x6f, 0x29, 0xcb, 0xd1, 0xcc, 0x71,
|
|
0xfb, 0xea, 0x92, 0xeb, 0x1c, 0xca, 0x4c, 0x70, 0xfe, 0x4d, 0xc9, 0x67, 0x43, 0x47, 0x94,
|
|
0xb9, 0x47, 0xbc, 0x3f, 0x01, 0xab, 0x7b, 0xa6, 0xe2, 0x76, 0xef, 0x5a, 0x7a, 0x29, 0x0b,
|
|
0x51, 0x54, 0x67, 0xd8, 0x1c, 0x14, 0x3e, 0x29, 0xec, 0xe9, 0x2d, 0x48, 0x67, 0xff, 0xed,
|
|
0x54, 0x4f, 0x48, 0xc0, 0xaa, 0x61, 0xf7, 0x78, 0x12, 0x03, 0x7a, 0x9e, 0x8b, 0xcf, 0x83,
|
|
0x7b, 0xae, 0xca, 0x7b, 0xd9, 0xe9, 0x53, 0x2a, 0xeb, 0xd2, 0xd8, 0xcd, 0xa3, 0x10, 0x25,
|
|
0x78, 0x5a, 0xb5, 0x23, 0x06, 0x93, 0xb7, 0x84, 0xd2, 0xbd, 0x96, 0x75, 0xa5, 0x5e, 0xcf,
|
|
0x4e, 0xe9, 0x50, 0xa1, 0xe6, 0x9d, 0xb1, 0xe3, 0x85, 0x66, 0x28, 0x4e, 0x43, 0xdc, 0x6e,
|
|
0xbb, 0x33, 0x9e, 0xf3, 0x0d, 0x00, 0xc1, 0xcf, 0x67, 0x34, 0x06, 0x7c, 0x71, 0xe3, 0x63,
|
|
0xb7, 0xb7, 0xdf, 0x92, 0xc4, 0xc2, 0x25, 0x5c, 0xff, 0xc3, 0x6e, 0xfc, 0xaa, 0x1e, 0x2a,
|
|
0x48, 0x11, 0x1c, 0x36, 0x68, 0x78, 0x86, 0x79, 0x30, 0xc3, 0xd6, 0xde, 0xbc, 0x3a, 0x2a,
|
|
0x6d, 0x1e, 0x46, 0xdd, 0xe0, 0x80, 0x1e, 0x44, 0x3b, 0x6f, 0xaf, 0x31, 0xda, 0xa2, 0xbd,
|
|
0x77, 0x06, 0x56, 0xc0, 0xb7, 0x92, 0x4b, 0x37, 0xc0, 0xfc, 0xc2, 0xd5, 0xfb, 0xa8, 0xda,
|
|
0xf5, 0x57, 0xa8, 0x18, 0xc0, 0xdf, 0xe7, 0xaa, 0x2a, 0xe0, 0x7c, 0x6f, 0x77, 0xb1, 0x26,
|
|
0xba, 0xf9, 0x2e, 0x1d, 0x16, 0xcb, 0xb8, 0xa2, 0x44, 0xd5, 0x2f, 0x1a, 0x79, 0x74, 0x87,
|
|
0x4b, 0x00, 0xc9, 0x4a, 0x3a, 0x65, 0x8f, 0xe6, 0x5d, 0xe5, 0x0a, 0x77, 0xd8, 0x1a, 0x14,
|
|
0x41, 0x75, 0xb1, 0xe2, 0x50, 0x2c, 0x93, 0x38, 0x2b, 0x6d, 0xf3, 0xf6, 0xdb, 0x1f, 0xcd,
|
|
0xff, 0x14, 0x70, 0xe7, 0x16, 0xe8, 0x3d, 0xf0, 0xe3, 0xbc, 0x5e, 0xb6, 0x3f, 0xcc, 0x81,
|
|
0x24, 0x67, 0xf3, 0x97, 0x3b, 0xfe, 0x3a, 0x96, 0x85, 0xdf, 0xe4, 0x6e, 0x3c, 0x85, 0x05,
|
|
0x0e, 0xa3, 0x2b, 0x07, 0xc8, 0xbf, 0xe5, 0x13, 0x82, 0x62, 0x08, 0x61, 0x69, 0x4b, 0x47,
|
|
0x62, 0x73, 0x44, 0x64, 0x8e, 0xe2, 0x91, 0xa6, 0x9a, 0xb7, 0xe9, 0x04, 0xb6, 0x54, 0x0c,
|
|
0xc5, 0xa9, 0x47, 0xa6, 0xc9, 0x08, 0xfe, 0x4e, 0xa6, 0xcc, 0x8a, 0x5b, 0x90, 0x6f, 0x2b,
|
|
0x3f, 0xb6, 0x0a, 0x96, 0xc0, 0x78, 0x58, 0x3c, 0x76, 0x6d, 0x94, 0x1a, 0xe4, 0x4e, 0xb8,
|
|
0x38, 0xbb, 0xf5, 0xeb, 0x29, 0xd8, 0xb0, 0xf3, 0x15, 0x1e, 0x99, 0x96, 0x3c, 0x5d, 0x63,
|
|
0xd5, 0xb1, 0xad, 0x52, 0xb8, 0x55, 0x70, 0x75, 0x3e, 0x1a, 0xd5, 0xda, 0xf6, 0x7a, 0x48,
|
|
0x7d, 0x44, 0x41, 0xf9, 0x11, 0xce, 0xd7, 0xca, 0xa5, 0x3d, 0x7a, 0x79, 0x7e, 0x7d, 0x25,
|
|
0x1b, 0x77, 0xbc, 0xf7, 0xc7, 0x0f, 0x84, 0x95, 0x10, 0x92, 0x67, 0x15, 0x11, 0x5a, 0x5e,
|
|
0x41, 0x66, 0x0f, 0x38, 0x03, 0xb2, 0xf1, 0x5d, 0xf8, 0xab, 0xc0, 0x02, 0x76, 0x84, 0x28,
|
|
0xf4, 0x9d, 0x56, 0x46, 0x60, 0x20, 0xdb, 0x68, 0xa7, 0xbb, 0xee, 0xac, 0x15, 0x01, 0x2f,
|
|
0x20, 0x09, 0xdb, 0xc0, 0x16, 0xa1, 0x89, 0xf9, 0x94, 0x59, 0x00, 0xc1, 0x76, 0xbf, 0xc1,
|
|
0x4d, 0x5d, 0x2d, 0xa9, 0x85, 0x2c, 0xd6, 0xd3, 0x14, 0xcc, 0x02, 0xc3, 0xc2, 0xfa, 0x6b,
|
|
0xb7, 0xa6, 0xef, 0xdd, 0x12, 0x26, 0xa4, 0x63, 0xe3, 0x62, 0xbd, 0x56, 0x8a, 0x52, 0x2b,
|
|
0xb9, 0xdf, 0x09, 0xbc, 0x0e, 0x97, 0xa9, 0xb0, 0x82, 0x46, 0x08, 0xd5, 0x1a, 0x8e, 0x1b,
|
|
0xa7, 0x90, 0x98, 0xb9, 0xbb, 0x3c, 0x17, 0x9a, 0xf2, 0x82, 0xba, 0x64, 0x0a, 0x7f, 0xca,
|
|
0x5a, 0x8c, 0x7c, 0xd3, 0x79, 0x09, 0x5b, 0x26, 0xbb, 0xbd, 0x25, 0xdf, 0x3d, 0x6f, 0x9a,
|
|
0x8f, 0xee, 0x21, 0x66, 0xb0, 0x8d, 0x84, 0x4c, 0x91, 0x45, 0xd4, 0x77, 0x4f, 0xb3, 0x8c,
|
|
0xbc, 0xa8, 0x99, 0xaa, 0x19, 0x53, 0x7c, 0x02, 0x87, 0xbb, 0x0b, 0x7c, 0x1a, 0x2d, 0xdf,
|
|
0x48, 0x44, 0x06, 0xd6, 0x7d, 0x0c, 0x2d, 0x35, 0x76, 0xae, 0xc4, 0x5f, 0x71, 0x85, 0x97,
|
|
0xc4, 0x3d, 0xef, 0x52, 0xbe, 0x00, 0xe4, 0xcd, 0x49, 0xd1, 0xd1, 0x1c, 0x3c, 0xd0, 0x1c,
|
|
0x42, 0xaf, 0xd4, 0xbd, 0x58, 0x34, 0x07, 0x32, 0xee, 0xb9, 0xb5, 0xea, 0xff, 0xd7, 0x8c,
|
|
0x0d, 0x2e, 0x2f, 0xaf, 0x87, 0xbb, 0xe6, 0x52, 0x71, 0x22, 0xf5, 0x25, 0x17, 0xa1, 0x82,
|
|
0x04, 0xc2, 0x4a, 0xbd, 0x57, 0xc6, 0xab, 0xc8, 0x35, 0x0c, 0x3c, 0xd9, 0xc2, 0x43, 0xdb,
|
|
0x27, 0x92, 0xcf, 0xb8, 0x25, 0x60, 0xfa, 0x21, 0x3b, 0x04, 0x52, 0xc8, 0x96, 0xba, 0x74,
|
|
0xe3, 0x67, 0x3e, 0x8e, 0x8d, 0x61, 0x90, 0x92, 0x59, 0xb6, 0x1a, 0x1c, 0x5e, 0x21, 0xc1,
|
|
0x65, 0xe5, 0xa6, 0x34, 0x05, 0x6f, 0xc5, 0x60, 0xb1, 0x83, 0xc1, 0xd5, 0xd5, 0xed, 0xd9,
|
|
0xc7, 0x11, 0x7b, 0x49, 0x7a, 0xf9, 0xf9, 0x84, 0x47, 0x9b, 0xe2, 0xa5, 0x82, 0xe0, 0xc2,
|
|
0x88, 0xd0, 0xb2, 0x58, 0x88, 0x7f, 0x45, 0x09, 0x67, 0x74, 0x61, 0xbf, 0xe6, 0x40, 0xe2,
|
|
0x9d, 0xc2, 0x47, 0x05, 0x89, 0xed, 0xcb, 0xbb, 0xb7, 0x27, 0xe7, 0xdc, 0x7a, 0xfd, 0xbf,
|
|
0xa8, 0xd0, 0xaa, 0x10, 0x39, 0x3c, 0x20, 0xf0, 0xd3, 0x6e, 0xb1, 0x72, 0xf8, 0xe6, 0x0f,
|
|
0xef, 0x37, 0xe5, 0x09, 0x33, 0x5a, 0x83, 0x43, 0x80, 0x4f, 0x65, 0x2f, 0x7c, 0x8c, 0x6a,
|
|
0xa0, 0x82, 0x0c, 0xd4, 0xd4, 0xfa, 0x81, 0x60, 0x3d, 0xdf, 0x06, 0xf1, 0x5f, 0x08, 0x0d,
|
|
0x6d, 0x43, 0xf2, 0xe3, 0x11, 0x7d, 0x80, 0x32, 0xc5, 0xfb, 0xc5, 0xd9, 0x27, 0xec, 0xc6,
|
|
0x4e, 0x65, 0x27, 0x76, 0x87, 0xa6, 0xee, 0xee, 0xd7, 0x8b, 0xd1, 0xa0, 0x5c, 0xb0, 0x42,
|
|
0x13, 0x0e, 0x95, 0x4a, 0xf2, 0x06, 0xc6, 0x43, 0x33, 0xf4, 0xc7, 0xf8, 0xe7, 0x1f, 0xdd,
|
|
0xe4, 0x46, 0x4a, 0x70, 0x39, 0x6c, 0xd0, 0xed, 0xca, 0xbe, 0x60, 0x3b, 0xd1, 0x7b, 0x57,
|
|
0x48, 0xe5, 0x3a, 0x79, 0xc1, 0x69, 0x33, 0x53, 0x1b, 0x80, 0xb8, 0x91, 0x7d, 0xb4, 0xf6,
|
|
0x17, 0x1a, 0x1d, 0x5a, 0x32, 0xd6, 0xcc, 0x71, 0x29, 0x3f, 0x28, 0xbb, 0xf3, 0x5e, 0x71,
|
|
0xb8, 0x43, 0xaf, 0xf8, 0xb9, 0x64, 0xef, 0xc4, 0xa5, 0x6c, 0x08, 0x53, 0xc7, 0x00, 0x10,
|
|
0x39, 0x4f, 0xdd, 0xe4, 0xb6, 0x19, 0x27, 0xfb, 0xb8, 0xf5, 0x32, 0x73, 0xe5, 0xcb, 0x32
|
|
};
|
|
|
|
/*
|
|
====================
|
|
COM_BlockSequenceCRCByte
|
|
|
|
For proxy protecting
|
|
====================
|
|
*/
|
|
qbyte Q2COM_BlockSequenceCRCByte (qbyte *base, int length, int sequence)
|
|
{
|
|
int n;
|
|
qbyte *p;
|
|
int x;
|
|
qbyte chkb[60 + 4];
|
|
unsigned short crc;
|
|
|
|
|
|
if (sequence < 0)
|
|
Sys_Error("sequence < 0, this shouldn't happen\n");
|
|
|
|
p = q2chktbl + (sequence % (sizeof(q2chktbl) - 4));
|
|
|
|
if (length > 60)
|
|
length = 60;
|
|
memcpy (chkb, base, length);
|
|
|
|
chkb[length] = p[0];
|
|
chkb[length+1] = p[1];
|
|
chkb[length+2] = p[2];
|
|
chkb[length+3] = p[3];
|
|
|
|
length += 4;
|
|
|
|
crc = QCRC_Block(chkb, length);
|
|
|
|
for (x=0, n=0; n<length; n++)
|
|
x += chkb[n];
|
|
|
|
crc = (crc ^ x) & 0xff;
|
|
|
|
return crc;
|
|
}
|
|
|
|
#endif
|
|
|
|
#ifdef _WIN32
|
|
// don't use these functions in MSVC8
|
|
#if (_MSC_VER < 1400)
|
|
int VARGS linuxlike_snprintf(char *buffer, int size, const char *format, ...)
|
|
{
|
|
#undef _vsnprintf
|
|
int ret;
|
|
va_list argptr;
|
|
|
|
if (size <= 0)
|
|
return 0;
|
|
size--;
|
|
|
|
va_start (argptr, format);
|
|
ret = _vsnprintf (buffer,size, format,argptr);
|
|
va_end (argptr);
|
|
|
|
buffer[size] = '\0';
|
|
|
|
return ret;
|
|
}
|
|
|
|
int VARGS linuxlike_vsnprintf(char *buffer, int size, const char *format, va_list argptr)
|
|
{
|
|
#undef _vsnprintf
|
|
int ret;
|
|
|
|
if (size <= 0)
|
|
return 0;
|
|
size--;
|
|
|
|
ret = _vsnprintf (buffer,size, format,argptr);
|
|
|
|
buffer[size] = '\0';
|
|
|
|
return ret;
|
|
}
|
|
#else
|
|
int VARGS linuxlike_snprintf_vc8(char *buffer, int size, const char *format, ...)
|
|
{
|
|
int ret;
|
|
va_list argptr;
|
|
|
|
va_start (argptr, format);
|
|
ret = vsnprintf_s (buffer,size, _TRUNCATE, format,argptr);
|
|
va_end (argptr);
|
|
|
|
return ret;
|
|
}
|
|
#endif
|
|
|
|
#endif
|
|
|
|
// libSDL.a and libSDLmain.a mingw32 libs use this function for some reason, just here to shut gcc up
|
|
/*#ifdef _MINGW_VFPRINTF
|
|
int __mingw_vfprintf (FILE *__stream, const char *__format, __VALIST __local_argv)
|
|
{
|
|
return vfprintf( __stream, __format, __local_argv );
|
|
}
|
|
#endif*/
|
|
|
|
int version_number(void)
|
|
{
|
|
int base = FTE_VER_MAJOR * 10000 + FTE_VER_MINOR * 100;
|
|
|
|
#ifdef OFFICIAL_RELEASE
|
|
base -= 1;
|
|
#endif
|
|
|
|
return base;
|
|
}
|
|
|
|
char *version_string(void)
|
|
{
|
|
static char s[128];
|
|
static qboolean done;
|
|
|
|
if (!done)
|
|
{
|
|
#ifdef OFFICIAL_RELEASE
|
|
Q_snprintfz(s, sizeof(s), "%s v%i.%02i", DISTRIBUTION, FTE_VER_MAJOR, FTE_VER_MINOR);
|
|
#else
|
|
#if defined(SVNREVISION)
|
|
if (strcmp(STRINGIFY(SVNREVISION), "-"))
|
|
Q_snprintfz(s, sizeof(s), "%s SVN %s", DISTRIBUTION, STRINGIFY(SVNREVISION));
|
|
else
|
|
#endif
|
|
Q_snprintfz(s, sizeof(s), "%s build %s", DISTRIBUTION, __DATE__);
|
|
#endif
|
|
done = true;
|
|
}
|
|
|
|
return s;
|
|
}
|
|
|
|
//C90
|
|
void COM_TimeOfDay(date_t *date)
|
|
{
|
|
struct tm *newtime;
|
|
time_t long_time;
|
|
|
|
time(&long_time);
|
|
newtime = localtime(&long_time);
|
|
|
|
date->day = newtime->tm_mday;
|
|
date->mon = newtime->tm_mon;
|
|
date->year = newtime->tm_year + 1900;
|
|
date->hour = newtime->tm_hour;
|
|
date->min = newtime->tm_min;
|
|
date->sec = newtime->tm_sec;
|
|
strftime( date->str, 128,
|
|
"%a %b %d, %H:%M:%S %Y", newtime);
|
|
}
|