df8bbcc9a333ee98de579b63b3523389c5a2f81d
[xonotic/darkplaces.git] / common.c
1 /*
2 Copyright (C) 1996-1997 Id Software, Inc.
3
4 This program is free software; you can redistribute it and/or
5 modify it under the terms of the GNU General Public License
6 as published by the Free Software Foundation; either version 2
7 of the License, or (at your option) any later version.
8
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
12
13 See the GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
18
19 */
20 // common.c -- misc functions used in client and server
21
22 #include <stdlib.h>
23 #include <fcntl.h>
24 #ifndef WIN32
25 #include <unistd.h>
26 #endif
27
28 #include "quakedef.h"
29
30 cvar_t registered = {0, "registered","0"};
31 cvar_t cmdline = {0, "cmdline","0"};
32
33 extern qboolean fs_modified;   // set true if using non-id files
34
35 char com_token[1024];
36 int com_argc;
37 const char **com_argv;
38
39 // LordHavoc: made commandline 1024 characters instead of 256
40 #define CMDLINE_LENGTH  1024
41 char com_cmdline[CMDLINE_LENGTH];
42
43 gamemode_t gamemode;
44 const char *gamename;
45 const char *gamedirname1;
46 const char *gamedirname2;
47 const char *gamescreenshotname;
48 const char *gameuserdirname;
49 char com_modname[MAX_OSPATH] = "";
50
51
52 /*
53 ============================================================================
54
55                                         BYTE ORDER FUNCTIONS
56
57 ============================================================================
58 */
59
60 short   ShortSwap (short l)
61 {
62         qbyte    b1,b2;
63
64         b1 = l&255;
65         b2 = (l>>8)&255;
66
67         return (b1<<8) + b2;
68 }
69
70 int    LongSwap (int l)
71 {
72         qbyte    b1,b2,b3,b4;
73
74         b1 = l&255;
75         b2 = (l>>8)&255;
76         b3 = (l>>16)&255;
77         b4 = (l>>24)&255;
78
79         return ((int)b1<<24) + ((int)b2<<16) + ((int)b3<<8) + b4;
80 }
81
82 float FloatSwap (float f)
83 {
84         union
85         {
86                 float   f;
87                 qbyte    b[4];
88         } dat1, dat2;
89
90
91         dat1.f = f;
92         dat2.b[0] = dat1.b[3];
93         dat2.b[1] = dat1.b[2];
94         dat2.b[2] = dat1.b[1];
95         dat2.b[3] = dat1.b[0];
96         return dat2.f;
97 }
98
99
100 // Extract integers from buffers
101
102 unsigned int BuffBigLong (const qbyte *buffer)
103 {
104         return (buffer[0] << 24) | (buffer[1] << 16) | (buffer[2] << 8) | buffer[3];
105 }
106
107 unsigned short BuffBigShort (const qbyte *buffer)
108 {
109         return (buffer[0] << 8) | buffer[1];
110 }
111
112 unsigned int BuffLittleLong (const qbyte *buffer)
113 {
114         return (buffer[3] << 24) | (buffer[2] << 16) | (buffer[1] << 8) | buffer[0];
115 }
116
117 unsigned short BuffLittleShort (const qbyte *buffer)
118 {
119         return (buffer[1] << 8) | buffer[0];
120 }
121
122
123 /*
124 ============================================================================
125
126                                         CRC FUNCTIONS
127
128 ============================================================================
129 */
130
131 // this is a 16 bit, non-reflected CRC using the polynomial 0x1021
132 // and the initial and final xor values shown below...  in other words, the
133 // CCITT standard CRC used by XMODEM
134
135 #define CRC_INIT_VALUE  0xffff
136 #define CRC_XOR_VALUE   0x0000
137
138 static unsigned short crctable[256] =
139 {
140         0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7,
141         0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef,
142         0x1231, 0x0210, 0x3273, 0x2252, 0x52b5, 0x4294, 0x72f7, 0x62d6,
143         0x9339, 0x8318, 0xb37b, 0xa35a, 0xd3bd, 0xc39c, 0xf3ff, 0xe3de,
144         0x2462, 0x3443, 0x0420, 0x1401, 0x64e6, 0x74c7, 0x44a4, 0x5485,
145         0xa56a, 0xb54b, 0x8528, 0x9509, 0xe5ee, 0xf5cf, 0xc5ac, 0xd58d,
146         0x3653, 0x2672, 0x1611, 0x0630, 0x76d7, 0x66f6, 0x5695, 0x46b4,
147         0xb75b, 0xa77a, 0x9719, 0x8738, 0xf7df, 0xe7fe, 0xd79d, 0xc7bc,
148         0x48c4, 0x58e5, 0x6886, 0x78a7, 0x0840, 0x1861, 0x2802, 0x3823,
149         0xc9cc, 0xd9ed, 0xe98e, 0xf9af, 0x8948, 0x9969, 0xa90a, 0xb92b,
150         0x5af5, 0x4ad4, 0x7ab7, 0x6a96, 0x1a71, 0x0a50, 0x3a33, 0x2a12,
151         0xdbfd, 0xcbdc, 0xfbbf, 0xeb9e, 0x9b79, 0x8b58, 0xbb3b, 0xab1a,
152         0x6ca6, 0x7c87, 0x4ce4, 0x5cc5, 0x2c22, 0x3c03, 0x0c60, 0x1c41,
153         0xedae, 0xfd8f, 0xcdec, 0xddcd, 0xad2a, 0xbd0b, 0x8d68, 0x9d49,
154         0x7e97, 0x6eb6, 0x5ed5, 0x4ef4, 0x3e13, 0x2e32, 0x1e51, 0x0e70,
155         0xff9f, 0xefbe, 0xdfdd, 0xcffc, 0xbf1b, 0xaf3a, 0x9f59, 0x8f78,
156         0x9188, 0x81a9, 0xb1ca, 0xa1eb, 0xd10c, 0xc12d, 0xf14e, 0xe16f,
157         0x1080, 0x00a1, 0x30c2, 0x20e3, 0x5004, 0x4025, 0x7046, 0x6067,
158         0x83b9, 0x9398, 0xa3fb, 0xb3da, 0xc33d, 0xd31c, 0xe37f, 0xf35e,
159         0x02b1, 0x1290, 0x22f3, 0x32d2, 0x4235, 0x5214, 0x6277, 0x7256,
160         0xb5ea, 0xa5cb, 0x95a8, 0x8589, 0xf56e, 0xe54f, 0xd52c, 0xc50d,
161         0x34e2, 0x24c3, 0x14a0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
162         0xa7db, 0xb7fa, 0x8799, 0x97b8, 0xe75f, 0xf77e, 0xc71d, 0xd73c,
163         0x26d3, 0x36f2, 0x0691, 0x16b0, 0x6657, 0x7676, 0x4615, 0x5634,
164         0xd94c, 0xc96d, 0xf90e, 0xe92f, 0x99c8, 0x89e9, 0xb98a, 0xa9ab,
165         0x5844, 0x4865, 0x7806, 0x6827, 0x18c0, 0x08e1, 0x3882, 0x28a3,
166         0xcb7d, 0xdb5c, 0xeb3f, 0xfb1e, 0x8bf9, 0x9bd8, 0xabbb, 0xbb9a,
167         0x4a75, 0x5a54, 0x6a37, 0x7a16, 0x0af1, 0x1ad0, 0x2ab3, 0x3a92,
168         0xfd2e, 0xed0f, 0xdd6c, 0xcd4d, 0xbdaa, 0xad8b, 0x9de8, 0x8dc9,
169         0x7c26, 0x6c07, 0x5c64, 0x4c45, 0x3ca2, 0x2c83, 0x1ce0, 0x0cc1,
170         0xef1f, 0xff3e, 0xcf5d, 0xdf7c, 0xaf9b, 0xbfba, 0x8fd9, 0x9ff8,
171         0x6e17, 0x7e36, 0x4e55, 0x5e74, 0x2e93, 0x3eb2, 0x0ed1, 0x1ef0
172 };
173
174 unsigned short CRC_Block(const qbyte *data, size_t size)
175 {
176         unsigned short crc = CRC_INIT_VALUE;
177         while (size--)
178                 crc = (crc << 8) ^ crctable[(crc >> 8) ^ (*data++)];
179         return crc ^ CRC_XOR_VALUE;
180 }
181
182
183 /*
184 ==============================================================================
185
186                         MESSAGE IO FUNCTIONS
187
188 Handles byte ordering and avoids alignment errors
189 ==============================================================================
190 */
191
192 //
193 // writing functions
194 //
195
196 void MSG_WriteChar (sizebuf_t *sb, int c)
197 {
198         qbyte    *buf;
199
200         buf = SZ_GetSpace (sb, 1);
201         buf[0] = c;
202 }
203
204 void MSG_WriteByte (sizebuf_t *sb, int c)
205 {
206         qbyte    *buf;
207
208         buf = SZ_GetSpace (sb, 1);
209         buf[0] = c;
210 }
211
212 void MSG_WriteShort (sizebuf_t *sb, int c)
213 {
214         qbyte    *buf;
215
216         buf = SZ_GetSpace (sb, 2);
217         buf[0] = c&0xff;
218         buf[1] = c>>8;
219 }
220
221 void MSG_WriteLong (sizebuf_t *sb, int c)
222 {
223         qbyte    *buf;
224
225         buf = SZ_GetSpace (sb, 4);
226         buf[0] = c&0xff;
227         buf[1] = (c>>8)&0xff;
228         buf[2] = (c>>16)&0xff;
229         buf[3] = c>>24;
230 }
231
232 void MSG_WriteFloat (sizebuf_t *sb, float f)
233 {
234         union
235         {
236                 float   f;
237                 int     l;
238         } dat;
239
240
241         dat.f = f;
242         dat.l = LittleLong (dat.l);
243
244         SZ_Write (sb, &dat.l, 4);
245 }
246
247 void MSG_WriteString (sizebuf_t *sb, const char *s)
248 {
249         if (!s)
250                 SZ_Write (sb, "", 1);
251         else
252                 SZ_Write (sb, s, (int)strlen(s)+1);
253 }
254
255 void MSG_WriteUnterminatedString (sizebuf_t *sb, const char *s)
256 {
257         if (s)
258                 SZ_Write (sb, s, (int)strlen(s));
259 }
260
261 void MSG_WriteCoord13i (sizebuf_t *sb, float f)
262 {
263         if (f >= 0)
264                 MSG_WriteShort (sb, (int)(f * 8.0 + 0.5));
265         else
266                 MSG_WriteShort (sb, (int)(f * 8.0 - 0.5));
267 }
268
269 void MSG_WriteCoord16i (sizebuf_t *sb, float f)
270 {
271         if (f >= 0)
272                 MSG_WriteShort (sb, (int)(f + 0.5));
273         else
274                 MSG_WriteShort (sb, (int)(f - 0.5));
275 }
276
277 void MSG_WriteCoord32f (sizebuf_t *sb, float f)
278 {
279         MSG_WriteFloat (sb, f);
280 }
281
282 void MSG_WriteCoord (sizebuf_t *sb, float f, protocolversion_t protocol)
283 {
284         if (protocol == PROTOCOL_QUAKE || protocol == PROTOCOL_QUAKEDP || protocol == PROTOCOL_NEHAHRAMOVIE)
285                 MSG_WriteCoord13i (sb, f);
286         else if (protocol == PROTOCOL_DARKPLACES1)
287                 MSG_WriteCoord32f (sb, f);
288         else if (protocol == PROTOCOL_DARKPLACES2 || protocol == PROTOCOL_DARKPLACES3 || protocol == PROTOCOL_DARKPLACES4)
289                 MSG_WriteCoord16i (sb, f);
290         else
291                 MSG_WriteCoord32f (sb, f);
292 }
293
294 void MSG_WriteVector (sizebuf_t *sb, float *v, protocolversion_t protocol)
295 {
296         MSG_WriteCoord (sb, v[0], protocol);
297         MSG_WriteCoord (sb, v[1], protocol);
298         MSG_WriteCoord (sb, v[2], protocol);
299 }
300
301 // LordHavoc: round to nearest value, rather than rounding toward zero, fixes crosshair problem
302 void MSG_WriteAngle8i (sizebuf_t *sb, float f)
303 {
304         if (f >= 0)
305                 MSG_WriteByte (sb, (int)(f*(256.0/360.0) + 0.5) & 255);
306         else
307                 MSG_WriteByte (sb, (int)(f*(256.0/360.0) - 0.5) & 255);
308 }
309
310 void MSG_WriteAngle16i (sizebuf_t *sb, float f)
311 {
312         if (f >= 0)
313                 MSG_WriteShort (sb, (int)(f*(65536.0/360.0) + 0.5) & 65535);
314         else
315                 MSG_WriteShort (sb, (int)(f*(65536.0/360.0) - 0.5) & 65535);
316 }
317
318 void MSG_WriteAngle32f (sizebuf_t *sb, float f)
319 {
320         MSG_WriteFloat (sb, f);
321 }
322
323 void MSG_WriteAngle (sizebuf_t *sb, float f, protocolversion_t protocol)
324 {
325         if (protocol == PROTOCOL_QUAKE || protocol == PROTOCOL_QUAKEDP || protocol == PROTOCOL_NEHAHRAMOVIE || protocol == PROTOCOL_DARKPLACES1 || protocol == PROTOCOL_DARKPLACES2 || protocol == PROTOCOL_DARKPLACES3 || protocol == PROTOCOL_DARKPLACES4)
326                 MSG_WriteAngle8i (sb, f);
327         else
328                 MSG_WriteAngle16i (sb, f);
329 }
330
331 //
332 // reading functions
333 //
334 int msg_readcount;
335 qboolean msg_badread;
336
337 void MSG_BeginReading (void)
338 {
339         msg_readcount = 0;
340         msg_badread = false;
341 }
342
343 int MSG_ReadLittleShort (void)
344 {
345         if (msg_readcount+2 > net_message.cursize)
346         {
347                 msg_badread = true;
348                 return -1;
349         }
350         msg_readcount += 2;
351         return (short)(net_message.data[msg_readcount-2] | (net_message.data[msg_readcount-1]<<8));
352 }
353
354 int MSG_ReadBigShort (void)
355 {
356         if (msg_readcount+2 > net_message.cursize)
357         {
358                 msg_badread = true;
359                 return -1;
360         }
361         msg_readcount += 2;
362         return (short)((net_message.data[msg_readcount-2]<<8) + net_message.data[msg_readcount-1]);
363 }
364
365 int MSG_ReadLittleLong (void)
366 {
367         if (msg_readcount+4 > net_message.cursize)
368         {
369                 msg_badread = true;
370                 return -1;
371         }
372         msg_readcount += 4;
373         return net_message.data[msg_readcount-4] | (net_message.data[msg_readcount-3]<<8) | (net_message.data[msg_readcount-2]<<16) | (net_message.data[msg_readcount-1]<<24);
374 }
375
376 int MSG_ReadBigLong (void)
377 {
378         if (msg_readcount+4 > net_message.cursize)
379         {
380                 msg_badread = true;
381                 return -1;
382         }
383         msg_readcount += 4;
384         return (net_message.data[msg_readcount-4]<<24) + (net_message.data[msg_readcount-3]<<16) + (net_message.data[msg_readcount-2]<<8) + net_message.data[msg_readcount-1];
385 }
386
387 float MSG_ReadLittleFloat (void)
388 {
389         union
390         {
391                 float f;
392                 int l;
393         } dat;
394         if (msg_readcount+4 > net_message.cursize)
395         {
396                 msg_badread = true;
397                 return -1;
398         }
399         msg_readcount += 4;
400         dat.l = net_message.data[msg_readcount-4] | (net_message.data[msg_readcount-3]<<8) | (net_message.data[msg_readcount-2]<<16) | (net_message.data[msg_readcount-1]<<24);
401         return dat.f;
402 }
403
404 float MSG_ReadBigFloat (void)
405 {
406         union
407         {
408                 float f;
409                 int l;
410         } dat;
411         if (msg_readcount+4 > net_message.cursize)
412         {
413                 msg_badread = true;
414                 return -1;
415         }
416         msg_readcount += 4;
417         dat.l = (net_message.data[msg_readcount-4]<<24) | (net_message.data[msg_readcount-3]<<16) | (net_message.data[msg_readcount-2]<<8) | net_message.data[msg_readcount-1];
418         return dat.f;
419 }
420
421 char *MSG_ReadString (void)
422 {
423         static char string[2048];
424         int l,c;
425         for (l = 0;l < (int) sizeof(string) - 1 && (c = MSG_ReadChar()) != -1 && c != 0;l++)
426                 string[l] = c;
427         string[l] = 0;
428         return string;
429 }
430
431 int MSG_ReadBytes (int numbytes, unsigned char *out)
432 {
433         int l, c;
434         for (l = 0;l < numbytes && (c = MSG_ReadChar()) != -1;l++)
435                 out[l] = c;
436         return l;
437 }
438
439 float MSG_ReadCoord13i (void)
440 {
441         return MSG_ReadLittleShort() * (1.0/8.0);
442 }
443
444 float MSG_ReadCoord16i (void)
445 {
446         return (signed short) MSG_ReadLittleShort();
447 }
448
449 float MSG_ReadCoord32f (void)
450 {
451         return MSG_ReadLittleFloat();
452 }
453
454 float MSG_ReadCoord (protocolversion_t protocol)
455 {
456         if (protocol == PROTOCOL_QUAKE || protocol == PROTOCOL_QUAKEDP || protocol == PROTOCOL_NEHAHRAMOVIE)
457                 return MSG_ReadCoord13i();
458         else if (protocol == PROTOCOL_DARKPLACES1)
459                 return MSG_ReadCoord32f();
460         else if (protocol == PROTOCOL_DARKPLACES2 || protocol == PROTOCOL_DARKPLACES3 || protocol == PROTOCOL_DARKPLACES4)
461                 return MSG_ReadCoord16i();
462         else
463                 return MSG_ReadCoord32f();
464 }
465
466 void MSG_ReadVector (float *v, protocolversion_t protocol)
467 {
468         v[0] = MSG_ReadCoord(protocol);
469         v[1] = MSG_ReadCoord(protocol);
470         v[2] = MSG_ReadCoord(protocol);
471 }
472
473 // LordHavoc: round to nearest value, rather than rounding toward zero, fixes crosshair problem
474 float MSG_ReadAngle8i (void)
475 {
476         return (signed char) MSG_ReadByte () * (360.0/256.0);
477 }
478
479 float MSG_ReadAngle16i (void)
480 {
481         return (signed short)MSG_ReadShort () * (360.0/65536.0);
482 }
483
484 float MSG_ReadAngle32f (void)
485 {
486         return MSG_ReadFloat ();
487 }
488
489 float MSG_ReadAngle (protocolversion_t protocol)
490 {
491         if (protocol == PROTOCOL_QUAKE || protocol == PROTOCOL_QUAKEDP || protocol == PROTOCOL_NEHAHRAMOVIE || protocol == PROTOCOL_DARKPLACES1 || protocol == PROTOCOL_DARKPLACES2 || protocol == PROTOCOL_DARKPLACES3 || protocol == PROTOCOL_DARKPLACES4)
492                 return MSG_ReadAngle8i ();
493         else
494                 return MSG_ReadAngle16i ();
495 }
496
497
498 //===========================================================================
499
500 void SZ_Clear (sizebuf_t *buf)
501 {
502         buf->cursize = 0;
503 }
504
505 void *SZ_GetSpace (sizebuf_t *buf, int length)
506 {
507         void *data;
508
509         if (buf->cursize + length > buf->maxsize)
510         {
511                 if (!buf->allowoverflow)
512                         Host_Error ("SZ_GetSpace: overflow without allowoverflow set\n");
513
514                 if (length > buf->maxsize)
515                         Host_Error ("SZ_GetSpace: %i is > full buffer size\n", length);
516
517                 buf->overflowed = true;
518                 Con_Print("SZ_GetSpace: overflow\n");
519                 SZ_Clear (buf);
520         }
521
522         data = buf->data + buf->cursize;
523         buf->cursize += length;
524
525         return data;
526 }
527
528 void SZ_Write (sizebuf_t *buf, const void *data, int length)
529 {
530         memcpy (SZ_GetSpace(buf,length),data,length);
531 }
532
533 // LordHavoc: thanks to Fuh for bringing the pure evil of SZ_Print to my
534 // attention, it has been eradicated from here, its only (former) use in
535 // all of darkplaces.
536
537 static char *hexchar = "0123456789ABCDEF";
538 void Com_HexDumpToConsole(const qbyte *data, int size)
539 {
540         int i, j, n;
541         char text[1024];
542         char *cur, *flushpointer;
543         const qbyte *d;
544         cur = text;
545         flushpointer = text + 512;
546         for (i = 0;i < size;)
547         {
548                 n = 16;
549                 if (n > size - i)
550                         n = size - i;
551                 d = data + i;
552                 // print offset
553                 *cur++ = hexchar[(i >> 12) & 15];
554                 *cur++ = hexchar[(i >>  8) & 15];
555                 *cur++ = hexchar[(i >>  4) & 15];
556                 *cur++ = hexchar[(i >>  0) & 15];
557                 *cur++ = ':';
558                 // print hex
559                 for (j = 0;j < 16;j++)
560                 {
561                         if (j < n)
562                         {
563                                 *cur++ = hexchar[(d[j] >> 4) & 15];
564                                 *cur++ = hexchar[(d[j] >> 0) & 15];
565                         }
566                         else
567                         {
568                                 *cur++ = ' ';
569                                 *cur++ = ' ';
570                         }
571                         if ((j & 3) == 3)
572                                 *cur++ = ' ';
573                 }
574                 // print text
575                 for (j = 0;j < 16;j++)
576                 {
577                         if (j < n)
578                         {
579                                 if (d[j] >= ' ' && d[j] <= 127)
580                                         *cur++ = d[j];
581                                 else
582                                         *cur++ = '.';
583                         }
584                         else
585                                 *cur++ = ' ';
586                 }
587                 *cur++ = '\n';
588                 i += n;
589                 if (cur >= flushpointer || i >= size)
590                 {
591                         *cur++ = 0;
592                         Con_Print(text);
593                         cur = text;
594                 }
595         }
596 }
597
598 void SZ_HexDumpToConsole(const sizebuf_t *buf)
599 {
600         Com_HexDumpToConsole(buf->data, buf->cursize);
601 }
602
603
604 //============================================================================
605
606
607 /*
608 ==============
609 COM_ParseToken
610
611 Parse a token out of a string
612 ==============
613 */
614 int COM_ParseToken(const char **datapointer, int returnnewline)
615 {
616         int len;
617         const char *data = *datapointer;
618
619         len = 0;
620         com_token[0] = 0;
621
622         if (!data)
623         {
624                 *datapointer = NULL;
625                 return false;
626         }
627
628 // skip whitespace
629 skipwhite:
630         // line endings:
631         // UNIX: \n
632         // Mac: \r
633         // Windows: \r\n
634         for (;*data <= ' ' && ((*data != '\n' && *data != '\r') || !returnnewline);data++)
635         {
636                 if (*data == 0)
637                 {
638                         // end of file
639                         *datapointer = NULL;
640                         return false;
641                 }
642         }
643
644         // handle Windows line ending
645         if (data[0] == '\r' && data[1] == '\n')
646                 data++;
647
648         if (data[0] == '/' && data[1] == '/')
649         {
650                 // comment
651                 while (*data && *data != '\n' && *data != '\r')
652                         data++;
653                 goto skipwhite;
654         }
655         else if (data[0] == '/' && data[1] == '*')
656         {
657                 // comment
658                 data++;
659                 while (*data && (data[0] != '*' || data[1] != '/'))
660                         data++;
661                 data += 2;
662                 goto skipwhite;
663         }
664         else if (*data == '\"')
665         {
666                 // quoted string
667                 for (data++;*data != '\"';data++)
668                 {
669                         if (*data == '\\' && data[1] == '"' )
670                                 data++;
671                         if (!*data || len >= (int)sizeof(com_token) - 1)
672                         {
673                                 com_token[0] = 0;
674                                 *datapointer = NULL;
675                                 return false;
676                         }
677                         com_token[len++] = *data;
678                 }
679                 com_token[len] = 0;
680                 *datapointer = data+1;
681                 return true;
682         }
683         else if (*data == '\'')
684         {
685                 // quoted string
686                 for (data++;*data != '\'';data++)
687                 {
688                         if (*data == '\\' && data[1] == '\'' )
689                                 data++;
690                         if (!*data || len >= (int)sizeof(com_token) - 1)
691                         {
692                                 com_token[0] = 0;
693                                 *datapointer = NULL;
694                                 return false;
695                         }
696                         com_token[len++] = *data;
697                 }
698                 com_token[len] = 0;
699                 *datapointer = data+1;
700                 return true;
701         }
702         else if (*data == '\r')
703         {
704                 // translate Mac line ending to UNIX
705                 com_token[len++] = '\n';
706                 com_token[len] = 0;
707                 *datapointer = data;
708                 return true;
709         }
710         else if (*data == '\n' || *data == '{' || *data == '}' || *data == ')' || *data == '(' || *data == ']' || *data == '[' || *data == '\'' || *data == ':' || *data == ',' || *data == ';')
711         {
712                 // single character
713                 com_token[len++] = *data++;
714                 com_token[len] = 0;
715                 *datapointer = data;
716                 return true;
717         }
718         else
719         {
720                 // regular word
721                 for (;*data > ' ' && *data != '{' && *data != '}' && *data != ')' && *data != '(' && *data != ']' && *data != '[' && *data != '\'' && *data != ':' && *data != ',' && *data != ';' && *data != '\'' && *data != '"';data++)
722                 {
723                         if (len >= (int)sizeof(com_token) - 1)
724                         {
725                                 com_token[0] = 0;
726                                 *datapointer = NULL;
727                                 return false;
728                         }
729                         com_token[len++] = *data;
730                 }
731                 com_token[len] = 0;
732                 *datapointer = data;
733                 return true;
734         }
735 }
736
737 /*
738 ==============
739 COM_ParseTokenConsole
740
741 Parse a token out of a string, behaving like the qwcl console
742 ==============
743 */
744 int COM_ParseTokenConsole(const char **datapointer)
745 {
746         int len;
747         const char *data = *datapointer;
748
749         len = 0;
750         com_token[0] = 0;
751
752         if (!data)
753         {
754                 *datapointer = NULL;
755                 return false;
756         }
757
758 // skip whitespace
759 skipwhite:
760         for (;*data <= ' ';data++)
761         {
762                 if (*data == 0)
763                 {
764                         // end of file
765                         *datapointer = NULL;
766                         return false;
767                 }
768         }
769
770         if (*data == '/' && data[1] == '/')
771         {
772                 // comment
773                 while (*data && *data != '\n' && *data != '\r')
774                         data++;
775                 goto skipwhite;
776         }
777         else if (*data == '\"')
778         {
779                 // quoted string
780                 for (data++;*data != '\"';data++)
781                 {
782                         if (!*data || len >= (int)sizeof(com_token) - 1)
783                         {
784                                 com_token[0] = 0;
785                                 *datapointer = NULL;
786                                 return false;
787                         }
788                         com_token[len++] = *data;
789                 }
790                 com_token[len] = 0;
791                 *datapointer = data+1;
792         }
793         else
794         {
795                 // regular word
796                 for (;*data > ' ';data++)
797                 {
798                         if (len >= (int)sizeof(com_token) - 1)
799                         {
800                                 com_token[0] = 0;
801                                 *datapointer = NULL;
802                                 return false;
803                         }
804                         com_token[len++] = *data;
805                 }
806                 com_token[len] = 0;
807                 *datapointer = data;
808         }
809
810         return true;
811 }
812
813
814 /*
815 ================
816 COM_CheckParm
817
818 Returns the position (1 to argc-1) in the program's argument list
819 where the given parameter apears, or 0 if not present
820 ================
821 */
822 int COM_CheckParm (const char *parm)
823 {
824         int i;
825
826         for (i=1 ; i<com_argc ; i++)
827         {
828                 if (!com_argv[i])
829                         continue;               // NEXTSTEP sometimes clears appkit vars.
830                 if (!strcmp (parm,com_argv[i]))
831                         return i;
832         }
833
834         return 0;
835 }
836
837 /*
838 ================
839 COM_CheckRegistered
840
841 Looks for the pop.txt file and verifies it.
842 Sets the "registered" cvar.
843 Immediately exits out if an alternate game was attempted to be started without
844 being registered.
845 ================
846 */
847 void COM_CheckRegistered (void)
848 {
849         Cvar_Set ("cmdline", com_cmdline);
850
851         if (gamemode == GAME_NORMAL && !FS_FileExists("gfx/pop.lmp"))
852         {
853                 if (fs_modified)
854                         Con_Print("Playing shareware version, with modification.\nwarning: most mods require full quake data.\n");
855                 else
856                         Con_Print("Playing shareware version.\n");
857                 return;
858         }
859
860         Cvar_Set ("registered", "1");
861         Con_Print("Playing registered version.\n");
862 }
863
864
865 /*
866 ================
867 COM_InitArgv
868 ================
869 */
870 void COM_InitArgv (void)
871 {
872         int i, j, n;
873         // reconstitute the command line for the cmdline externally visible cvar
874         n = 0;
875         for (j = 0;(j < MAX_NUM_ARGVS) && (j < com_argc);j++)
876         {
877                 i = 0;
878                 if (strstr(com_argv[j], " "))
879                 {
880                         // arg contains whitespace, store quotes around it
881                         com_cmdline[n++] = '\"';
882                         while ((n < (CMDLINE_LENGTH - 1)) && com_argv[j][i])
883                                 com_cmdline[n++] = com_argv[j][i++];
884                         com_cmdline[n++] = '\"';
885                 }
886                 else
887                 {
888                         while ((n < (CMDLINE_LENGTH - 1)) && com_argv[j][i])
889                                 com_cmdline[n++] = com_argv[j][i++];
890                 }
891                 if (n < (CMDLINE_LENGTH - 1))
892                         com_cmdline[n++] = ' ';
893                 else
894                         break;
895         }
896         com_cmdline[n] = 0;
897 }
898
899
900 //===========================================================================
901
902 // Game mods
903
904 typedef struct
905 {
906         const char* prog_name;
907         const char* cmdline;
908         const char* gamename;
909         const char* gamedirname1;
910         const char* gamedirname2;
911         const char* gamescreenshotname;
912         const char* gameuserdirname;
913 } gamemode_info_t;
914
915 static const gamemode_info_t gamemode_info [] =
916 {// prog_name           cmdline                 gamename                                gamedirname     gamescreenshotname
917
918 // GAME_NORMAL
919 // COMMANDLINEOPTION: Game: -quake runs the game Quake (default)
920 { "",                           "-quake",               "DarkPlaces-Quake",             "id1",          NULL,                   "dp",                   "darkplaces" },
921 // GAME_HIPNOTIC
922 // COMMANDLINEOPTION: Game: -hipnotic runs Quake mission pack 1: The Scourge of Armagon
923 { "hipnotic",           "-hipnotic",    "Darkplaces-Hipnotic",  "id1",          "hipnotic",             "dp",                   "darkplaces" },
924 // GAME_ROGUE
925 // COMMANDLINEOPTION: Game: -rogue runs Quake mission pack 2: The Dissolution of Eternity
926 { "rogue",                      "-rogue",               "Darkplaces-Rogue",             "id1",          "rogue",                "dp",                   "darkplaces" },
927 // GAME_NEHAHRA
928 // COMMANDLINEOPTION: Game: -nehahra runs The Seal of Nehahra movie and game
929 { "nehahra",            "-nehahra",             "DarkPlaces-Nehahra",   "id1",          "nehahra",              "dp",                   "darkplaces" },
930 // GAME_NEXUIZ
931 // COMMANDLINEOPTION: Game: -nexuiz runs the multiplayer game Nexuiz
932 { "nexuiz",                     "-nexuiz",              "Nexuiz",                               "data",         NULL,                   "nexuiz",               "nexuiz" },
933 // GAME_TRANSFUSION
934 // COMMANDLINEOPTION: Game: -transfusion runs Transfusion (the recreation of Blood in Quake)
935 { "transfusion",        "-transfusion", "Transfusion",                  "basetf",       NULL,                   "transfusion",  "transfusion" },
936 // GAME_GOODVSBAD2
937 // COMMANDLINEOPTION: Game: -goodvsbad2 runs the psychadelic RTS FPS game Good Vs Bad 2
938 { "gvb2",                       "-goodvsbad2",  "GoodVs.Bad2",                  "rts",          NULL,                   "gvb2",                 "gvb2" },
939 // GAME_TEU
940 // COMMANDLINEOPTION: Game: -teu runs The Evil Unleashed (this option is obsolete as they are not using darkplaces)
941 { "teu",                        "-teu",                 "TheEvilUnleashed",             "baseteu",      NULL,                   "teu",                  "teu" },
942 // GAME_BATTLEMECH
943 // COMMANDLINEOPTION: Game: -battlemech runs the multiplayer topdown deathmatch game BattleMech
944 { "battlemech",         "-battlemech",  "Battlemech",                   "base",         NULL,                   "battlemech",   "battlemech" },
945 // GAME_ZYMOTIC
946 // COMMANDLINEOPTION: Game: -zymotic runs the singleplayer game Zymotic
947 { "zymotic",            "-zymotic",             "Zymotic",                              "data",         NULL,                   "zymotic",              "zymotic" },
948 // GAME_FNIGGIUM
949 // COMMANDLINEOPTION: Game: -fniggium runs the post apocalyptic melee RPG Fniggium
950 { "fniggium",           "-fniggium",    "Fniggium",                             "data",         NULL,                   "fniggium",             "fniggium" },
951 // GAME_SETHERAL
952 // COMMANDLINEOPTION: Game: -setheral runs the multiplayer game Setheral
953 { "setheral",           "-setheral",    "Setheral",                             "data",         NULL,                   "setheral",             "setheral" },
954 // GAME_SOM
955 // COMMANDLINEOPTION: Game: -som runs the multiplayer game Son Of Man
956 { "som",                        "-som",                 "Son of Man",                   "id1",          "sonofman",             "som",                  "darkplaces" },
957 // GAME_TENEBRAE
958 // COMMANDLINEOPTION: Game: -tenebrae runs the graphics test mod known as Tenebrae (some features not implemented)
959 { "tenebrae",           "-tenebrae",    "DarkPlaces-Tenebrae",  "id1",          "tenebrae",             "dp",                   "darkplaces" },
960 // GAME_NEOTERIC
961 // COMMANDLINEOPTION: Game: -neoteric runs the game Neoteric
962 { "neoteric",           "-neoteric",    "Neoteric",                             "id1",          "neobase",              "neo",                  "darkplaces" },
963 // GAME_OPENQUARTZ
964 // COMMANDLINEOPTION: Game: -openquartz runs the game OpenQuartz, a standalone GPL replacement of the quake content
965 { "openquartz",         "-openquartz",  "OpenQuartz",                   "id1",          NULL,                   "openquartz",   "darkplaces"},
966 // GAME_PRYDON
967 // COMMANDLINEOPTION: Game: -prydon runs the topdown point and click action-RPG Prydon Gate
968 { "prydon",                     "-prydon",              "PrydonGate",                   "id1",          "prydon",               "prydon",               "darkplaces"},
969 // GAME_NETHERWORLD
970 // COMMANDLINEOPTION: Game: -netherworld runs the game Netherworld: Dark Master
971 { "netherworld",        "-netherworld", "Netherworld: Dark Master",     "id1",          "netherworld",  "nw",                   "darkplaces"},
972 // GAME_THEHUNTED
973 // COMMANDLINEOPTION: Game: -thehunted runs the game The Hunted
974 { "thehunted",          "-thehunted",   "The Hunted",                   "thdata",       NULL,                   "th",                   "thehunted"},
975 };
976
977 void COM_InitGameType (void)
978 {
979         char name [MAX_OSPATH];
980         unsigned int i;
981
982         FS_StripExtension (com_argv[0], name, sizeof (name));
983         COM_ToLowerString (name, name, sizeof (name));
984
985         // Check the binary name; default to GAME_NORMAL (0)
986         gamemode = GAME_NORMAL;
987         for (i = 1; i < sizeof (gamemode_info) / sizeof (gamemode_info[0]); i++)
988                 if (strstr (name, gamemode_info[i].prog_name))
989                 {
990                         gamemode = i;
991                         break;
992                 }
993
994         // Look for a command-line option
995         for (i = 0; i < sizeof (gamemode_info) / sizeof (gamemode_info[0]); i++)
996                 if (COM_CheckParm (gamemode_info[i].cmdline))
997                 {
998                         gamemode = i;
999                         break;
1000                 }
1001
1002         gamename = gamemode_info[gamemode].gamename;
1003         gamedirname1 = gamemode_info[gamemode].gamedirname1;
1004         gamedirname2 = gamemode_info[gamemode].gamedirname2;
1005         gamescreenshotname = gamemode_info[gamemode].gamescreenshotname;
1006         gameuserdirname = gamemode_info[gamemode].gameuserdirname;
1007 }
1008
1009
1010 /*
1011 ================
1012 COM_Init
1013 ================
1014 */
1015 void COM_Init_Commands (void)
1016 {
1017         Cvar_RegisterVariable (&registered);
1018         Cvar_RegisterVariable (&cmdline);
1019 }
1020
1021 /*
1022 ============
1023 va
1024
1025 does a varargs printf into a temp buffer, so I don't need to have
1026 varargs versions of all text functions.
1027 FIXME: make this buffer size safe someday
1028 ============
1029 */
1030 char *va(const char *format, ...)
1031 {
1032         va_list argptr;
1033         // LordHavoc: now cycles through 8 buffers to avoid problems in most cases
1034         static char string[8][1024], *s;
1035         static int stringindex = 0;
1036
1037         s = string[stringindex];
1038         stringindex = (stringindex + 1) & 7;
1039         va_start (argptr, format);
1040         dpvsnprintf (s, sizeof (string[0]), format,argptr);
1041         va_end (argptr);
1042
1043         return s;
1044 }
1045
1046
1047 //======================================
1048
1049 // snprintf and vsnprintf are NOT portable. Use their DP counterparts instead
1050
1051 #undef snprintf
1052 #undef vsnprintf
1053
1054 #ifdef WIN32
1055 # define snprintf _snprintf
1056 # define vsnprintf _vsnprintf
1057 #endif
1058
1059
1060 int dpsnprintf (char *buffer, size_t buffersize, const char *format, ...)
1061 {
1062         va_list args;
1063         int result;
1064
1065         va_start (args, format);
1066         result = dpvsnprintf (buffer, buffersize, format, args);
1067         va_end (args);
1068
1069         return result;
1070 }
1071
1072
1073 int dpvsnprintf (char *buffer, size_t buffersize, const char *format, va_list args)
1074 {
1075         int result;
1076
1077         result = vsnprintf (buffer, buffersize, format, args);
1078         if (result < 0 || (size_t)result >= buffersize)
1079         {
1080                 buffer[buffersize - 1] = '\0';
1081                 return -1;
1082         }
1083
1084         return result;
1085 }
1086
1087
1088 //======================================
1089
1090 void COM_ToLowerString (const char *in, char *out, size_t size_out)
1091 {
1092         if (size_out == 0)
1093                 return;
1094
1095         while (*in && size_out > 1)
1096         {
1097                 if (*in >= 'A' && *in <= 'Z')
1098                         *out++ = *in++ + 'a' - 'A';
1099                 else
1100                         *out++ = *in++;
1101                 size_out--;
1102         }
1103         *out = '\0';
1104 }
1105
1106 void COM_ToUpperString (const char *in, char *out, size_t size_out)
1107 {
1108         if (size_out == 0)
1109                 return;
1110
1111         while (*in && size_out > 1)
1112         {
1113                 if (*in >= 'a' && *in <= 'z')
1114                         *out++ = *in++ + 'A' - 'a';
1115                 else
1116                         *out++ = *in++;
1117                 size_out--;
1118         }
1119         *out = '\0';
1120 }
1121
1122 int COM_StringBeginsWith(const char *s, const char *match)
1123 {
1124         for (;*s && *match;s++, match++)
1125                 if (*s != *match)
1126                         return false;
1127         return true;
1128 }
1129
1130 int COM_ReadAndTokenizeLine(const char **text, char **argv, int maxargc, char *tokenbuf, int tokenbufsize, const char *commentprefix)
1131 {
1132         int argc, commentprefixlength;
1133         char *tokenbufend;
1134         const char *l;
1135         argc = 0;
1136         tokenbufend = tokenbuf + tokenbufsize;
1137         l = *text;
1138         commentprefixlength = 0;
1139         if (commentprefix)
1140                 commentprefixlength = (int)strlen(commentprefix);
1141         while (*l && *l != '\n' && *l != '\r')
1142         {
1143                 if (*l > ' ')
1144                 {
1145                         if (commentprefixlength && !strncmp(l, commentprefix, commentprefixlength))
1146                         {
1147                                 while (*l && *l != '\n' && *l != '\r')
1148                                         l++;
1149                                 break;
1150                         }
1151                         if (argc >= maxargc)
1152                                 return -1;
1153                         argv[argc++] = tokenbuf;
1154                         if (*l == '"')
1155                         {
1156                                 l++;
1157                                 while (*l && *l != '"')
1158                                 {
1159                                         if (tokenbuf >= tokenbufend)
1160                                                 return -1;
1161                                         *tokenbuf++ = *l++;
1162                                 }
1163                                 if (*l == '"')
1164                                         l++;
1165                         }
1166                         else
1167                         {
1168                                 while (*l > ' ')
1169                                 {
1170                                         if (tokenbuf >= tokenbufend)
1171                                                 return -1;
1172                                         *tokenbuf++ = *l++;
1173                                 }
1174                         }
1175                         if (tokenbuf >= tokenbufend)
1176                                 return -1;
1177                         *tokenbuf++ = 0;
1178                 }
1179                 else
1180                         l++;
1181         }
1182         // line endings:
1183         // UNIX: \n
1184         // Mac: \r
1185         // Windows: \r\n
1186         if (*l == '\r')
1187                 l++;
1188         if (*l == '\n')
1189                 l++;
1190         *text = l;
1191         return argc;
1192 }
1193
1194 // written by Elric, thanks Elric!
1195 char *SearchInfostring(const char *infostring, const char *key)
1196 {
1197         static char value [256];
1198         char crt_key [256];
1199         size_t value_ind, key_ind;
1200         char c;
1201
1202         if (*infostring++ != '\\')
1203                 return NULL;
1204
1205         value_ind = 0;
1206         for (;;)
1207         {
1208                 key_ind = 0;
1209
1210                 // Get the key name
1211                 for (;;)
1212                 {
1213                         c = *infostring++;
1214
1215                         if (c == '\0')
1216                                 return NULL;
1217                         if (c == '\\' || key_ind == sizeof (crt_key) - 1)
1218                         {
1219                                 crt_key[key_ind] = '\0';
1220                                 break;
1221                         }
1222
1223                         crt_key[key_ind++] = c;
1224                 }
1225
1226                 // If it's the key we are looking for, save it in "value"
1227                 if (!strcmp(crt_key, key))
1228                 {
1229                         for (;;)
1230                         {
1231                                 c = *infostring++;
1232
1233                                 if (c == '\0' || c == '\\' || value_ind == sizeof (value) - 1)
1234                                 {
1235                                         value[value_ind] = '\0';
1236                                         return value;
1237                                 }
1238
1239                                 value[value_ind++] = c;
1240                         }
1241                 }
1242
1243                 // Else, skip the value
1244                 for (;;)
1245                 {
1246                         c = *infostring++;
1247
1248                         if (c == '\0')
1249                                 return NULL;
1250                         if (c == '\\')
1251                                 break;
1252                 }
1253         }
1254 }
1255
1256
1257 //========================================================
1258 // strlcat and strlcpy, from OpenBSD
1259
1260 /*
1261  * Copyright (c) 1998 Todd C. Miller <Todd.Miller@courtesan.com>
1262  *
1263  * Permission to use, copy, modify, and distribute this software for any
1264  * purpose with or without fee is hereby granted, provided that the above
1265  * copyright notice and this permission notice appear in all copies.
1266  *
1267  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
1268  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
1269  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
1270  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
1271  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
1272  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
1273  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
1274  */
1275
1276 /*      $OpenBSD: strlcat.c,v 1.11 2003/06/17 21:56:24 millert Exp $    */
1277 /*      $OpenBSD: strlcpy.c,v 1.8 2003/06/17 21:56:24 millert Exp $     */
1278
1279
1280 #ifndef HAVE_STRLCAT
1281 size_t
1282 strlcat(char *dst, const char *src, size_t siz)
1283 {
1284         register char *d = dst;
1285         register const char *s = src;
1286         register size_t n = siz;
1287         size_t dlen;
1288
1289         /* Find the end of dst and adjust bytes left but don't go past end */
1290         while (n-- != 0 && *d != '\0')
1291                 d++;
1292         dlen = d - dst;
1293         n = siz - dlen;
1294
1295         if (n == 0)
1296                 return(dlen + strlen(s));
1297         while (*s != '\0') {
1298                 if (n != 1) {
1299                         *d++ = *s;
1300                         n--;
1301                 }
1302                 s++;
1303         }
1304         *d = '\0';
1305
1306         return(dlen + (s - src));       /* count does not include NUL */
1307 }
1308 #endif  // #ifndef HAVE_STRLCAT
1309
1310
1311 #ifndef HAVE_STRLCPY
1312 size_t
1313 strlcpy(char *dst, const char *src, size_t siz)
1314 {
1315         register char *d = dst;
1316         register const char *s = src;
1317         register size_t n = siz;
1318
1319         /* Copy as many bytes as will fit */
1320         if (n != 0 && --n != 0) {
1321                 do {
1322                         if ((*d++ = *s++) == 0)
1323                                 break;
1324                 } while (--n != 0);
1325         }
1326
1327         /* Not enough room in dst, add NUL and traverse rest of src */
1328         if (n == 0) {
1329                 if (siz != 0)
1330                         *d = '\0';              /* NUL-terminate dst */
1331                 while (*s++)
1332                         ;
1333         }
1334
1335         return(s - src - 1);    /* count does not include NUL */
1336 }
1337
1338 #endif  // #ifndef HAVE_STRLCPY