334a31b12cabefc969afc63bce09700400d02a36
[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, (qbyte *)&dat.l, 4);
245 }
246
247 void MSG_WriteString (sizebuf_t *sb, const char *s)
248 {
249         if (!s)
250                 SZ_Write (sb, (qbyte *)"", 1);
251         else
252                 SZ_Write (sb, (qbyte *)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, (qbyte *)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 qbyte *SZ_GetSpace (sizebuf_t *buf, int length)
506 {
507         qbyte *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 qbyte *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",                              "basezym",              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 // GAME_DEFEATINDETAIL2
976 // COMMANDLINEOPTION: Game: -did2 runs the game Defeat In Detail 2
977 { "did2",                       "-did2",                "Defeat In Detail 2",   "data",         NULL,                   "did2_",                "did2" },
978 };
979
980 void COM_InitGameType (void)
981 {
982         char name [MAX_OSPATH];
983         unsigned int i;
984
985         FS_StripExtension (com_argv[0], name, sizeof (name));
986         COM_ToLowerString (name, name, sizeof (name));
987
988         // Check the binary name; default to GAME_NORMAL (0)
989         gamemode = GAME_NORMAL;
990         for (i = 1; i < sizeof (gamemode_info) / sizeof (gamemode_info[0]); i++)
991                 if (strstr (name, gamemode_info[i].prog_name))
992                 {
993                         gamemode = (gamemode_t)i;
994                         break;
995                 }
996
997         // Look for a command-line option
998         for (i = 0; i < sizeof (gamemode_info) / sizeof (gamemode_info[0]); i++)
999                 if (COM_CheckParm (gamemode_info[i].cmdline))
1000                 {
1001                         gamemode = (gamemode_t)i;
1002                         break;
1003                 }
1004
1005         gamename = gamemode_info[gamemode].gamename;
1006         gamedirname1 = gamemode_info[gamemode].gamedirname1;
1007         gamedirname2 = gamemode_info[gamemode].gamedirname2;
1008         gamescreenshotname = gamemode_info[gamemode].gamescreenshotname;
1009         gameuserdirname = gamemode_info[gamemode].gameuserdirname;
1010 }
1011
1012
1013 /*
1014 ================
1015 COM_Init
1016 ================
1017 */
1018 void COM_Init_Commands (void)
1019 {
1020         Cvar_RegisterVariable (&registered);
1021         Cvar_RegisterVariable (&cmdline);
1022 }
1023
1024 /*
1025 ============
1026 va
1027
1028 does a varargs printf into a temp buffer, so I don't need to have
1029 varargs versions of all text functions.
1030 FIXME: make this buffer size safe someday
1031 ============
1032 */
1033 char *va(const char *format, ...)
1034 {
1035         va_list argptr;
1036         // LordHavoc: now cycles through 8 buffers to avoid problems in most cases
1037         static char string[8][1024], *s;
1038         static int stringindex = 0;
1039
1040         s = string[stringindex];
1041         stringindex = (stringindex + 1) & 7;
1042         va_start (argptr, format);
1043         dpvsnprintf (s, sizeof (string[0]), format,argptr);
1044         va_end (argptr);
1045
1046         return s;
1047 }
1048
1049
1050 //======================================
1051
1052 // snprintf and vsnprintf are NOT portable. Use their DP counterparts instead
1053
1054 #undef snprintf
1055 #undef vsnprintf
1056
1057 #ifdef WIN32
1058 # define snprintf _snprintf
1059 # define vsnprintf _vsnprintf
1060 #endif
1061
1062
1063 int dpsnprintf (char *buffer, size_t buffersize, const char *format, ...)
1064 {
1065         va_list args;
1066         int result;
1067
1068         va_start (args, format);
1069         result = dpvsnprintf (buffer, buffersize, format, args);
1070         va_end (args);
1071
1072         return result;
1073 }
1074
1075
1076 int dpvsnprintf (char *buffer, size_t buffersize, const char *format, va_list args)
1077 {
1078         int result;
1079
1080         result = vsnprintf (buffer, buffersize, format, args);
1081         if (result < 0 || (size_t)result >= buffersize)
1082         {
1083                 buffer[buffersize - 1] = '\0';
1084                 return -1;
1085         }
1086
1087         return result;
1088 }
1089
1090
1091 //======================================
1092
1093 void COM_ToLowerString (const char *in, char *out, size_t size_out)
1094 {
1095         if (size_out == 0)
1096                 return;
1097
1098         while (*in && size_out > 1)
1099         {
1100                 if (*in >= 'A' && *in <= 'Z')
1101                         *out++ = *in++ + 'a' - 'A';
1102                 else
1103                         *out++ = *in++;
1104                 size_out--;
1105         }
1106         *out = '\0';
1107 }
1108
1109 void COM_ToUpperString (const char *in, char *out, size_t size_out)
1110 {
1111         if (size_out == 0)
1112                 return;
1113
1114         while (*in && size_out > 1)
1115         {
1116                 if (*in >= 'a' && *in <= 'z')
1117                         *out++ = *in++ + 'A' - 'a';
1118                 else
1119                         *out++ = *in++;
1120                 size_out--;
1121         }
1122         *out = '\0';
1123 }
1124
1125 int COM_StringBeginsWith(const char *s, const char *match)
1126 {
1127         for (;*s && *match;s++, match++)
1128                 if (*s != *match)
1129                         return false;
1130         return true;
1131 }
1132
1133 int COM_ReadAndTokenizeLine(const char **text, char **argv, int maxargc, char *tokenbuf, int tokenbufsize, const char *commentprefix)
1134 {
1135         int argc, commentprefixlength;
1136         char *tokenbufend;
1137         const char *l;
1138         argc = 0;
1139         tokenbufend = tokenbuf + tokenbufsize;
1140         l = *text;
1141         commentprefixlength = 0;
1142         if (commentprefix)
1143                 commentprefixlength = (int)strlen(commentprefix);
1144         while (*l && *l != '\n' && *l != '\r')
1145         {
1146                 if (*l > ' ')
1147                 {
1148                         if (commentprefixlength && !strncmp(l, commentprefix, commentprefixlength))
1149                         {
1150                                 while (*l && *l != '\n' && *l != '\r')
1151                                         l++;
1152                                 break;
1153                         }
1154                         if (argc >= maxargc)
1155                                 return -1;
1156                         argv[argc++] = tokenbuf;
1157                         if (*l == '"')
1158                         {
1159                                 l++;
1160                                 while (*l && *l != '"')
1161                                 {
1162                                         if (tokenbuf >= tokenbufend)
1163                                                 return -1;
1164                                         *tokenbuf++ = *l++;
1165                                 }
1166                                 if (*l == '"')
1167                                         l++;
1168                         }
1169                         else
1170                         {
1171                                 while (*l > ' ')
1172                                 {
1173                                         if (tokenbuf >= tokenbufend)
1174                                                 return -1;
1175                                         *tokenbuf++ = *l++;
1176                                 }
1177                         }
1178                         if (tokenbuf >= tokenbufend)
1179                                 return -1;
1180                         *tokenbuf++ = 0;
1181                 }
1182                 else
1183                         l++;
1184         }
1185         // line endings:
1186         // UNIX: \n
1187         // Mac: \r
1188         // Windows: \r\n
1189         if (*l == '\r')
1190                 l++;
1191         if (*l == '\n')
1192                 l++;
1193         *text = l;
1194         return argc;
1195 }
1196
1197 // written by Elric, thanks Elric!
1198 char *SearchInfostring(const char *infostring, const char *key)
1199 {
1200         static char value [256];
1201         char crt_key [256];
1202         size_t value_ind, key_ind;
1203         char c;
1204
1205         if (*infostring++ != '\\')
1206                 return NULL;
1207
1208         value_ind = 0;
1209         for (;;)
1210         {
1211                 key_ind = 0;
1212
1213                 // Get the key name
1214                 for (;;)
1215                 {
1216                         c = *infostring++;
1217
1218                         if (c == '\0')
1219                                 return NULL;
1220                         if (c == '\\' || key_ind == sizeof (crt_key) - 1)
1221                         {
1222                                 crt_key[key_ind] = '\0';
1223                                 break;
1224                         }
1225
1226                         crt_key[key_ind++] = c;
1227                 }
1228
1229                 // If it's the key we are looking for, save it in "value"
1230                 if (!strcmp(crt_key, key))
1231                 {
1232                         for (;;)
1233                         {
1234                                 c = *infostring++;
1235
1236                                 if (c == '\0' || c == '\\' || value_ind == sizeof (value) - 1)
1237                                 {
1238                                         value[value_ind] = '\0';
1239                                         return value;
1240                                 }
1241
1242                                 value[value_ind++] = c;
1243                         }
1244                 }
1245
1246                 // Else, skip the value
1247                 for (;;)
1248                 {
1249                         c = *infostring++;
1250
1251                         if (c == '\0')
1252                                 return NULL;
1253                         if (c == '\\')
1254                                 break;
1255                 }
1256         }
1257 }
1258
1259
1260 //========================================================
1261 // strlcat and strlcpy, from OpenBSD
1262
1263 /*
1264  * Copyright (c) 1998 Todd C. Miller <Todd.Miller@courtesan.com>
1265  *
1266  * Permission to use, copy, modify, and distribute this software for any
1267  * purpose with or without fee is hereby granted, provided that the above
1268  * copyright notice and this permission notice appear in all copies.
1269  *
1270  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
1271  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
1272  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
1273  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
1274  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
1275  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
1276  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
1277  */
1278
1279 /*      $OpenBSD: strlcat.c,v 1.11 2003/06/17 21:56:24 millert Exp $    */
1280 /*      $OpenBSD: strlcpy.c,v 1.8 2003/06/17 21:56:24 millert Exp $     */
1281
1282
1283 #ifndef HAVE_STRLCAT
1284 size_t
1285 strlcat(char *dst, const char *src, size_t siz)
1286 {
1287         register char *d = dst;
1288         register const char *s = src;
1289         register size_t n = siz;
1290         size_t dlen;
1291
1292         /* Find the end of dst and adjust bytes left but don't go past end */
1293         while (n-- != 0 && *d != '\0')
1294                 d++;
1295         dlen = d - dst;
1296         n = siz - dlen;
1297
1298         if (n == 0)
1299                 return(dlen + strlen(s));
1300         while (*s != '\0') {
1301                 if (n != 1) {
1302                         *d++ = *s;
1303                         n--;
1304                 }
1305                 s++;
1306         }
1307         *d = '\0';
1308
1309         return(dlen + (s - src));       /* count does not include NUL */
1310 }
1311 #endif  // #ifndef HAVE_STRLCAT
1312
1313
1314 #ifndef HAVE_STRLCPY
1315 size_t
1316 strlcpy(char *dst, const char *src, size_t siz)
1317 {
1318         register char *d = dst;
1319         register const char *s = src;
1320         register size_t n = siz;
1321
1322         /* Copy as many bytes as will fit */
1323         if (n != 0 && --n != 0) {
1324                 do {
1325                         if ((*d++ = *s++) == 0)
1326                                 break;
1327                 } while (--n != 0);
1328         }
1329
1330         /* Not enough room in dst, add NUL and traverse rest of src */
1331         if (n == 0) {
1332                 if (siz != 0)
1333                         *d = '\0';              /* NUL-terminate dst */
1334                 while (*s++)
1335                         ;
1336         }
1337
1338         return(s - src - 1);    /* count does not include NUL */
1339 }
1340
1341 #endif  // #ifndef HAVE_STRLCPY