#include "quakedef.h"
-cvar_t registered = {0, "registered","0"};
-cvar_t cmdline = {0, "cmdline","0"};
+cvar_t registered = {0, "registered","0", "indicates if this is running registered quake (whether gfx/qpop.lmp was found)"};
+cvar_t cmdline = {0, "cmdline","0", "contains commandline the engine was launched with"};
extern qboolean fs_modified; // set true if using non-id files
-char com_token[1024];
+char com_token[MAX_INPUTLINE];
int com_argc;
const char **com_argv;
-// LordHavoc: made commandline 1024 characters instead of 256
-#define CMDLINE_LENGTH 1024
-char com_cmdline[CMDLINE_LENGTH];
+char com_cmdline[MAX_INPUTLINE];
gamemode_t gamemode;
const char *gamename;
short ShortSwap (short l)
{
- qbyte b1,b2;
+ unsigned char b1,b2;
b1 = l&255;
b2 = (l>>8)&255;
int LongSwap (int l)
{
- qbyte b1,b2,b3,b4;
+ unsigned char b1,b2,b3,b4;
b1 = l&255;
b2 = (l>>8)&255;
union
{
float f;
- qbyte b[4];
+ unsigned char b[4];
} dat1, dat2;
// Extract integers from buffers
-unsigned int BuffBigLong (const qbyte *buffer)
+unsigned int BuffBigLong (const unsigned char *buffer)
{
return (buffer[0] << 24) | (buffer[1] << 16) | (buffer[2] << 8) | buffer[3];
}
-unsigned short BuffBigShort (const qbyte *buffer)
+unsigned short BuffBigShort (const unsigned char *buffer)
{
return (buffer[0] << 8) | buffer[1];
}
-unsigned int BuffLittleLong (const qbyte *buffer)
+unsigned int BuffLittleLong (const unsigned char *buffer)
{
return (buffer[3] << 24) | (buffer[2] << 16) | (buffer[1] << 8) | buffer[0];
}
-unsigned short BuffLittleShort (const qbyte *buffer)
+unsigned short BuffLittleShort (const unsigned char *buffer)
{
return (buffer[1] << 8) | buffer[0];
}
0x6e17, 0x7e36, 0x4e55, 0x5e74, 0x2e93, 0x3eb2, 0x0ed1, 0x1ef0
};
-unsigned short CRC_Block(const qbyte *data, size_t size)
+unsigned short CRC_Block(const unsigned char *data, size_t size)
{
unsigned short crc = CRC_INIT_VALUE;
while (size--)
void MSG_WriteChar (sizebuf_t *sb, int c)
{
- qbyte *buf;
+ unsigned char *buf;
buf = SZ_GetSpace (sb, 1);
buf[0] = c;
void MSG_WriteByte (sizebuf_t *sb, int c)
{
- qbyte *buf;
+ unsigned char *buf;
buf = SZ_GetSpace (sb, 1);
buf[0] = c;
void MSG_WriteShort (sizebuf_t *sb, int c)
{
- qbyte *buf;
+ unsigned char *buf;
buf = SZ_GetSpace (sb, 2);
buf[0] = c&0xff;
void MSG_WriteLong (sizebuf_t *sb, int c)
{
- qbyte *buf;
+ unsigned char *buf;
buf = SZ_GetSpace (sb, 4);
buf[0] = c&0xff;
dat.f = f;
dat.l = LittleLong (dat.l);
- SZ_Write (sb, (qbyte *)&dat.l, 4);
+ SZ_Write (sb, (unsigned char *)&dat.l, 4);
}
void MSG_WriteString (sizebuf_t *sb, const char *s)
{
if (!s)
- SZ_Write (sb, (qbyte *)"", 1);
+ SZ_Write (sb, (unsigned char *)"", 1);
else
- SZ_Write (sb, (qbyte *)s, (int)strlen(s)+1);
+ SZ_Write (sb, (unsigned char *)s, (int)strlen(s)+1);
}
void MSG_WriteUnterminatedString (sizebuf_t *sb, const char *s)
{
if (s)
- SZ_Write (sb, (qbyte *)s, (int)strlen(s));
+ SZ_Write (sb, (unsigned char *)s, (int)strlen(s));
}
void MSG_WriteCoord13i (sizebuf_t *sb, float f)
char *MSG_ReadString (void)
{
- static char string[2048];
+ static char string[MAX_INPUTLINE];
int l,c;
for (l = 0;l < (int) sizeof(string) - 1 && (c = MSG_ReadChar()) != -1 && c != 0;l++)
string[l] = c;
buf->cursize = 0;
}
-qbyte *SZ_GetSpace (sizebuf_t *buf, int length)
+unsigned char *SZ_GetSpace (sizebuf_t *buf, int length)
{
- qbyte *data;
+ unsigned char *data;
if (buf->cursize + length > buf->maxsize)
{
if (!buf->allowoverflow)
- Host_Error ("SZ_GetSpace: overflow without allowoverflow set\n");
+ Host_Error ("SZ_GetSpace: overflow without allowoverflow set");
if (length > buf->maxsize)
- Host_Error ("SZ_GetSpace: %i is > full buffer size\n", length);
+ Host_Error ("SZ_GetSpace: %i is > full buffer size", length);
buf->overflowed = true;
Con_Print("SZ_GetSpace: overflow\n");
return data;
}
-void SZ_Write (sizebuf_t *buf, const qbyte *data, int length)
+void SZ_Write (sizebuf_t *buf, const unsigned char *data, int length)
{
memcpy (SZ_GetSpace(buf,length),data,length);
}
// all of darkplaces.
static char *hexchar = "0123456789ABCDEF";
-void Com_HexDumpToConsole(const qbyte *data, int size)
+void Com_HexDumpToConsole(const unsigned char *data, int size)
{
int i, j, n;
char text[1024];
char *cur, *flushpointer;
- const qbyte *d;
+ const unsigned char *d;
cur = text;
flushpointer = text + 512;
for (i = 0;i < size;)
{
// arg contains whitespace, store quotes around it
com_cmdline[n++] = '\"';
- while ((n < (CMDLINE_LENGTH - 1)) && com_argv[j][i])
+ while ((n < ((int)sizeof(com_cmdline) - 1)) && com_argv[j][i])
com_cmdline[n++] = com_argv[j][i++];
com_cmdline[n++] = '\"';
}
else
{
- while ((n < (CMDLINE_LENGTH - 1)) && com_argv[j][i])
+ while ((n < ((int)sizeof(com_cmdline) - 1)) && com_argv[j][i])
com_cmdline[n++] = com_argv[j][i++];
}
- if (n < (CMDLINE_LENGTH - 1))
+ if (n < ((int)sizeof(com_cmdline) - 1))
com_cmdline[n++] = ' ';
else
break;
// written by Elric, thanks Elric!
char *SearchInfostring(const char *infostring, const char *key)
{
- static char value [256];
- char crt_key [256];
+ static char value [MAX_INPUTLINE];
+ char crt_key [MAX_INPUTLINE];
size_t value_ind, key_ind;
char c;
}
}
+void InfoString_GetValue(const char *buffer, const char *key, char *value, size_t valuelength)
+{
+ int pos = 0, j;
+ size_t keylength;
+ if (!key)
+ key = "";
+ if (!value)
+ value = "";
+ keylength = strlen(key);
+ if (valuelength < 1 || !value)
+ {
+ Con_Printf("InfoString_GetValue: no room in value\n");
+ return;
+ }
+ value[0] = 0;
+ if (strchr(key, '\\'))
+ {
+ Con_Printf("InfoString_GetValue: key name \"%s\" contains \\ which is not possible in an infostring\n", key);
+ return;
+ }
+ if (!key[0])
+ {
+ Con_Printf("InfoString_GetValue: can not look up a key with no name\n");
+ return;
+ }
+ while (buffer[pos] == '\\')
+ {
+ if (!memcmp(buffer + pos+1, key, keylength))
+ {
+ for (pos++;buffer[pos] && buffer[pos] != '\\';pos++);
+ pos++;
+ for (j = 0;buffer[pos+j] && buffer[pos+j] != '\\' && j < (int)valuelength - 1;j++)
+ value[j] = buffer[pos+j];
+ value[j] = 0;
+ return;
+ }
+ for (pos++;buffer[pos] && buffer[pos] != '\\';pos++);
+ for (pos++;buffer[pos] && buffer[pos] != '\\';pos++);
+ }
+ // if we reach this point the key was not found
+}
+
+void InfoString_SetValue(char *buffer, size_t bufferlength, const char *key, const char *value)
+{
+ int pos = 0, pos2;
+ size_t keylength;
+ if (!key)
+ key = "";
+ if (!value)
+ value = "";
+ keylength = strlen(key);
+ if (strchr(key, '\\') || strchr(value, '\\'))
+ {
+ Con_Printf("InfoString_SetValue: \"%s\" \"%s\" contains \\ which is not possible to store in an infostring\n", key, value);
+ return;
+ }
+ if (!key[0])
+ {
+ Con_Printf("InfoString_SetValue: can not set a key with no name\n");
+ return;
+ }
+ while (buffer[pos] == '\\')
+ {
+ if (!memcmp(buffer + pos+1, key, keylength))
+ break;
+ for (pos++;buffer[pos] && buffer[pos] != '\\';pos++);
+ for (pos++;buffer[pos] && buffer[pos] != '\\';pos++);
+ }
+ // if we found the key, find the end of it because we will be replacing it
+ pos2 = pos;
+ if (buffer[pos] == '\\')
+ {
+ for (pos2++;buffer[pos2] && buffer[pos2] != '\\';pos++);
+ for (pos2++;buffer[pos2] && buffer[pos2] != '\\';pos++);
+ }
+ if (bufferlength <= 1 + strlen(key) + 1 + strlen(value) + strlen(buffer + pos2))
+ {
+ Con_Printf("InfoString_SetValue: no room for \"%s\" \"%s\" in infostring\n", key, value);
+ return;
+ }
+ if (value && value[0])
+ {
+ // set the key/value and append the remaining text
+ char tempbuffer[4096];
+ strlcpy(tempbuffer, buffer + pos2, sizeof(tempbuffer));
+ sprintf(buffer + pos, "\\%s\\%s%s", key, value, tempbuffer);
+ }
+ else
+ {
+ // just remove the key from the text
+ strcpy(buffer + pos, buffer + pos2);
+ }
+}
+
//========================================================
// strlcat and strlcpy, from OpenBSD