/*
Copyright (C) 1996-1997 Id Software, Inc.
+Copyright (C) 2000-2020 DarkPlaces contributors
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
#include <stdlib.h>
#include <fcntl.h>
-#ifdef WIN32
-#include <io.h>
-#else
+#ifndef WIN32
#include <unistd.h>
#endif
#include "quakedef.h"
+#include "utf8lib.h"
-cvar_t registered = {0, "registered","0"};
-cvar_t cmdline = {0, "cmdline","0"};
-
-mempool_t *pak_mempool;
-
-qboolean com_modified; // set true if using non-id files
-
-qboolean msg_suppress_1 = 0;
-
-void COM_InitFilesystem (void);
-
-char com_token[1024];
-char com_basedir[MAX_OSPATH];
-int com_argc;
-char **com_argv;
-
-// LordHavoc: made commandline 1024 characters instead of 256
-#define CMDLINE_LENGTH 1024
-char com_cmdline[CMDLINE_LENGTH];
-
-int gamemode;
-char *gamename;
-char *gamedirname;
-
-/*
-
-
-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.
+cvar_t registered = {CF_CLIENT | CF_SERVER, "registered","0", "indicates if this is running registered quake (whether gfx/pop.lmp was found)"};
+cvar_t cmdline = {CF_CLIENT | CF_SERVER, "cmdline","0", "contains commandline the engine was launched with"};
+// FIXME: Find a better place for these.
+cvar_t cl_playermodel = {CF_CLIENT | CF_SERVER | CF_USERINFO | CF_ARCHIVE, "playermodel", "", "current player model in Nexuiz/Xonotic"};
+cvar_t cl_playerskin = {CF_CLIENT | CF_SERVER | CF_USERINFO | CF_ARCHIVE, "playerskin", "", "current player skin in Nexuiz/Xonotic"};
+char com_token[MAX_INPUTLINE];
-FIXME:
-The file "parms.txt" will be read out of the game directory and appended to the current command line arguments to allow different games to initialize startup parms differently. This could be used to add a "-sspeed 22050" for the high quality sound edition. Because they are added at the end, they will not override an explicit setting on the original command line.
-
-*/
-
-//============================================================================
-
-
-/*
-============================================================================
-
- LIBRARY REPLACEMENT FUNCTIONS
-
-============================================================================
-*/
+//===========================================================================
-int Q_strncasecmp (char *s1, char *s2, int n)
+void SZ_Clear (sizebuf_t *buf)
{
- 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)
- return -1; // strings not equal
- }
- if (!c1)
- return 0; // strings are equal
- }
-
- return -1;
+ buf->cursize = 0;
}
-int Q_strcasecmp (char *s1, char *s2)
+unsigned char *SZ_GetSpace (sizebuf_t *buf, int length)
{
- return Q_strncasecmp (s1, s2, 99999);
-}
-
-/*
-============================================================================
+ unsigned char *data;
- BYTE ORDER FUNCTIONS
-
-============================================================================
-*/
-
-#if !defined(ENDIAN_LITTLE) && !defined(ENDIAN_BIG)
-short (*BigShort) (short l);
-short (*LittleShort) (short l);
-int (*BigLong) (int l);
-int (*LittleLong) (int l);
-float (*BigFloat) (float l);
-float (*LittleFloat) (float l);
-#endif
+ if (buf->cursize + length > buf->maxsize)
+ {
+ if (!buf->allowoverflow)
+ Host_Error ("SZ_GetSpace: overflow without allowoverflow set");
-short ShortSwap (short l)
-{
- qbyte b1,b2;
+ if (length > buf->maxsize)
+ Host_Error ("SZ_GetSpace: %i is > full buffer size", length);
- b1 = l&255;
- b2 = (l>>8)&255;
+ buf->overflowed = true;
+ Con_Print("SZ_GetSpace: overflow\n");
+ SZ_Clear (buf);
+ }
- return (b1<<8) + b2;
-}
+ data = buf->data + buf->cursize;
+ buf->cursize += length;
-#if !defined(ENDIAN_LITTLE) && !defined(ENDIAN_BIG)
-short ShortNoSwap (short l)
-{
- return l;
+ return data;
}
-#endif
-int LongSwap (int l)
+void SZ_Write (sizebuf_t *buf, const unsigned char *data, int length)
{
- 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;
+ memcpy (SZ_GetSpace(buf,length),data,length);
}
-#if !defined(ENDIAN_LITTLE) && !defined(ENDIAN_BIG)
-int LongNoSwap (int l)
-{
- return l;
-}
-#endif
+// LadyHavoc: thanks to Fuh for bringing the pure evil of SZ_Print to my
+// attention, it has been eradicated from here, its only (former) use in
+// all of darkplaces.
-float FloatSwap (float f)
+static const char *hexchar = "0123456789ABCDEF";
+void Com_HexDumpToConsole(const unsigned char *data, int size)
{
- union
+ int i, j, n;
+ char text[1024];
+ char *cur, *flushpointer;
+ const unsigned char *d;
+ cur = text;
+ flushpointer = text + 512;
+ for (i = 0;i < size;)
{
- 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;
+ n = 16;
+ if (n > size - i)
+ n = size - i;
+ d = data + i;
+ // print offset
+ *cur++ = hexchar[(i >> 12) & 15];
+ *cur++ = hexchar[(i >> 8) & 15];
+ *cur++ = hexchar[(i >> 4) & 15];
+ *cur++ = hexchar[(i >> 0) & 15];
+ *cur++ = ':';
+ // print hex
+ for (j = 0;j < 16;j++)
+ {
+ if (j < n)
+ {
+ *cur++ = hexchar[(d[j] >> 4) & 15];
+ *cur++ = hexchar[(d[j] >> 0) & 15];
+ }
+ else
+ {
+ *cur++ = ' ';
+ *cur++ = ' ';
+ }
+ if ((j & 3) == 3)
+ *cur++ = ' ';
+ }
+ // print text
+ for (j = 0;j < 16;j++)
+ {
+ if (j < n)
+ {
+ // color change prefix character has to be treated specially
+ if (d[j] == STRING_COLOR_TAG)
+ {
+ *cur++ = STRING_COLOR_TAG;
+ *cur++ = STRING_COLOR_TAG;
+ }
+ else if (d[j] >= (unsigned char) ' ')
+ *cur++ = d[j];
+ else
+ *cur++ = '.';
+ }
+ else
+ *cur++ = ' ';
+ }
+ *cur++ = '\n';
+ i += n;
+ if (cur >= flushpointer || i >= size)
+ {
+ *cur++ = 0;
+ Con_Print(text);
+ cur = text;
+ }
+ }
}
-#if !defined(ENDIAN_LITTLE) && !defined(ENDIAN_BIG)
-float FloatNoSwap (float f)
+void SZ_HexDumpToConsole(const sizebuf_t *buf)
{
- return f;
+ Com_HexDumpToConsole(buf->data, buf->cursize);
}
-#endif
-
-/*
-==============================================================================
-
- MESSAGE IO FUNCTIONS
-Handles byte ordering and avoids alignment errors
-==============================================================================
-*/
-
-//
-// writing functions
-//
-
-void MSG_WriteChar (sizebuf_t *sb, int c)
-{
- qbyte *buf;
-
- buf = SZ_GetSpace (sb, 1);
- buf[0] = c;
-}
-void MSG_WriteByte (sizebuf_t *sb, int c)
-{
- qbyte *buf;
-
- buf = SZ_GetSpace (sb, 1);
- buf[0] = c;
-}
+//============================================================================
-void MSG_WriteShort (sizebuf_t *sb, int c)
-{
- qbyte *buf;
+/*
+==============
+COM_Wordwrap
- buf = SZ_GetSpace (sb, 2);
- buf[0] = c&0xff;
- buf[1] = c>>8;
-}
+Word wraps a string. The wordWidth function is guaranteed to be called exactly
+once for each word in the string, so it may be stateful, no idea what that
+would be good for any more. At the beginning of the string, it will be called
+for the char 0 to initialize a clean state, and then once with the string " "
+(a space) so the routine knows how long a space is.
-void MSG_WriteLong (sizebuf_t *sb, int c)
-{
- qbyte *buf;
+In case no single character fits into the given width, the wordWidth function
+must return the width of exactly one character.
- buf = SZ_GetSpace (sb, 4);
- buf[0] = c&0xff;
- buf[1] = (c>>8)&0xff;
- buf[2] = (c>>16)&0xff;
- buf[3] = c>>24;
-}
+Wrapped lines get the isContinuation flag set and are continuationWidth less wide.
-void MSG_WriteFloat (sizebuf_t *sb, float f)
+The sum of the return values of the processLine function will be returned.
+==============
+*/
+int COM_Wordwrap(const char *string, size_t length, float continuationWidth, float maxWidth, COM_WordWidthFunc_t wordWidth, void *passthroughCW, COM_LineProcessorFunc processLine, void *passthroughPL)
{
- union
+ // Logic is as follows:
+ //
+ // For each word or whitespace:
+ // Newline found? Output current line, advance to next line. This is not a continuation. Continue.
+ // Space found? Always add it to the current line, no matter if it fits.
+ // Word found? Check if current line + current word fits.
+ // If it fits, append it. Continue.
+ // If it doesn't fit, output current line, advance to next line. Append the word. This is a continuation. Continue.
+
+ qbool isContinuation = false;
+ float spaceWidth;
+ const char *startOfLine = string;
+ const char *cursor = string;
+ const char *end = string + length;
+ float spaceUsedInLine = 0;
+ float spaceUsedForWord;
+ int result = 0;
+ size_t wordLen;
+ size_t dummy;
+
+ dummy = 0;
+ wordWidth(passthroughCW, NULL, &dummy, -1);
+ dummy = 1;
+ spaceWidth = wordWidth(passthroughCW, " ", &dummy, -1);
+
+ for(;;)
{
- 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, char *s)
-{
- if (!s)
- SZ_Write (sb, "", 1);
- else
- SZ_Write (sb, s, strlen(s)+1);
-}
+ char ch = (cursor < end) ? *cursor : 0;
+ switch(ch)
+ {
+ case 0: // end of string
+ result += processLine(passthroughPL, startOfLine, cursor - startOfLine, spaceUsedInLine, isContinuation);
+ goto out;
+ case '\n': // end of line
+ result += processLine(passthroughPL, startOfLine, cursor - startOfLine, spaceUsedInLine, isContinuation);
+ isContinuation = false;
+ ++cursor;
+ startOfLine = cursor;
+ break;
+ case ' ': // space
+ ++cursor;
+ spaceUsedInLine += spaceWidth;
+ break;
+ default: // word
+ wordLen = 1;
+ while(cursor + wordLen < end)
+ {
+ switch(cursor[wordLen])
+ {
+ case 0:
+ case '\n':
+ case ' ':
+ goto out_inner;
+ default:
+ ++wordLen;
+ break;
+ }
+ }
+ out_inner:
+ spaceUsedForWord = wordWidth(passthroughCW, cursor, &wordLen, maxWidth - continuationWidth); // this may have reduced wordLen when it won't fit - but this is GOOD. TODO fix words that do fit in a non-continuation line
+ if(wordLen < 1) // cannot happen according to current spec of wordWidth
+ {
+ wordLen = 1;
+ spaceUsedForWord = maxWidth + 1; // too high, forces it in a line of itself
+ }
+ if(spaceUsedInLine + spaceUsedForWord <= maxWidth || cursor == startOfLine)
+ {
+ // we can simply append it
+ cursor += wordLen;
+ spaceUsedInLine += spaceUsedForWord;
+ }
+ else
+ {
+ // output current line
+ result += processLine(passthroughPL, startOfLine, cursor - startOfLine, spaceUsedInLine, isContinuation);
+ isContinuation = true;
+ startOfLine = cursor;
+ cursor += wordLen;
+ spaceUsedInLine = continuationWidth + spaceUsedForWord;
+ }
+ }
+ }
+ out:
-// used by server (always latest dpprotocol)
-void MSG_WriteDPCoord (sizebuf_t *sb, float f)
-{
- if (f >= 0)
- MSG_WriteShort (sb, (int)(f + 0.5f));
- else
- MSG_WriteShort (sb, (int)(f - 0.5f));
-}
+ return result;
-void MSG_WritePreciseAngle (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);
-}
+/*
+ qbool isContinuation = false;
+ float currentWordSpace = 0;
+ const char *currentWord = 0;
+ float minReserve = 0;
-// LordHavoc: round to nearest value, rather than rounding toward zero, fixes crosshair problem
-void MSG_WriteAngle (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);
-}
+ float spaceUsedInLine = 0;
+ const char *currentLine = 0;
+ const char *currentLineEnd = 0;
+ float currentLineFinalWhitespace = 0;
+ const char *p;
-//
-// reading functions
-//
-int msg_readcount;
-qboolean msg_badread;
+ int result = 0;
+ minReserve = charWidth(passthroughCW, 0);
+ minReserve += charWidth(passthroughCW, ' ');
-void MSG_BeginReading (void)
-{
- msg_readcount = 0;
- msg_badread = false;
-}
+ if(maxWidth < continuationWidth + minReserve)
+ maxWidth = continuationWidth + minReserve;
-int MSG_ReadShort (void)
-{
- int c;
+ charWidth(passthroughCW, 0);
- if (msg_readcount+2 > net_message.cursize)
+ for(p = string; p < string + length; ++p)
{
- msg_badread = true;
- return -1;
- }
+ char c = *p;
+ float w = charWidth(passthroughCW, c);
- c = (short)(net_message.data[msg_readcount]
- + (net_message.data[msg_readcount+1]<<8));
-
- msg_readcount += 2;
+ if(!currentWord)
+ {
+ currentWord = p;
+ currentWordSpace = 0;
+ }
- return c;
-}
+ if(!currentLine)
+ {
+ currentLine = p;
+ spaceUsedInLine = isContinuation ? continuationWidth : 0;
+ currentLineEnd = 0;
+ }
-int MSG_ReadLong (void)
-{
- int c;
+ if(c == ' ')
+ {
+ // 1. I can add the word AND a space - then just append it.
+ if(spaceUsedInLine + currentWordSpace + w <= maxWidth)
+ {
+ currentLineEnd = p; // note: space not included here
+ currentLineFinalWhitespace = w;
+ spaceUsedInLine += currentWordSpace + w;
+ }
+ // 2. I can just add the word - then append it, output current line and go to next one.
+ else if(spaceUsedInLine + currentWordSpace <= maxWidth)
+ {
+ result += processLine(passthroughPL, currentLine, p - currentLine, spaceUsedInLine + currentWordSpace, isContinuation);
+ currentLine = 0;
+ isContinuation = true;
+ }
+ // 3. Otherwise, output current line and go to next one, where I can add the word.
+ else if(continuationWidth + currentWordSpace + w <= maxWidth)
+ {
+ if(currentLineEnd)
+ result += processLine(passthroughPL, currentLine, currentLineEnd - currentLine, spaceUsedInLine - currentLineFinalWhitespace, isContinuation);
+ currentLine = currentWord;
+ spaceUsedInLine = continuationWidth + currentWordSpace + w;
+ currentLineEnd = p;
+ currentLineFinalWhitespace = w;
+ isContinuation = true;
+ }
+ // 4. We can't even do that? Then output both current and next word as new lines.
+ else
+ {
+ if(currentLineEnd)
+ {
+ result += processLine(passthroughPL, currentLine, currentLineEnd - currentLine, spaceUsedInLine - currentLineFinalWhitespace, isContinuation);
+ isContinuation = true;
+ }
+ result += processLine(passthroughPL, currentWord, p - currentWord, currentWordSpace, isContinuation);
+ currentLine = 0;
+ isContinuation = true;
+ }
+ currentWord = 0;
+ }
+ else if(c == '\n')
+ {
+ // 1. I can add the word - then do it.
+ if(spaceUsedInLine + currentWordSpace <= maxWidth)
+ {
+ result += processLine(passthroughPL, currentLine, p - currentLine, spaceUsedInLine + currentWordSpace, isContinuation);
+ }
+ // 2. Otherwise, output current line, next one and make tabula rasa.
+ else
+ {
+ if(currentLineEnd)
+ {
+ processLine(passthroughPL, currentLine, currentLineEnd - currentLine, spaceUsedInLine - currentLineFinalWhitespace, isContinuation);
+ isContinuation = true;
+ }
+ result += processLine(passthroughPL, currentWord, p - currentWord, currentWordSpace, isContinuation);
+ }
+ currentWord = 0;
+ currentLine = 0;
+ isContinuation = false;
+ }
+ else
+ {
+ currentWordSpace += w;
+ if(
+ spaceUsedInLine + currentWordSpace > maxWidth // can't join this line...
+ &&
+ continuationWidth + currentWordSpace > maxWidth // can't join any other line...
+ )
+ {
+ // this word cannot join ANY line...
+ // so output the current line...
+ if(currentLineEnd)
+ {
+ result += processLine(passthroughPL, currentLine, currentLineEnd - currentLine, spaceUsedInLine - currentLineFinalWhitespace, isContinuation);
+ isContinuation = true;
+ }
- if (msg_readcount+4 > net_message.cursize)
- {
- msg_badread = true;
- return -1;
+ // then this word's beginning...
+ if(isContinuation)
+ {
+ // it may not fit, but we know we have to split it into maxWidth - continuationWidth pieces
+ float pieceWidth = maxWidth - continuationWidth;
+ const char *pos = currentWord;
+ currentWordSpace = 0;
+
+ // reset the char width function to a state where no kerning occurs (start of word)
+ charWidth(passthroughCW, ' ');
+ while(pos <= p)
+ {
+ float w = charWidth(passthroughCW, *pos);
+ if(currentWordSpace + w > pieceWidth) // this piece won't fit any more
+ {
+ // print everything until it
+ result += processLine(passthroughPL, currentWord, pos - currentWord, currentWordSpace, true);
+ // go to here
+ currentWord = pos;
+ currentWordSpace = 0;
+ }
+ currentWordSpace += w;
+ ++pos;
+ }
+ // now we have a currentWord that fits... set up its next line
+ // currentWordSpace has been set
+ // currentWord has been set
+ spaceUsedInLine = continuationWidth;
+ currentLine = currentWord;
+ currentLineEnd = 0;
+ isContinuation = true;
+ }
+ else
+ {
+ // we have a guarantee that it will fix (see if clause)
+ result += processLine(passthroughPL, currentWord, p - currentWord, currentWordSpace - w, isContinuation);
+
+ // and use the rest of this word as new start of a line
+ currentWordSpace = w;
+ currentWord = p;
+ spaceUsedInLine = continuationWidth;
+ currentLine = p;
+ currentLineEnd = 0;
+ isContinuation = true;
+ }
+ }
+ }
}
- 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
+ if(!currentWord)
{
- qbyte b[4];
- float f;
- int l;
- } dat;
-
- dat.b[0] = net_message.data[msg_readcount];
- dat.b[1] = net_message.data[msg_readcount+1];
- dat.b[2] = net_message.data[msg_readcount+2];
- dat.b[3] = net_message.data[msg_readcount+3];
- msg_readcount += 4;
-
- dat.l = LittleLong (dat.l);
-
- return dat.f;
-}
-
-char *MSG_ReadString (void)
-{
- static char string[2048];
- int l,c;
+ currentWord = p;
+ currentWordSpace = 0;
+ }
- l = 0;
- do
+ if(currentLine) // Same procedure as \n
{
- c = MSG_ReadChar ();
- if (c == -1 || c == 0)
- break;
- string[l] = c;
- l++;
- } while (l < sizeof(string)-1);
-
- string[l] = 0;
-
- return string;
-}
-
-// used by server (always latest dpprotocol)
-float MSG_ReadDPCoord (void)
-{
- return (signed short) MSG_ReadShort();
-}
-
-// used by client
-float MSG_ReadCoord (void)
-{
- if (dpprotocol == DPPROTOCOL_VERSION2 || dpprotocol == DPPROTOCOL_VERSION3)
- return (signed short) MSG_ReadShort();
- else if (dpprotocol == DPPROTOCOL_VERSION1)
- return MSG_ReadFloat();
- else
- return MSG_ReadShort() * (1.0f/8.0f);
-}
-
-
-//===========================================================================
+ // Can I append the current word?
+ if(spaceUsedInLine + currentWordSpace <= maxWidth)
+ result += processLine(passthroughPL, currentLine, p - currentLine, spaceUsedInLine + currentWordSpace, isContinuation);
+ else
+ {
+ if(currentLineEnd)
+ {
+ result += processLine(passthroughPL, currentLine, currentLineEnd - currentLine, spaceUsedInLine - currentLineFinalWhitespace, isContinuation);
+ isContinuation = true;
+ }
+ result += processLine(passthroughPL, currentWord, p - currentWord, currentWordSpace, isContinuation);
+ }
+ }
-void SZ_Alloc (sizebuf_t *buf, int startsize, char *name)
-{
- if (startsize < 256)
- startsize = 256;
- buf->mempool = Mem_AllocPool(name);
- buf->data = Mem_Alloc(buf->mempool, startsize);
- buf->maxsize = startsize;
- buf->cursize = 0;
+ return result;
+*/
}
+/*
+==============
+COM_ParseToken_Simple
-void SZ_Free (sizebuf_t *buf)
-{
- Mem_FreePool(&buf->mempool);
- buf->data = NULL;
- buf->maxsize = 0;
- buf->cursize = 0;
-}
-
-void SZ_Clear (sizebuf_t *buf)
+Parse a token out of a string
+==============
+*/
+int COM_ParseToken_Simple(const char **datapointer, qbool returnnewline, qbool parsebackslash, qbool parsecomments)
{
- buf->cursize = 0;
-}
+ int len;
+ int c;
+ const char *data = *datapointer;
-void *SZ_GetSpace (sizebuf_t *buf, int length)
-{
- void *data;
+ len = 0;
+ com_token[0] = 0;
- if (buf->cursize + length > buf->maxsize)
+ if (!data)
{
- if (!buf->allowoverflow)
- Host_Error ("SZ_GetSpace: overflow without allowoverflow set\n");
-
- if (length > buf->maxsize)
- Host_Error ("SZ_GetSpace: %i is > full buffer size\n", length);
-
- buf->overflowed = true;
- Con_Printf ("SZ_GetSpace: overflow\n");
- SZ_Clear (buf);
+ *datapointer = NULL;
+ return false;
}
- data = buf->data + buf->cursize;
- buf->cursize += length;
-
- return data;
-}
-
-void SZ_Write (sizebuf_t *buf, void *data, int length)
-{
- memcpy (SZ_GetSpace(buf,length),data,length);
-}
-
-void SZ_Print (sizebuf_t *buf, char *data)
-{
- int len;
-
- len = strlen(data)+1;
-
-// byte * cast to keep VC++ happy
- if (buf->data[buf->cursize-1])
- memcpy ((qbyte *)SZ_GetSpace(buf, len),data,len); // no trailing 0
- else
- memcpy ((qbyte *)SZ_GetSpace(buf, len-1)-1,data,len); // write over trailing 0
-}
-
-static char *hexchar = "0123456789ABCDEF";
-void SZ_HexDumpToConsole(sizebuf_t *buf)
-{
- int i;
- char text[1024];
- char *cur, *flushpointer;
- cur = text;
- flushpointer = text + 512;
- for (i = 0;i < buf->cursize;i++)
+// skip whitespace
+skipwhite:
+ // line endings:
+ // UNIX: \n
+ // Mac: \r
+ // Windows: \r\n
+ for (;ISWHITESPACE(*data) && ((*data != '\n' && *data != '\r') || !returnnewline);data++)
{
- if ((i & 15) == 0)
- {
- *cur++ = hexchar[(i >> 12) & 15];
- *cur++ = hexchar[(i >> 8) & 15];
- *cur++ = hexchar[(i >> 4) & 15];
- *cur++ = hexchar[(i >> 0) & 15];
- *cur++ = ':';
- *cur++ = ' ';
- }
- else if ((i & 15) == 15)
- *cur++ = '\n';
- else
- *cur++ = ' ';
- if (i & 1)
- {
- *cur++ = hexchar[(buf->data[i] >> 4) & 15] | 0x80;
- *cur++ = hexchar[(buf->data[i] >> 0) & 15] | 0x80;
- }
- else
+ if (*data == 0)
{
- *cur++ = hexchar[(buf->data[i] >> 4) & 15];
- *cur++ = hexchar[(buf->data[i] >> 0) & 15];
+ // end of file
+ *datapointer = NULL;
+ return false;
}
- if (cur >= flushpointer)
+ }
+
+ // handle Windows line ending
+ if (data[0] == '\r' && data[1] == '\n')
+ data++;
+
+ if (parsecomments && data[0] == '/' && data[1] == '/')
+ {
+ // comment
+ while (*data && *data != '\n' && *data != '\r')
+ data++;
+ goto skipwhite;
+ }
+ else if (parsecomments && data[0] == '/' && data[1] == '*')
+ {
+ // comment
+ data++;
+ while (*data && (data[0] != '*' || data[1] != '/'))
+ data++;
+ if (*data)
+ data++;
+ if (*data)
+ data++;
+ goto skipwhite;
+ }
+ else if (*data == '\"')
+ {
+ // quoted string
+ for (data++;*data && *data != '\"';data++)
{
- *cur++ = 0;
- Con_Printf("%s", text);
- cur = text;
+ c = *data;
+ if (*data == '\\' && parsebackslash)
+ {
+ data++;
+ c = *data;
+ if (c == 'n')
+ c = '\n';
+ else if (c == 't')
+ c = '\t';
+ }
+ if (len < (int)sizeof(com_token) - 1)
+ com_token[len++] = c;
}
+ com_token[len] = 0;
+ if (*data == '\"')
+ data++;
+ *datapointer = data;
+ return true;
}
- if ((i & 15) != 0)
- *cur++ = '\n';
- if (cur > text)
+ else if (*data == '\r')
{
- *cur++ = 0;
- Con_Printf("%s", text);
+ // translate Mac line ending to UNIX
+ com_token[len++] = '\n';data++;
+ com_token[len] = 0;
+ *datapointer = data;
+ return true;
}
-}
-
-
-//============================================================================
-
-
-/*
-============
-COM_SkipPath
-============
-*/
-char *COM_SkipPath (char *pathname)
-{
- char *last;
-
- last = pathname;
- while (*pathname)
+ else if (*data == '\n')
{
- if (*pathname=='/')
- last = pathname+1;
- pathname++;
+ // single character
+ com_token[len++] = *data++;
+ com_token[len] = 0;
+ *datapointer = data;
+ return true;
}
- return last;
-}
-
-/*
-============
-COM_StripExtension
-============
-*/
-// LordHavoc: replacement for severely broken COM_StripExtension that was used in original quake.
-void COM_StripExtension (char *in, char *out)
-{
- char *last = NULL;
- while (*in)
- {
- if (*in == '.')
- last = out;
- else if (*in == '/' || *in == '\\' || *in == ':')
- last = NULL;
- *out++ = *in++;
- }
- if (last)
- *last = 0;
else
- *out = 0;
+ {
+ // regular word
+ for (;!ISWHITESPACE(*data);data++)
+ if (len < (int)sizeof(com_token) - 1)
+ com_token[len++] = *data;
+ com_token[len] = 0;
+ *datapointer = data;
+ return true;
+ }
}
/*
-============
-COM_FileExtension
-============
-*/
-char *COM_FileExtension (char *in)
-{
- static char exten[8];
- int i;
-
- while (*in && *in != '.')
- in++;
- if (!*in)
- return "";
- in++;
- for (i=0 ; i<7 && *in ; i++,in++)
- exten[i] = *in;
- exten[i] = 0;
- return exten;
-}
+==============
+COM_ParseToken_QuakeC
-/*
-============
-COM_FileBase
-============
+Parse a token out of a string
+==============
*/
-void COM_FileBase (char *in, char *out)
+int COM_ParseToken_QuakeC(const char **datapointer, qbool returnnewline)
{
- char *slash, *dot;
- char *s;
+ int len;
+ int c;
+ const char *data = *datapointer;
+
+ len = 0;
+ com_token[0] = 0;
- slash = in;
- dot = NULL;
- s = in;
- while(*s)
+ if (!data)
{
- if (*s == '/')
- slash = s + 1;
- if (*s == '.')
- dot = s;
- s++;
+ *datapointer = NULL;
+ return false;
}
- if (dot == NULL)
- dot = s;
- if (dot - slash < 2)
- strcpy (out,"?model?");
- else
+
+// skip whitespace
+skipwhite:
+ // line endings:
+ // UNIX: \n
+ // Mac: \r
+ // Windows: \r\n
+ for (;ISWHITESPACE(*data) && ((*data != '\n' && *data != '\r') || !returnnewline);data++)
{
- while (slash < dot)
- *out++ = *slash++;
- *out++ = 0;
+ if (*data == 0)
+ {
+ // end of file
+ *datapointer = NULL;
+ return false;
+ }
}
-}
+ // handle Windows line ending
+ if (data[0] == '\r' && data[1] == '\n')
+ data++;
-/*
-==================
-COM_DefaultExtension
-==================
-*/
-void COM_DefaultExtension (char *path, char *extension)
-{
- 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 (data[0] == '/' && data[1] == '/')
+ {
+ // comment
+ while (*data && *data != '\n' && *data != '\r')
+ data++;
+ goto skipwhite;
+ }
+ else if (data[0] == '/' && data[1] == '*')
{
- if (*src == '.')
- return; // it has an extension
- src--;
+ // comment
+ data++;
+ while (*data && (data[0] != '*' || data[1] != '/'))
+ data++;
+ if (*data)
+ data++;
+ if (*data)
+ data++;
+ goto skipwhite;
+ }
+ else if (*data == '\"' || *data == '\'')
+ {
+ // quoted string
+ char quote = *data;
+ for (data++;*data && *data != quote;data++)
+ {
+ c = *data;
+ if (*data == '\\')
+ {
+ data++;
+ c = *data;
+ if (c == 'n')
+ c = '\n';
+ else if (c == 't')
+ c = '\t';
+ }
+ if (len < (int)sizeof(com_token) - 1)
+ com_token[len++] = c;
+ }
+ com_token[len] = 0;
+ if (*data == quote)
+ data++;
+ *datapointer = data;
+ return true;
+ }
+ else if (*data == '\r')
+ {
+ // translate Mac line ending to UNIX
+ com_token[len++] = '\n';data++;
+ com_token[len] = 0;
+ *datapointer = data;
+ return true;
+ }
+ else if (*data == '\n' || *data == '{' || *data == '}' || *data == ')' || *data == '(' || *data == ']' || *data == '[' || *data == ':' || *data == ',' || *data == ';')
+ {
+ // single character
+ com_token[len++] = *data++;
+ com_token[len] = 0;
+ *datapointer = data;
+ return true;
+ }
+ else
+ {
+ // regular word
+ for (;!ISWHITESPACE(*data) && *data != '{' && *data != '}' && *data != ')' && *data != '(' && *data != ']' && *data != '[' && *data != ':' && *data != ',' && *data != ';';data++)
+ if (len < (int)sizeof(com_token) - 1)
+ com_token[len++] = *data;
+ com_token[len] = 0;
+ *datapointer = data;
+ return true;
}
-
- strcat (path, extension);
}
-
/*
==============
-COM_Parse
+COM_ParseToken_VM_Tokenize
Parse a token out of a string
==============
*/
-char *COM_Parse (char *data)
+int COM_ParseToken_VM_Tokenize(const char **datapointer, qbool returnnewline)
{
- int c;
- int len;
-
+ int len;
+ int c;
+ const char *data = *datapointer;
+
len = 0;
com_token[0] = 0;
-
+
if (!data)
- return NULL;
-
+ {
+ *datapointer = NULL;
+ return false;
+ }
+
// skip whitespace
skipwhite:
- while ( (c = *data) <= ' ')
+ // line endings:
+ // UNIX: \n
+ // Mac: \r
+ // Windows: \r\n
+ for (;ISWHITESPACE(*data) && ((*data != '\n' && *data != '\r') || !returnnewline);data++)
{
- if (c == 0)
- return NULL; // end of file;
- data++;
+ if (*data == 0)
+ {
+ // end of file
+ *datapointer = NULL;
+ return false;
+ }
}
-// skip // comments
- if (c=='/' && data[1] == '/')
+ // handle Windows line ending
+ if (data[0] == '\r' && data[1] == '\n')
+ data++;
+
+ if (data[0] == '/' && data[1] == '/')
{
- while (*data && *data != '\n')
+ // comment
+ while (*data && *data != '\n' && *data != '\r')
data++;
goto skipwhite;
}
-
-
-// handle quoted strings specially
- if (c == '\"')
+ else if (data[0] == '/' && data[1] == '*')
{
+ // comment
data++;
- while (1)
+ while (*data && (data[0] != '*' || data[1] != '/'))
+ data++;
+ if (*data)
+ data++;
+ if (*data)
+ data++;
+ goto skipwhite;
+ }
+ else if (*data == '\"' || *data == '\'')
+ {
+ char quote = *data;
+ // quoted string
+ for (data++;*data && *data != quote;data++)
{
- c = *data++;
- if (c=='\"' || !c)
+ c = *data;
+ if (*data == '\\')
{
- com_token[len] = 0;
- return data;
+ data++;
+ c = *data;
+ if (c == 'n')
+ c = '\n';
+ else if (c == 't')
+ c = '\t';
}
- com_token[len] = c;
- len++;
+ if (len < (int)sizeof(com_token) - 1)
+ com_token[len++] = c;
}
+ com_token[len] = 0;
+ if (*data == quote)
+ data++;
+ *datapointer = data;
+ return true;
}
-
-// parse single characters
- if (c=='{' || c=='}'|| c==')'|| c=='(' || c=='\'' || c==':')
+ else if (*data == '\r')
{
- com_token[len] = c;
- len++;
+ // translate Mac line ending to UNIX
+ com_token[len++] = '\n';data++;
com_token[len] = 0;
- return data+1;
+ *datapointer = data;
+ return true;
}
-
-// parse a regular word
- do
+ else if (*data == '\n' || *data == '{' || *data == '}' || *data == ')' || *data == '(' || *data == ']' || *data == '[' || *data == ':' || *data == ',' || *data == ';')
{
- com_token[len] = c;
- data++;
- len++;
- c = *data;
- if (c=='{' || c=='}'|| c==')'|| c=='(' || c=='\'' || c==':')
- break;
- } while (c>32);
-
- com_token[len] = 0;
- return data;
+ // single character
+ com_token[len++] = *data++;
+ com_token[len] = 0;
+ *datapointer = data;
+ return true;
+ }
+ else
+ {
+ // regular word
+ for (;!ISWHITESPACE(*data) && *data != '{' && *data != '}' && *data != ')' && *data != '(' && *data != ']' && *data != '[' && *data != ':' && *data != ',' && *data != ';';data++)
+ if (len < (int)sizeof(com_token) - 1)
+ com_token[len++] = *data;
+ com_token[len] = 0;
+ *datapointer = data;
+ return true;
+ }
}
-
/*
-================
-COM_CheckParm
+==============
+COM_ParseToken_Console
-Returns the position (1 to argc-1) in the program's argument list
-where the given parameter apears, or 0 if not present
-================
+Parse a token out of a string, behaving like the qwcl console
+==============
*/
-int COM_CheckParm (char *parm)
+int COM_ParseToken_Console(const char **datapointer)
{
- int i;
-
- for (i=1 ; i<com_argc ; i++)
+ int len;
+ const char *data = *datapointer;
+
+ len = 0;
+ com_token[0] = 0;
+
+ if (!data)
+ {
+ *datapointer = NULL;
+ return false;
+ }
+
+// skip whitespace
+skipwhite:
+ for (;ISWHITESPACE(*data);data++)
{
- if (!com_argv[i])
- continue; // NEXTSTEP sometimes clears appkit vars.
- if (!strcmp (parm,com_argv[i]))
- return i;
+ if (*data == 0)
+ {
+ // end of file
+ *datapointer = NULL;
+ return false;
+ }
+ }
+
+ if (*data == '/' && data[1] == '/')
+ {
+ // comment
+ while (*data && *data != '\n' && *data != '\r')
+ data++;
+ goto skipwhite;
}
-
- return 0;
+ else if (*data == '\"')
+ {
+ // quoted string
+ for (data++;*data && *data != '\"';data++)
+ {
+ // allow escaped " and \ case
+ if (*data == '\\' && (data[1] == '\"' || data[1] == '\\'))
+ data++;
+ if (len < (int)sizeof(com_token) - 1)
+ com_token[len++] = *data;
+ }
+ com_token[len] = 0;
+ if (*data == '\"')
+ data++;
+ *datapointer = data;
+ }
+ else
+ {
+ // regular word
+ for (;!ISWHITESPACE(*data);data++)
+ if (len < (int)sizeof(com_token) - 1)
+ com_token[len++] = *data;
+ com_token[len] = 0;
+ *datapointer = data;
+ }
+
+ return true;
}
/*
-================
-COM_CheckRegistered
+===============
+Com_CalcRoll
-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.
-================
+Used by view and sv_user
+===============
*/
-void COM_CheckRegistered (void)
+float Com_CalcRoll (const vec3_t angles, const vec3_t velocity, const vec_t angleval, const vec_t velocityval)
{
- Cvar_Set ("cmdline", com_cmdline);
+ vec3_t forward, right, up;
+ float sign;
+ float side;
- if (!Sys_FileTime("gfx/pop.lmp"))
- {
- if (com_modified)
- Con_Printf ("Playing shareware version, with modification.\nwarning: most mods require full quake data.\n");
- else
- Con_Printf ("Playing shareware version.\n");
- return;
- }
+ AngleVectors (angles, forward, right, up);
+ side = DotProduct (velocity, right);
+ sign = side < 0 ? -1 : 1;
+ side = fabs(side);
- Cvar_Set ("registered", "1");
- Con_Printf ("Playing registered version.\n");
-}
+ if (side < velocityval)
+ side = side * angleval / velocityval;
+ else
+ side = angleval;
+ return side*sign;
-void COM_Path_f (void);
+}
+//===========================================================================
/*
================
-COM_InitArgv
+COM_Init
================
*/
-void COM_InitArgv (void)
+void COM_Init_Commands (void)
{
int i, j, n;
+ char com_cmdline[MAX_INPUTLINE];
+
+ Cvar_RegisterVariable (®istered);
+ Cvar_RegisterVariable (&cmdline);
+ Cvar_RegisterVariable(&cl_playermodel);
+ Cvar_RegisterVirtual(&cl_playermodel, "_cl_playermodel");
+ Cvar_RegisterVariable(&cl_playerskin);
+ Cvar_RegisterVirtual(&cl_playerskin, "_cl_playerskin");
+
// reconstitute the command line for the cmdline externally visible cvar
n = 0;
- for (j = 0;(j < MAX_NUM_ARGVS) && (j < com_argc);j++)
+ for (j = 0;(j < MAX_NUM_ARGVS) && (j < sys.argc);j++)
{
i = 0;
- while ((n < (CMDLINE_LENGTH - 1)) && com_argv[j][i])
- com_cmdline[n++] = com_argv[j][i++];
- if (n < (CMDLINE_LENGTH - 1))
+ if (strstr(sys.argv[j], " "))
+ {
+ // arg contains whitespace, store quotes around it
+ // This condition checks whether we can allow to put
+ // in two quote characters.
+ if (n >= ((int)sizeof(com_cmdline) - 2))
+ break;
+ com_cmdline[n++] = '\"';
+ // This condition checks whether we can allow one
+ // more character and a quote character.
+ while ((n < ((int)sizeof(com_cmdline) - 2)) && sys.argv[j][i])
+ // FIXME: Doesn't quote special characters.
+ com_cmdline[n++] = sys.argv[j][i++];
+ com_cmdline[n++] = '\"';
+ }
+ else
+ {
+ // This condition checks whether we can allow one
+ // more character.
+ while ((n < ((int)sizeof(com_cmdline) - 1)) && sys.argv[j][i])
+ com_cmdline[n++] = sys.argv[j][i++];
+ }
+ if (n < ((int)sizeof(com_cmdline) - 1))
com_cmdline[n++] = ' ';
else
break;
}
com_cmdline[n] = 0;
+ Cvar_SetQuick(&cmdline, com_cmdline);
}
-void COM_InitGameType (void)
-{
- char name[MAX_OSPATH];
- COM_StripExtension(com_argv[0], name);
- COM_ToLowerString(name, name);
-
- if (strstr(name, "transfusion"))
- gamemode = GAME_TRANSFUSION;
- else if (strstr(name, "nehahra"))
- gamemode = GAME_NEHAHRA;
- else if (strstr(name, "hipnotic"))
- gamemode = GAME_HIPNOTIC;
- else if (strstr(name, "rogue"))
- gamemode = GAME_ROGUE;
- else
- gamemode = GAME_NORMAL;
-
- if (COM_CheckParm ("-transfusion"))
- gamemode = GAME_TRANSFUSION;
- else if (COM_CheckParm ("-nehahra"))
- gamemode = GAME_NEHAHRA;
- else if (COM_CheckParm ("-hipnotic"))
- gamemode = GAME_HIPNOTIC;
- else if (COM_CheckParm ("-rogue"))
- gamemode = GAME_ROGUE;
- else if (COM_CheckParm ("-quake"))
- gamemode = GAME_NORMAL;
-
- switch(gamemode)
- {
- case GAME_NORMAL:
- gamename = "DarkPlaces-Quake";
- gamedirname = "";
- break;
- case GAME_HIPNOTIC:
- gamename = "Darkplaces-Hipnotic";
- gamedirname = "hipnotic";
- break;
- case GAME_ROGUE:
- gamename = "Darkplaces-Rogue";
- gamedirname = "rogue";
- break;
- case GAME_NEHAHRA:
- gamename = "DarkPlaces-Nehahra";
- gamedirname = "nehahra";
- break;
- case GAME_TRANSFUSION:
- gamename = "Transfusion";
- gamedirname = "transfusion";
- break;
- default:
- Sys_Error("COM_InitGameType: unknown gamemode %i\n", gamemode);
- break;
- }
-}
-
-
-extern void Mathlib_Init(void);
-
-/*
-================
-COM_Init
-================
-*/
-void COM_Init (void)
-{
-#if !defined(ENDIAN_LITTLE) && !defined(ENDIAN_BIG)
- qbyte swaptest[2] = {1,0};
-
-// set the byte swapping variables in a portable manner
- if ( *(short *)swaptest == 1)
- {
- BigShort = ShortSwap;
- LittleShort = ShortNoSwap;
- BigLong = LongSwap;
- LittleLong = LongNoSwap;
- BigFloat = FloatSwap;
- LittleFloat = FloatNoSwap;
- }
- else
- {
- BigShort = ShortNoSwap;
- LittleShort = ShortSwap;
- BigLong = LongNoSwap;
- LittleLong = LongSwap;
- BigFloat = FloatNoSwap;
- LittleFloat = FloatSwap;
- }
-#endif
-
- pak_mempool = Mem_AllocPool("paks");
-
- Cvar_RegisterVariable (®istered);
- Cvar_RegisterVariable (&cmdline);
- Cmd_AddCommand ("path", COM_Path_f);
-
- Mathlib_Init();
-
- COM_InitFilesystem ();
- COM_CheckRegistered ();
-}
-
-
/*
============
va
-does a varargs printf into a temp buffer, so I don't need to have
-varargs versions of all text functions.
-FIXME: make this buffer size safe someday
+varargs print into provided buffer, returns buffer (so that it can be called in-line, unlike dpsnprintf)
============
*/
-char *va(char *format, ...)
+char *va(char *buf, size_t buflen, const char *format, ...)
{
va_list argptr;
- // LordHavoc: now cycles through 8 buffers to avoid problems in most cases
- static char string[8][1024], *s;
- static int stringindex = 0;
- s = string[stringindex];
- stringindex = (stringindex + 1) & 7;
va_start (argptr, format);
- vsprintf (s, format,argptr);
+ dpvsnprintf (buf, buflen, format,argptr);
va_end (argptr);
- return s;
+ return buf;
}
-/*
-=============================================================================
-
-QUAKE FILESYSTEM
+//======================================
-=============================================================================
-*/
+// snprintf and vsnprintf are NOT portable. Use their DP counterparts instead
-int com_filesize;
+#undef snprintf
+#undef vsnprintf
+#ifdef WIN32
+# define snprintf _snprintf
+# define vsnprintf _vsnprintf
+#endif
-//
-// in memory
-//
-typedef struct
+int dpsnprintf (char *buffer, size_t buffersize, const char *format, ...)
{
- char name[MAX_QPATH];
- int filepos, filelen;
-} packfile_t;
+ va_list args;
+ int result;
-typedef struct pack_s
-{
- char filename[MAX_OSPATH];
- int handle;
- int numfiles;
- packfile_t *files;
- mempool_t *mempool;
- struct pack_s *next;
-} pack_t;
-
-//
-// on disk
-//
-typedef struct
-{
- char name[56];
- int filepos, filelen;
-} dpackfile_t;
+ va_start (args, format);
+ result = dpvsnprintf (buffer, buffersize, format, args);
+ va_end (args);
-typedef struct
-{
- char id[4];
- int dirofs;
- int dirlen;
-} dpackheader_t;
+ return result;
+}
-// LordHavoc: was 2048, increased to 65536 and changed info[MAX_PACK_FILES] to a temporary alloc
-#define MAX_FILES_IN_PACK 65536
-pack_t *packlist = NULL;
+int dpvsnprintf (char *buffer, size_t buffersize, const char *format, va_list args)
+{
+ int result;
-#if CACHEENABLE
-char com_cachedir[MAX_OSPATH];
+#if _MSC_VER >= 1400
+ result = _vsnprintf_s (buffer, buffersize, _TRUNCATE, format, args);
+#else
+ result = vsnprintf (buffer, buffersize, format, args);
#endif
-char com_gamedir[MAX_OSPATH];
+ if (result < 0 || (size_t)result >= buffersize)
+ {
+ buffer[buffersize - 1] = '\0';
+ return -1;
+ }
-typedef struct searchpath_s
-{
- char filename[MAX_OSPATH];
- pack_t *pack; // only one of filename / pack will be used
- struct searchpath_s *next;
-} searchpath_t;
+ return result;
+}
-searchpath_t *com_searchpaths;
-/*
-============
-COM_Path_f
+//======================================
-============
-*/
-void COM_Path_f (void)
+void COM_ToLowerString (const char *in, char *out, size_t size_out)
{
- searchpath_t *s;
+ if (size_out == 0)
+ return;
- Con_Printf ("Current search path:\n");
- for (s=com_searchpaths ; s ; s=s->next)
+ if(utf8_enable.integer)
{
- if (s->pack)
+ *out = 0;
+ while(*in && size_out > 1)
{
- Con_Printf ("%s (%i files)\n", s->pack->filename, s->pack->numfiles);
+ int n;
+ Uchar ch = u8_getchar_utf8_enabled(in, &in);
+ ch = u8_tolower(ch);
+ n = u8_fromchar(ch, out, size_out);
+ if(n <= 0)
+ break;
+ out += n;
+ size_out -= n;
}
+ return;
+ }
+
+ while (*in && size_out > 1)
+ {
+ if (*in >= 'A' && *in <= 'Z')
+ *out++ = *in++ + 'a' - 'A';
else
- Con_Printf ("%s\n", s->filename);
+ *out++ = *in++;
+ size_out--;
}
+ *out = '\0';
}
-/*
-============
-COM_CreatePath
-
-LordHavoc: Previously only used for CopyFile, now also used for COM_WriteFile.
-============
-*/
-void COM_CreatePath (char *path)
+void COM_ToUpperString (const char *in, char *out, size_t size_out)
{
- char *ofs, save;
+ if (size_out == 0)
+ return;
- for (ofs = path+1 ; *ofs ; ofs++)
+ if(utf8_enable.integer)
{
- if (*ofs == '/' || *ofs == '\\')
+ *out = 0;
+ while(*in && size_out > 1)
{
- // create the directory
- save = *ofs;
- *ofs = 0;
- Sys_mkdir (path);
- *ofs = save;
+ int n;
+ Uchar ch = u8_getchar_utf8_enabled(in, &in);
+ ch = u8_toupper(ch);
+ n = u8_fromchar(ch, out, size_out);
+ if(n <= 0)
+ break;
+ out += n;
+ size_out -= n;
}
+ return;
}
-}
-
-
-/*
-============
-COM_WriteFile
-The filename will be prefixed by the current game directory
-============
-*/
-qboolean COM_WriteFile (char *filename, void *data, int len)
-{
- int handle;
- char name[MAX_OSPATH];
-
- sprintf (name, "%s/%s", com_gamedir, filename);
-
- // LordHavoc: added this
- COM_CreatePath (name); // create directories up to the file
-
- handle = Sys_FileOpenWrite (name);
- if (handle == -1)
+ while (*in && size_out > 1)
{
- Con_Printf ("COM_WriteFile: failed on %s\n", name);
- return false;
+ if (*in >= 'a' && *in <= 'z')
+ *out++ = *in++ + 'A' - 'a';
+ else
+ *out++ = *in++;
+ size_out--;
}
+ *out = '\0';
+}
- Con_DPrintf ("COM_WriteFile: %s\n", name);
- Sys_FileWrite (handle, data, len);
- Sys_FileClose (handle);
+int COM_StringBeginsWith(const char *s, const char *match)
+{
+ for (;*s && *match;s++, match++)
+ if (*s != *match)
+ return false;
return true;
}
-
-/*
-===========
-COM_CopyFile
-
-Copies a file over from the net to the local cache, creating any directories
-needed. This is for the convenience of developers using ISDN from home.
-===========
-*/
-void COM_CopyFile (char *netpath, char *cachepath)
+int COM_ReadAndTokenizeLine(const char **text, char **argv, int maxargc, char *tokenbuf, int tokenbufsize, const char *commentprefix)
{
- int in, out;
- int remaining, count;
- char buf[4096];
-
- remaining = Sys_FileOpenRead (netpath, &in);
- COM_CreatePath (cachepath); // create directories up to the cache file
- out = Sys_FileOpenWrite (cachepath);
-
- while (remaining)
+ int argc, commentprefixlength;
+ char *tokenbufend;
+ const char *l;
+ argc = 0;
+ tokenbufend = tokenbuf + tokenbufsize;
+ l = *text;
+ commentprefixlength = 0;
+ if (commentprefix)
+ commentprefixlength = (int)strlen(commentprefix);
+ while (*l && *l != '\n' && *l != '\r')
{
- if (remaining < sizeof(buf))
- count = remaining;
+ if (!ISWHITESPACE(*l))
+ {
+ if (commentprefixlength && !strncmp(l, commentprefix, commentprefixlength))
+ {
+ while (*l && *l != '\n' && *l != '\r')
+ l++;
+ break;
+ }
+ if (argc >= maxargc)
+ return -1;
+ argv[argc++] = tokenbuf;
+ if (*l == '"')
+ {
+ l++;
+ while (*l && *l != '"')
+ {
+ if (tokenbuf >= tokenbufend)
+ return -1;
+ *tokenbuf++ = *l++;
+ }
+ if (*l == '"')
+ l++;
+ }
+ else
+ {
+ while (!ISWHITESPACE(*l))
+ {
+ if (tokenbuf >= tokenbufend)
+ return -1;
+ *tokenbuf++ = *l++;
+ }
+ }
+ if (tokenbuf >= tokenbufend)
+ return -1;
+ *tokenbuf++ = 0;
+ }
else
- count = sizeof(buf);
- Sys_FileRead (in, buf, count);
- Sys_FileWrite (out, buf, count);
- remaining -= count;
+ l++;
}
-
- Sys_FileClose (in);
- Sys_FileClose (out);
+ // line endings:
+ // UNIX: \n
+ // Mac: \r
+ // Windows: \r\n
+ if (*l == '\r')
+ l++;
+ if (*l == '\n')
+ l++;
+ *text = l;
+ return argc;
}
/*
-===========
-COM_OpenRead
-===========
-*/
-QFile * COM_OpenRead (const char *path, int offs, int len, qboolean zip)
-{
- int fd = open (path, O_RDONLY);
- unsigned char id[2];
- unsigned char len_bytes[4];
+============
+COM_StringLengthNoColors
- if (fd == -1)
- {
- Sys_Error ("Couldn't open %s", path);
- return 0;
- }
- if (offs < 0 || len < 0)
- {
- // normal file
- offs = 0;
- len = lseek (fd, 0, SEEK_END);
- lseek (fd, 0, SEEK_SET);
- }
- lseek (fd, offs, SEEK_SET);
- if (zip)
- {
- read (fd, id, 2);
- if (id[0] == 0x1f && id[1] == 0x8b)
- {
- lseek (fd, offs + len - 4, SEEK_SET);
- read (fd, len_bytes, 4);
- len = ((len_bytes[3] << 24)
- | (len_bytes[2] << 16)
- | (len_bytes[1] << 8)
- | (len_bytes[0]));
- }
- }
- lseek (fd, offs, SEEK_SET);
- com_filesize = len;
+calculates the visible width of a color coded string.
-#ifdef WIN32
- setmode (fd, O_BINARY);
-#endif
- if (zip)
- return Qdopen (fd, "rbz");
- else
- return Qdopen (fd, "rb");
-}
+*valid is filled with TRUE if the string is a valid colored string (that is, if
+it does not end with an unfinished color code). If it gets filled with FALSE, a
+fix would be adding a STRING_COLOR_TAG at the end of the string.
-/*
-===========
-COM_FindFile
+valid can be set to NULL if the caller doesn't care.
-Finds the file in the search path.
-Sets com_filesize and one of handle or file
-===========
+For size_s, specify the maximum number of characters from s to use, or 0 to use
+all characters until the zero terminator.
+============
*/
-int COM_FindFile (char *filename, QFile **file, qboolean quiet, qboolean zip)
+size_t
+COM_StringLengthNoColors(const char *s, size_t size_s, qbool *valid)
{
- searchpath_t *search;
- char netpath[MAX_OSPATH];
-#if CACHEENABLE
- char cachepath[MAX_OSPATH];
- int cachetime;
-#endif
- pack_t *pak;
- int i;
- int findtime;
- char gzfilename[MAX_OSPATH];
- int filenamelen;
-
- filenamelen = strlen (filename);
- sprintf (gzfilename, "%s.gz", filename);
-
- if (!file)
- Sys_Error ("COM_FindFile: file not set");
-
-//
-// search through the path, one element at a time
-//
- search = com_searchpaths;
-
- for ( ; search ; search = search->next)
+ const char *end = size_s ? (s + size_s) : NULL;
+ size_t len = 0;
+ for(;;)
{
- // is the element a pak file?
- if (search->pack)
+ switch((s == end) ? 0 : *s)
{
- // look through all the pak file elements
- pak = search->pack;
- for (i=0 ; i<pak->numfiles ; i++)
- if (!strcmp (pak->files[i].name, filename)
- || !strcmp (pak->files[i].name, gzfilename))
- { // found it!
- if (!quiet)
- Sys_Printf ("PackFile: %s : %s\n",pak->filename, pak->files[i].name);
- // open a new file on the pakfile
- *file = COM_OpenRead (pak->filename, pak->files[i].filepos, pak->files[i].filelen, zip);
- return com_filesize;
+ case 0:
+ if(valid)
+ *valid = true;
+ return len;
+ case STRING_COLOR_TAG:
+ ++s;
+ switch((s == end) ? 0 : *s)
+ {
+ case STRING_COLOR_RGB_TAG_CHAR:
+ if (s+1 != end && isxdigit(s[1]) &&
+ s+2 != end && isxdigit(s[2]) &&
+ s+3 != end && isxdigit(s[3]) )
+ {
+ s+=3;
+ break;
+ }
+ ++len; // STRING_COLOR_TAG
+ ++len; // STRING_COLOR_RGB_TAG_CHAR
+ break;
+ case 0: // ends with unfinished color code!
+ ++len;
+ if(valid)
+ *valid = false;
+ return len;
+ case STRING_COLOR_TAG: // escaped ^
+ ++len;
+ break;
+ case '0': case '1': case '2': case '3': case '4':
+ case '5': case '6': case '7': case '8': case '9': // color code
+ break;
+ default: // not a color code
+ ++len; // STRING_COLOR_TAG
+ ++len; // the character
+ break;
}
+ break;
+ default:
+ ++len;
+ break;
}
- else
- {
- sprintf (netpath, "%s/%s",search->filename, filename);
-
- findtime = Sys_FileTime (netpath);
- if (findtime == -1)
- continue;
-
-#if CACHEENABLE
- // see if the file needs to be updated in the cache
- if (com_cachedir[0])
- {
-#if defined(_WIN32)
- if ((strlen(netpath) < 2) || (netpath[1] != ':'))
- sprintf (cachepath,"%s%s", com_cachedir, netpath);
- else
- sprintf (cachepath,"%s%s", com_cachedir, netpath+2);
-#else
- sprintf (cachepath,"%s%s", com_cachedir, netpath);
-#endif
-
- cachetime = Sys_FileTime (cachepath);
-
- if (cachetime < findtime)
- COM_CopyFile (netpath, cachepath);
- strcpy (netpath, cachepath);
- }
-#endif
-
- if (!quiet)
- Sys_Printf ("FindFile: %s\n",netpath);
- *file = COM_OpenRead (netpath, -1, -1, zip);
- return com_filesize;
- }
-
- }
-
- if (!quiet)
- Sys_Printf ("FindFile: can't find %s\n", filename);
-
- *file = NULL;
- com_filesize = -1;
- return -1;
+ ++s;
+ }
+ // never get here
}
-
/*
-===========
-COM_FOpenFile
+============
+COM_StringDecolorize
-If the requested file is inside a packfile, a new QFile * will be opened
-into the file.
-===========
-*/
-int COM_FOpenFile (char *filename, QFile **file, qboolean quiet, qboolean zip)
-{
- return COM_FindFile (filename, file, quiet, zip);
-}
+removes color codes from a string.
+If escape_carets is true, the resulting string will be safe for printing. If
+escape_carets is false, the function will just strip color codes (for logging
+for example).
-/*
-============
-COM_LoadFile
+If the output buffer size did not suffice for converting, the function returns
+FALSE. Generally, if escape_carets is false, the output buffer needs
+strlen(str)+1 bytes, and if escape_carets is true, it can need strlen(str)*1.5+2
+bytes. In any case, the function makes sure that the resulting string is
+zero terminated.
-Filename are reletive to the quake directory.
-Always appends a 0 byte.
+For size_in, specify the maximum number of characters from in to use, or 0 to use
+all characters until the zero terminator.
============
*/
-qbyte *loadbuf;
-int loadsize;
-qbyte *COM_LoadFile (char *path, qboolean quiet)
+qbool
+COM_StringDecolorize(const char *in, size_t size_in, char *out, size_t size_out, qbool escape_carets)
{
- QFile *h;
- qbyte *buf;
- char base[1024];
- int len;
-
- buf = NULL; // quiet compiler warning
- loadsize = 0;
-
-// look for it in the filesystem or pack files
- len = COM_FOpenFile (path, &h, quiet, true);
- if (!h)
- return NULL;
-
- loadsize = len;
-
-// extract the filename base name for hunk tag
- COM_FileBase (path, base);
-
- buf = Mem_Alloc(tempmempool, len+1);
- if (!buf)
- Sys_Error ("COM_LoadFile: not enough available memory for %s (size %i)", path, len);
-
- ((qbyte *)buf)[len] = 0;
-
- Qread (h, buf, len);
- Qclose (h);
-
- return buf;
+#define APPEND(ch) do { if(--size_out) { *out++ = (ch); } else { *out++ = 0; return false; } } while(0)
+ const char *end = size_in ? (in + size_in) : NULL;
+ if(size_out < 1)
+ return false;
+ for(;;)
+ {
+ switch((in == end) ? 0 : *in)
+ {
+ case 0:
+ *out++ = 0;
+ return true;
+ case STRING_COLOR_TAG:
+ ++in;
+ switch((in == end) ? 0 : *in)
+ {
+ case STRING_COLOR_RGB_TAG_CHAR:
+ if (in+1 != end && isxdigit(in[1]) &&
+ in+2 != end && isxdigit(in[2]) &&
+ in+3 != end && isxdigit(in[3]) )
+ {
+ in+=3;
+ break;
+ }
+ APPEND(STRING_COLOR_TAG);
+ if(escape_carets)
+ APPEND(STRING_COLOR_TAG);
+ APPEND(STRING_COLOR_RGB_TAG_CHAR);
+ break;
+ case 0: // ends with unfinished color code!
+ APPEND(STRING_COLOR_TAG);
+ // finish the code by appending another caret when escaping
+ if(escape_carets)
+ APPEND(STRING_COLOR_TAG);
+ *out++ = 0;
+ return true;
+ case STRING_COLOR_TAG: // escaped ^
+ APPEND(STRING_COLOR_TAG);
+ // append a ^ twice when escaping
+ if(escape_carets)
+ APPEND(STRING_COLOR_TAG);
+ break;
+ case '0': case '1': case '2': case '3': case '4':
+ case '5': case '6': case '7': case '8': case '9': // color code
+ break;
+ default: // not a color code
+ APPEND(STRING_COLOR_TAG);
+ APPEND(*in);
+ break;
+ }
+ break;
+ default:
+ APPEND(*in);
+ break;
+ }
+ ++in;
+ }
+ // never get here
+#undef APPEND
}
-/*
-=================
-COM_LoadPackFile
-
-Takes an explicit (not game tree related) path to a pak file.
-
-Loads the header and directory, adding the files at the beginning
-of the list so they override previous pack files.
-=================
-*/
-pack_t *COM_LoadPackFile (char *packfile)
+char *InfoString_GetValue(const char *buffer, const char *key, char *value, size_t valuelength)
{
- dpackheader_t header;
- int i;
- int numpackfiles;
- pack_t *pack;
- int packhandle;
- // LordHavoc: changed from stack array to temporary alloc, allowing huge pack directories
- dpackfile_t *info;
-
- if (Sys_FileOpenRead (packfile, &packhandle) == -1)
+ int pos = 0, j;
+ size_t keylength;
+ if (!key)
+ key = "";
+ keylength = strlen(key);
+ if (valuelength < 1 || !value)
+ {
+ Con_Printf("InfoString_GetValue: no room in value\n");
return NULL;
-
- Sys_FileRead (packhandle, (void *)&header, sizeof(header));
- if (memcmp(header.id, "PACK", 4))
- Sys_Error ("%s is not a packfile", packfile);
- header.dirofs = LittleLong (header.dirofs);
- header.dirlen = LittleLong (header.dirlen);
-
- if (header.dirlen % sizeof(dpackfile_t))
- Sys_Error ("%s has an invalid directory size", packfile);
-
- numpackfiles = header.dirlen / sizeof(dpackfile_t);
-
- if (numpackfiles > MAX_FILES_IN_PACK)
- Sys_Error ("%s has %i files", packfile, numpackfiles);
-
- pack = Mem_Alloc(pak_mempool, sizeof (pack_t));
- strcpy (pack->filename, packfile);
- pack->handle = packhandle;
- pack->numfiles = numpackfiles;
- pack->mempool = Mem_AllocPool(packfile);
- pack->files = Mem_Alloc(pack->mempool, numpackfiles * sizeof(packfile_t));
- pack->next = packlist;
- packlist = pack;
-
- info = Mem_Alloc(tempmempool, sizeof(*info) * numpackfiles);
- Sys_FileSeek (packhandle, header.dirofs);
- Sys_FileRead (packhandle, (void *)info, header.dirlen);
-
-// parse the directory
- for (i = 0;i < numpackfiles;i++)
+ }
+ value[0] = 0;
+ if (strchr(key, '\\'))
{
- strcpy (pack->files[i].name, info[i].name);
- pack->files[i].filepos = LittleLong(info[i].filepos);
- pack->files[i].filelen = LittleLong(info[i].filelen);
+ Con_Printf("InfoString_GetValue: key name \"%s\" contains \\ which is not possible in an infostring\n", key);
+ return NULL;
}
-
- Mem_Free(info);
-
- Con_Printf ("Added packfile %s (%i files)\n", packfile, numpackfiles);
- return pack;
+ if (strchr(key, '\"'))
+ {
+ Con_Printf("InfoString_SetValue: key name \"%s\" contains \" which is not allowed in an infostring\n", key);
+ return NULL;
+ }
+ if (!key[0])
+ {
+ Con_Printf("InfoString_GetValue: can not look up a key with no name\n");
+ return NULL;
+ }
+ while (buffer[pos] == '\\')
+ {
+ if (!memcmp(buffer + pos+1, key, keylength) &&
+ (buffer[pos+1 + keylength] == 0 ||
+ buffer[pos+1 + keylength] == '\\'))
+ {
+ pos += 1 + (int)keylength; // Skip \key
+ if (buffer[pos] == '\\') pos++; // Skip \ before value.
+ for (j = 0;buffer[pos+j] && buffer[pos+j] != '\\' && j < (int)valuelength - 1;j++)
+ value[j] = buffer[pos+j];
+ value[j] = 0;
+ return value;
+ }
+ if (buffer[pos] == '\\') pos++; // Skip \ before value.
+ for (pos++;buffer[pos] && buffer[pos] != '\\';pos++);
+ if (buffer[pos] == '\\') pos++; // Skip \ before value.
+ for (pos++;buffer[pos] && buffer[pos] != '\\';pos++);
+ }
+ // if we reach this point the key was not found
+ return NULL;
}
+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 (strchr(key, '\"') || strchr(value, '\"'))
+ {
+ Con_Printf("InfoString_SetValue: \"%s\" \"%s\" contains \" which is not allowed 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) &&
+ (buffer[pos+1 + keylength] == 0 ||
+ buffer[pos+1 + keylength] == '\\'))
+ break;
+ if (buffer[pos] == '\\') pos++; // Skip \ before value.
+ for (;buffer[pos] && buffer[pos] != '\\';pos++);
+ if (buffer[pos] == '\\') pos++; // Skip \ before value.
+ for (;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] == '\\')
+ {
+ pos2 += 1 + (int)keylength; // Skip \key
+ if (buffer[pos2] == '\\') pos2++; // Skip \ before value.
+ for (;buffer[pos2] && buffer[pos2] != '\\';pos2++);
+ }
+ if (bufferlength <= pos + 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[0])
+ {
+ // set the key/value and append the remaining text
+ char tempbuffer[MAX_INPUTLINE];
+ strlcpy(tempbuffer, buffer + pos2, sizeof(tempbuffer));
+ dpsnprintf(buffer + pos, bufferlength - pos, "\\%s\\%s%s", key, value, tempbuffer);
+ }
+ else
+ {
+ // just remove the key from the text
+ strlcpy(buffer + pos, buffer + pos2, bufferlength - pos);
+ }
+}
-/*
-================
-COM_AddGameDirectory
-
-Sets com_gamedir, adds the directory to the head of the path,
-then loads and adds pak1.pak pak2.pak ...
-================
-*/
-void COM_AddGameDirectory (char *dir)
+void InfoString_Print(char *buffer)
{
- stringlist_t *list, *current;
- searchpath_t *search;
- pack_t *pak;
- char pakfile[MAX_OSPATH];
-
- strcpy (com_gamedir, dir);
-
-//
-// add the directory to the search path
-//
- search = Mem_Alloc(pak_mempool, sizeof(searchpath_t));
- strcpy (search->filename, dir);
- search->next = com_searchpaths;
- com_searchpaths = search;
-
- // add any paks in the directory
- list = listdirectory(dir);
- for (current = list;current;current = current->next)
+ int i;
+ char key[MAX_INPUTLINE];
+ char value[MAX_INPUTLINE];
+ while (*buffer)
{
- if (matchpattern(current->text, "*.pak"))
+ if (*buffer != '\\')
{
- sprintf (pakfile, "%s/%s", dir, current->text);
- pak = COM_LoadPackFile (pakfile);
- if (pak)
- {
- search = Mem_Alloc(pak_mempool, sizeof(searchpath_t));
- search->pack = pak;
- search->next = com_searchpaths;
- com_searchpaths = search;
- }
- else
- Con_Printf("unable to load pak \"%s\"\n", pakfile);
+ Con_Printf("InfoString_Print: corrupt string\n");
+ return;
+ }
+ for (buffer++, i = 0;*buffer && *buffer != '\\';buffer++)
+ if (i < (int)sizeof(key)-1)
+ key[i++] = *buffer;
+ key[i] = 0;
+ if (*buffer != '\\')
+ {
+ Con_Printf("InfoString_Print: corrupt string\n");
+ return;
}
+ for (buffer++, i = 0;*buffer && *buffer != '\\';buffer++)
+ if (i < (int)sizeof(value)-1)
+ value[i++] = *buffer;
+ value[i] = 0;
+ // empty value is an error case
+ Con_Printf("%20s %s\n", key, value[0] ? value : "NO VALUE");
}
- freedirectory(list);
}
+//========================================================
+// strlcat and strlcpy, from OpenBSD
+
/*
-================
-COM_InitFilesystem
-================
-*/
-void COM_InitFilesystem (void)
+ * Copyright (c) 1998 Todd C. Miller <Todd.Miller@courtesan.com>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/* $OpenBSD: strlcat.c,v 1.11 2003/06/17 21:56:24 millert Exp $ */
+/* $OpenBSD: strlcpy.c,v 1.8 2003/06/17 21:56:24 millert Exp $ */
+
+
+#ifndef HAVE_STRLCAT
+size_t
+strlcat(char *dst, const char *src, size_t siz)
{
- int i;
- searchpath_t *search;
-
- strcpy(com_basedir, ".");
+ register char *d = dst;
+ register const char *s = src;
+ register size_t n = siz;
+ size_t dlen;
+
+ /* Find the end of dst and adjust bytes left but don't go past end */
+ while (n-- != 0 && *d != '\0')
+ d++;
+ dlen = d - dst;
+ n = siz - dlen;
+
+ if (n == 0)
+ return(dlen + strlen(s));
+ while (*s != '\0') {
+ if (n != 1) {
+ *d++ = *s;
+ n--;
+ }
+ s++;
+ }
+ *d = '\0';
- // -basedir <path>
- // Overrides the system supplied base directory (under GAMENAME)
- i = COM_CheckParm ("-basedir");
- if (i && i < com_argc-1)
- strcpy (com_basedir, com_argv[i+1]);
+ return(dlen + (s - src)); /* count does not include NUL */
+}
+#endif // #ifndef HAVE_STRLCAT
- i = strlen (com_basedir);
- if (i > 0 && (com_basedir[i-1] == '\\' || com_basedir[i-1] == '/'))
- com_basedir[i-1] = 0;
-// start up with GAMENAME by default (id1)
- COM_AddGameDirectory (va("%s/"GAMENAME, com_basedir));
- if (gamedirname[0])
- {
- com_modified = true;
- COM_AddGameDirectory (va("%s/%s", com_basedir, gamedirname));
+#ifndef HAVE_STRLCPY
+size_t
+strlcpy(char *dst, const char *src, size_t siz)
+{
+ register char *d = dst;
+ register const char *s = src;
+ register size_t n = siz;
+
+ /* Copy as many bytes as will fit */
+ if (n != 0 && --n != 0) {
+ do {
+ if ((*d++ = *s++) == 0)
+ break;
+ } while (--n != 0);
}
- // -game <gamedir>
- // Adds basedir/gamedir as an override game
- i = COM_CheckParm ("-game");
- if (i && i < com_argc-1)
- {
- com_modified = true;
- COM_AddGameDirectory (va("%s/%s", com_basedir, com_argv[i+1]));
+ /* Not enough room in dst, add NUL and traverse rest of src */
+ if (n == 0) {
+ if (siz != 0)
+ *d = '\0'; /* NUL-terminate dst */
+ while (*s++)
+ ;
}
- // -path <dir or packfile> [<dir or packfile>] ...
- // Fully specifies the exact search path, overriding the generated one
- i = COM_CheckParm ("-path");
- if (i)
- {
- com_modified = true;
- com_searchpaths = NULL;
- while (++i < com_argc)
- {
- if (!com_argv[i] || com_argv[i][0] == '+' || com_argv[i][0] == '-')
- break;
-
- search = Mem_Alloc(pak_mempool, sizeof(searchpath_t));
- if ( !strcmp(COM_FileExtension(com_argv[i]), "pak") )
- {
- search->pack = COM_LoadPackFile (com_argv[i]);
- if (!search->pack)
- Sys_Error ("Couldn't load packfile: %s", com_argv[i]);
- }
- else
- strcpy (search->filename, com_argv[i]);
- search->next = com_searchpaths;
- com_searchpaths = search;
- }
- }
+ return(s - src - 1); /* count does not include NUL */
}
-int COM_FileExists(char *filename)
+#endif // #ifndef HAVE_STRLCPY
+
+void FindFraction(double val, int *num, int *denom, int denomMax)
{
- searchpath_t *search;
- char netpath[MAX_OSPATH];
- pack_t *pak;
- int i;
- int findtime;
+ int i;
+ double bestdiff;
+ // initialize
+ bestdiff = fabs(val);
+ *num = 0;
+ *denom = 1;
- for (search = com_searchpaths;search;search = search->next)
+ for(i = 1; i <= denomMax; ++i)
{
- if (search->pack)
+ int inum = (int) floor(0.5 + val * i);
+ double diff = fabs(val - inum / (double)i);
+ if(diff < bestdiff)
{
- pak = search->pack;
- for (i = 0;i < pak->numfiles;i++)
- if (!strcmp (pak->files[i].name, filename))
- return true;
+ bestdiff = diff;
+ *num = inum;
+ *denom = i;
}
- else
- {
- sprintf (netpath, "%s/%s",search->filename, filename);
- findtime = Sys_FileTime (netpath);
- if (findtime != -1)
- return true;
- }
}
-
- return false;
}
+// decodes an XPM from C syntax
+char **XPM_DecodeString(const char *in)
+{
+ static char *tokens[257];
+ static char lines[257][512];
+ size_t line = 0;
-//======================================
-// LordHavoc: added these because they are useful
+ // skip until "{" token
+ while(COM_ParseToken_QuakeC(&in, false) && strcmp(com_token, "{"));
-void COM_ToLowerString(char *in, char *out)
-{
- while (*in)
+ // now, read in succession: string, comma-or-}
+ while(COM_ParseToken_QuakeC(&in, false))
{
- if (*in >= 'A' && *in <= 'Z')
- *out++ = *in++ + 'a' - 'A';
- else
- *out++ = *in++;
+ tokens[line] = lines[line];
+ strlcpy(lines[line++], com_token, sizeof(lines[0]));
+ if(!COM_ParseToken_QuakeC(&in, false))
+ return NULL;
+ if(!strcmp(com_token, "}"))
+ break;
+ if(strcmp(com_token, ","))
+ return NULL;
+ if(line >= sizeof(tokens) / sizeof(tokens[0]))
+ return NULL;
}
+
+ return tokens;
}
-void COM_ToUpperString(char *in, char *out)
+static const char base64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+static void base64_3to4(const unsigned char *in, unsigned char *out, int bytes)
{
- while (*in)
- {
- if (*in >= 'a' && *in <= 'z')
- *out++ = *in++ + 'A' - 'a';
- else
- *out++ = *in++;
- }
+ unsigned char i0 = (bytes > 0) ? in[0] : 0;
+ unsigned char i1 = (bytes > 1) ? in[1] : 0;
+ unsigned char i2 = (bytes > 2) ? in[2] : 0;
+ unsigned char o0 = base64[i0 >> 2];
+ unsigned char o1 = base64[((i0 << 4) | (i1 >> 4)) & 077];
+ unsigned char o2 = base64[((i1 << 2) | (i2 >> 6)) & 077];
+ unsigned char o3 = base64[i2 & 077];
+ out[0] = (bytes > 0) ? o0 : '?';
+ out[1] = (bytes > 0) ? o1 : '?';
+ out[2] = (bytes > 1) ? o2 : '=';
+ out[3] = (bytes > 2) ? o3 : '=';
}
-int COM_StringBeginsWith(const char *s, const char *match)
+size_t base64_encode(unsigned char *buf, size_t buflen, size_t outbuflen)
{
- for (;*s && *match;s++, match++)
- if (*s != *match)
- return false;
- return true;
+ size_t blocks, i;
+ // expand the out-buffer
+ blocks = (buflen + 2) / 3;
+ if(blocks*4 > outbuflen)
+ return 0;
+ for(i = blocks; i > 0; )
+ {
+ --i;
+ base64_3to4(buf + 3*i, buf + 4*i, (int)(buflen - 3*i));
+ }
+ return blocks * 4;
}
-
projects / xonotic / darkplaces.git / blobdiff