rewrote memory system entirely (hunk, cache, and zone are gone, memory pools replaced...
[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 #ifdef WIN32
25 #include <io.h>
26 #else
27 #include <unistd.h>
28 #endif
29
30 #include "quakedef.h"
31
32 #define NUM_SAFE_ARGVS  7
33
34 static char *largv[MAX_NUM_ARGVS + NUM_SAFE_ARGVS + 1];
35 static char *argvdummy = " ";
36
37 static char *safeargvs[NUM_SAFE_ARGVS] =
38         {"-stdvid", "-nolan", "-nosound", "-nocdaudio", "-nojoy", "-nomouse", "-window"};
39
40 cvar_t registered = {0, "registered","0"};
41 cvar_t cmdline = {0, "cmdline","0"};
42
43 mempool_t *pak_mempool;
44
45 qboolean com_modified;   // set true if using non-id files
46
47 //qboolean proghack;
48
49 //int static_registered = 1;  // only for startup check, then set
50
51 qboolean msg_suppress_1 = 0;
52
53 void COM_InitFilesystem (void);
54
55 char com_token[1024];
56 int com_argc;
57 char **com_argv;
58
59 // LordHavoc: made commandline 1024 characters instead of 256
60 #define CMDLINE_LENGTH  1024
61 char com_cmdline[CMDLINE_LENGTH];
62
63 int gamemode;
64 char *gamename;
65
66 /*
67
68
69 All of Quake's data access is through a hierchal file system, but the contents of the file system can be transparently merged from several sources.
70
71 The "base directory" is the path to the directory holding the quake.exe and all game directories.  The sys_* files pass this to host_init in quakeparms_t->basedir.  This can be overridden with the "-basedir" command line parm to allow code debugging in a different directory.  The base directory is
72 only used during filesystem initialization.
73
74 The "game directory" is the first tree on the search path and directory that all generated files (savegames, screenshots, demos, config files) will be saved to.  This can be overridden with the "-game" command line parameter.  The game directory can never be changed while quake is executing.  This is a precacution against having a malicious server instruct clients to write files over areas they shouldn't.
75
76 The "cache directory" is only used during development to save network bandwidth, especially over ISDN / T1 lines.  If there is a cache directory
77 specified, when a file is found by the normal search path, it will be mirrored
78 into the cache directory, then opened there.
79
80
81
82 FIXME:
83 The file "parms.txt" will be read out of the game directory and appended to the current command line arguments to allow different games to initialize startup parms differently.  This could be used to add a "-sspeed 22050" for the high quality sound edition.  Because they are added at the end, they will not override an explicit setting on the original command line.
84
85 */
86
87 //============================================================================
88
89
90 /*
91 ============================================================================
92
93                                         LIBRARY REPLACEMENT FUNCTIONS
94
95 ============================================================================
96 */
97
98 /*
99 void Q_memset (void *dest, int fill, int count)
100 {
101         int             i;
102
103         if ( (((long)dest | count) & 3) == 0)
104         {
105                 count >>= 2;
106                 fill = fill | (fill<<8) | (fill<<16) | (fill<<24);
107                 for (i=0 ; i<count ; i++)
108                         ((int *)dest)[i] = fill;
109         }
110         else
111                 for (i=0 ; i<count ; i++)
112                         ((byte *)dest)[i] = fill;
113 }
114
115 void Q_memcpy (void *dest, void *src, int count)
116 {
117         int             i;
118         
119         if (( ( (long)dest | (long)src | count) & 3) == 0 )
120         {
121                 count>>=2;
122                 for (i=0 ; i<count ; i++)
123                         ((int *)dest)[i] = ((int *)src)[i];
124         }
125         else
126                 for (i=0 ; i<count ; i++)
127                         ((byte *)dest)[i] = ((byte *)src)[i];
128 }
129
130 int Q_memcmp (void *m1, void *m2, int count)
131 {
132         while(count)
133         {
134                 count--;
135                 if (((byte *)m1)[count] != ((byte *)m2)[count])
136                         return -1;
137         }
138         return 0;
139 }
140
141 void Q_strcpy (char *dest, char *src)
142 {
143         while (*src)
144         {
145                 *dest++ = *src++;
146         }
147         *dest++ = 0;
148 }
149
150 void Q_strncpy (char *dest, char *src, int count)
151 {
152         while (*src && count--)
153         {
154                 *dest++ = *src++;
155         }
156         if (count)
157                 *dest++ = 0;
158 }
159
160 int Q_strlen (char *str)
161 {
162         int             count;
163         
164         count = 0;
165         while (str[count])
166                 count++;
167
168         return count;
169 }
170
171 char *Q_strrchr(char *s, char c)
172 {
173     int len = Q_strlen(s);
174     s += len;
175     while (len--)
176         if (*--s == c) return s;
177     return 0;
178 }
179
180 void Q_strcat (char *dest, char *src)
181 {
182         dest += Q_strlen(dest);
183         Q_strcpy (dest, src);
184 }
185
186 int Q_strcmp (char *s1, char *s2)
187 {
188         while (1)
189         {
190                 if (*s1 != *s2)
191                         return -1;              // strings not equal    
192                 if (!*s1)
193                         return 0;               // strings are equal
194                 s1++;
195                 s2++;
196         }
197
198         return -1;
199 }
200
201 int Q_strncmp (char *s1, char *s2, int count)
202 {
203         while (1)
204         {
205                 if (!count--)
206                         return 0;
207                 if (*s1 != *s2)
208                         return -1;              // strings not equal    
209                 if (!*s1)
210                         return 0;               // strings are equal
211                 s1++;
212                 s2++;
213         }
214
215         return -1;
216 }
217 */
218 int Q_strncasecmp (char *s1, char *s2, int n)
219 {
220         int             c1, c2;
221
222         while (1)
223         {
224                 c1 = *s1++;
225                 c2 = *s2++;
226
227                 if (!n--)
228                         return 0;               // strings are equal until end point
229
230                 if (c1 != c2)
231                 {
232                         if (c1 >= 'a' && c1 <= 'z')
233                                 c1 -= ('a' - 'A');
234                         if (c2 >= 'a' && c2 <= 'z')
235                                 c2 -= ('a' - 'A');
236                         if (c1 != c2)
237                                 return -1;              // strings not equal
238                 }
239                 if (!c1)
240                         return 0;               // strings are equal
241 //              s1++;
242 //              s2++;
243         }
244
245         return -1;
246 }
247
248 int Q_strcasecmp (char *s1, char *s2)
249 {
250         return Q_strncasecmp (s1, s2, 99999);
251 }
252 /*
253 int Q_atoi (char *str)
254 {
255         int             val;
256         int             sign;
257         int             c;
258
259         if (*str == '-')
260         {
261                 sign = -1;
262                 str++;
263         }
264         else
265                 sign = 1;
266                 
267         val = 0;
268
269 //
270 // check for hex
271 //
272         if (str[0] == '0' && (str[1] == 'x' || str[1] == 'X') )
273         {
274                 str += 2;
275                 while (1)
276                 {
277                         c = *str++;
278                         if (c >= '0' && c <= '9')
279                                 val = (val<<4) + c - '0';
280                         else if (c >= 'a' && c <= 'f')
281                                 val = (val<<4) + c - 'a' + 10;
282                         else if (c >= 'A' && c <= 'F')
283                                 val = (val<<4) + c - 'A' + 10;
284                         else
285                                 return val*sign;
286                 }
287         }
288         
289 //
290 // check for character
291 //
292         if (str[0] == '\'')
293         {
294                 return sign * str[1];
295         }
296         
297 //
298 // assume decimal
299 //
300         while (1)
301         {
302                 c = *str++;
303                 if (c <'0' || c > '9')
304                         return val*sign;
305                 val = val*10 + c - '0';
306         }
307         
308         return 0;
309 }
310
311
312 float Q_atof (char *str)
313 {
314         double                  val;
315         int             sign;
316         int             c;
317         int             decimal, total;
318         
319         if (*str == '-')
320         {
321                 sign = -1;
322                 str++;
323         }
324         else
325                 sign = 1;
326                 
327         val = 0;
328
329 //
330 // check for hex
331 //
332         if (str[0] == '0' && (str[1] == 'x' || str[1] == 'X') )
333         {
334                 str += 2;
335                 while (1)
336                 {
337                         c = *str++;
338                         if (c >= '0' && c <= '9')
339                                 val = (val*16) + c - '0';
340                         else if (c >= 'a' && c <= 'f')
341                                 val = (val*16) + c - 'a' + 10;
342                         else if (c >= 'A' && c <= 'F')
343                                 val = (val*16) + c - 'A' + 10;
344                         else
345                                 return val*sign;
346                 }
347         }
348         
349 //
350 // check for character
351 //
352         if (str[0] == '\'')
353         {
354                 return sign * str[1];
355         }
356         
357 //
358 // assume decimal
359 //
360         decimal = -1;
361         total = 0;
362         while (1)
363         {
364                 c = *str++;
365                 if (c == '.')
366                 {
367                         decimal = total;
368                         continue;
369                 }
370                 if (c <'0' || c > '9')
371                         break;
372                 val = val*10 + c - '0';
373                 total++;
374         }
375
376         if (decimal == -1)
377                 return val*sign;
378         while (total > decimal)
379         {
380                 val /= 10;
381                 total--;
382         }
383
384         return val*sign;
385 }
386 */
387
388 /*
389 ============================================================================
390
391                                         BYTE ORDER FUNCTIONS
392
393 ============================================================================
394 */
395
396 #if !defined(ENDIAN_LITTLE) && !defined(ENDIAN_BIG)
397 short   (*BigShort) (short l);
398 short   (*LittleShort) (short l);
399 int     (*BigLong) (int l);
400 int     (*LittleLong) (int l);
401 float   (*BigFloat) (float l);
402 float   (*LittleFloat) (float l);
403 #endif
404
405 short   ShortSwap (short l)
406 {
407         byte    b1,b2;
408
409         b1 = l&255;
410         b2 = (l>>8)&255;
411
412         return (b1<<8) + b2;
413 }
414
415 #if !defined(ENDIAN_LITTLE) && !defined(ENDIAN_BIG)
416 short   ShortNoSwap (short l)
417 {
418         return l;
419 }
420 #endif
421
422 int    LongSwap (int l)
423 {
424         byte    b1,b2,b3,b4;
425
426         b1 = l&255;
427         b2 = (l>>8)&255;
428         b3 = (l>>16)&255;
429         b4 = (l>>24)&255;
430
431         return ((int)b1<<24) + ((int)b2<<16) + ((int)b3<<8) + b4;
432 }
433
434 #if !defined(ENDIAN_LITTLE) && !defined(ENDIAN_BIG)
435 int     LongNoSwap (int l)
436 {
437         return l;
438 }
439 #endif
440
441 float FloatSwap (float f)
442 {
443         union
444         {
445                 float   f;
446                 byte    b[4];
447         } dat1, dat2;
448
449
450         dat1.f = f;
451         dat2.b[0] = dat1.b[3];
452         dat2.b[1] = dat1.b[2];
453         dat2.b[2] = dat1.b[1];
454         dat2.b[3] = dat1.b[0];
455         return dat2.f;
456 }
457
458 #if !defined(ENDIAN_LITTLE) && !defined(ENDIAN_BIG)
459 float FloatNoSwap (float f)
460 {
461         return f;
462 }
463 #endif
464
465 /*
466 ==============================================================================
467
468                         MESSAGE IO FUNCTIONS
469
470 Handles byte ordering and avoids alignment errors
471 ==============================================================================
472 */
473
474 //
475 // writing functions
476 //
477
478 void MSG_WriteChar (sizebuf_t *sb, int c)
479 {
480         byte    *buf;
481         
482 //#ifdef PARANOID
483 //      if (c < -128 || c > 127)
484 //              Sys_Error ("MSG_WriteChar: range error");
485 //#endif
486
487         buf = SZ_GetSpace (sb, 1);
488         buf[0] = c;
489 }
490
491 void MSG_WriteByte (sizebuf_t *sb, int c)
492 {
493         byte    *buf;
494         
495 //#ifdef PARANOID
496 //      if (c < 0 || c > 255)
497 //              Sys_Error ("MSG_WriteByte: range error");
498 //#endif
499
500         buf = SZ_GetSpace (sb, 1);
501         buf[0] = c;
502 }
503
504 void MSG_WriteShort (sizebuf_t *sb, int c)
505 {
506         byte    *buf;
507
508 //#ifdef PARANOID
509 //      if (c < ((short)0x8000) || c > (short)0x7fff)
510 //              Sys_Error ("MSG_WriteShort: range error");
511 //#endif
512
513         buf = SZ_GetSpace (sb, 2);
514         buf[0] = c&0xff;
515         buf[1] = c>>8;
516 }
517
518 void MSG_WriteLong (sizebuf_t *sb, int c)
519 {
520         byte    *buf;
521
522         buf = SZ_GetSpace (sb, 4);
523         buf[0] = c&0xff;
524         buf[1] = (c>>8)&0xff;
525         buf[2] = (c>>16)&0xff;
526         buf[3] = c>>24;
527 }
528
529 void MSG_WriteFloat (sizebuf_t *sb, float f)
530 {
531         union
532         {
533                 float   f;
534                 int     l;
535         } dat;
536
537
538         dat.f = f;
539         dat.l = LittleLong (dat.l);
540
541         SZ_Write (sb, &dat.l, 4);
542 }
543
544 void MSG_WriteString (sizebuf_t *sb, char *s)
545 {
546         if (!s)
547                 SZ_Write (sb, "", 1);
548         else
549                 SZ_Write (sb, s, strlen(s)+1);
550 }
551
552 // used by server (always dpprotocol)
553 // moved to common.h as #define
554 /*
555 void MSG_WriteFloatCoord (sizebuf_t *sb, float f)
556 {
557         MSG_WriteFloat(sb, f);
558 }
559 */
560
561 // used by client
562 void MSG_WriteCoord (sizebuf_t *sb, float f)
563 {
564         if (dpprotocol)
565                 MSG_WriteFloat(sb, f);
566         else
567         {
568                 if (f >= 0)
569                         MSG_WriteShort (sb, (int)(f*8.0f + 0.5f));
570                 else
571                         MSG_WriteShort (sb, (int)(f*8.0f - 0.5f));
572         }
573 }
574
575 void MSG_WritePreciseAngle (sizebuf_t *sb, float f)
576 {
577         if (f >= 0)
578                 MSG_WriteShort (sb, (int)(f*(65536.0f/360.0f) + 0.5f) & 65535);
579         else
580                 MSG_WriteShort (sb, (int)(f*(65536.0f/360.0f) - 0.5f) & 65535);
581 }
582
583 // LordHavoc: round to nearest value, rather than rounding toward zero, fixes crosshair problem
584 void MSG_WriteAngle (sizebuf_t *sb, float f)
585 {
586         if (f >= 0)
587                 MSG_WriteByte (sb, (int)(f*(256.0f/360.0f) + 0.5f) & 255);
588         else
589                 MSG_WriteByte (sb, (int)(f*(256.0f/360.0f) - 0.5f) & 255);
590 }
591
592 //
593 // reading functions
594 //
595 int                     msg_readcount;
596 qboolean        msg_badread;
597
598 void MSG_BeginReading (void)
599 {
600         msg_readcount = 0;
601         msg_badread = false;
602 }
603
604 /*
605 // returns -1 and sets msg_badread if no more characters are available
606 int MSG_ReadChar (void)
607 {
608         int     c;
609         
610         // LordHavoc: minor optimization
611         if (msg_readcount >= net_message.cursize)
612 //      if (msg_readcount+1 > net_message.cursize)
613         {
614                 msg_badread = true;
615                 return -1;
616         }
617                 
618         c = (signed char)net_message.data[msg_readcount];
619         msg_readcount++;
620
621         return c;
622 }
623
624 int MSG_ReadByte (void)
625 {
626         int     c;
627         
628         // LordHavoc: minor optimization
629         if (msg_readcount >= net_message.cursize)
630 //      if (msg_readcount+1 > net_message.cursize)
631         {
632                 msg_badread = true;
633                 return -1;
634         }
635
636         c = (unsigned char)net_message.data[msg_readcount];
637         msg_readcount++;
638         
639         return c;
640 }
641 */
642
643 int MSG_ReadShort (void)
644 {
645         int     c;
646
647         if (msg_readcount+2 > net_message.cursize)
648         {
649                 msg_badread = true;
650                 return -1;
651         }
652                 
653         c = (short)(net_message.data[msg_readcount]
654         + (net_message.data[msg_readcount+1]<<8));
655         
656         msg_readcount += 2;
657         
658         return c;
659 }
660
661 int MSG_ReadLong (void)
662 {
663         int     c;
664         
665         if (msg_readcount+4 > net_message.cursize)
666         {
667                 msg_badread = true;
668                 return -1;
669         }
670
671         c = net_message.data[msg_readcount]
672         + (net_message.data[msg_readcount+1]<<8)
673         + (net_message.data[msg_readcount+2]<<16)
674         + (net_message.data[msg_readcount+3]<<24);
675         
676         msg_readcount += 4;
677         
678         return c;
679 }
680
681 float MSG_ReadFloat (void)
682 {
683         union
684         {
685                 byte    b[4];
686                 float   f;
687                 int     l;
688         } dat;
689         
690         dat.b[0] =      net_message.data[msg_readcount];
691         dat.b[1] =      net_message.data[msg_readcount+1];
692         dat.b[2] =      net_message.data[msg_readcount+2];
693         dat.b[3] =      net_message.data[msg_readcount+3];
694         msg_readcount += 4;
695         
696         dat.l = LittleLong (dat.l);
697
698         return dat.f;   
699 }
700
701 char *MSG_ReadString (void)
702 {
703         static char     string[2048];
704         int             l,c;
705         
706         l = 0;
707         do
708         {
709                 c = MSG_ReadChar ();
710                 if (c == -1 || c == 0)
711                         break;
712                 string[l] = c;
713                 l++;
714         } while (l < sizeof(string)-1);
715         
716         string[l] = 0;
717         
718         return string;
719 }
720
721 // used by server (always dpprotocol)
722 // moved to common.h as #define
723 /*
724 float MSG_ReadFloatCoord (void)
725 {
726         return MSG_ReadFloat();
727 }
728 */
729
730 // used by client
731 float MSG_ReadCoord (void)
732 {
733         if (dpprotocol)
734                 return MSG_ReadFloat();
735         else
736                 return MSG_ReadShort() * (1.0f/8.0f);
737 }
738
739 /*
740 float MSG_ReadCoord (void)
741 {
742         return MSG_ReadShort() * (1.0f/8.0f);
743 }
744
745 float MSG_ReadAngle (void)
746 {
747         return MSG_ReadChar() * (360.0f/256.0f);
748 }
749
750 float MSG_ReadPreciseAngle (void)
751 {
752         return MSG_ReadShort() * (360.0f/65536);
753 }
754 */
755
756
757 //===========================================================================
758
759 void SZ_Alloc (sizebuf_t *buf, int startsize, char *name)
760 {
761         if (startsize < 256)
762                 startsize = 256;
763         buf->mempool = Mem_AllocPool(name);
764         buf->data = Mem_Alloc(buf->mempool, startsize);
765         buf->maxsize = startsize;
766         buf->cursize = 0;
767 }
768
769
770 void SZ_Free (sizebuf_t *buf)
771 {
772         Mem_FreePool(&buf->mempool);
773         buf->data = NULL;
774         buf->maxsize = 0;
775         buf->cursize = 0;
776 }
777
778 void SZ_Clear (sizebuf_t *buf)
779 {
780         buf->cursize = 0;
781 }
782
783 void *SZ_GetSpace (sizebuf_t *buf, int length)
784 {
785         void    *data;
786
787         if (buf->cursize + length > buf->maxsize)
788         {
789                 if (!buf->allowoverflow)
790                         Host_Error ("SZ_GetSpace: overflow without allowoverflow set - use -zone on the commandline for more zone memory, default: 128k (quake original default was 48k)");
791
792                 if (length > buf->maxsize)
793                         Host_Error ("SZ_GetSpace: %i is > full buffer size", length);
794
795                 buf->overflowed = true;
796                 Con_Printf ("SZ_GetSpace: overflow");
797                 SZ_Clear (buf);
798         }
799
800         data = buf->data + buf->cursize;
801         buf->cursize += length;
802         
803         return data;
804 }
805
806 void SZ_Write (sizebuf_t *buf, void *data, int length)
807 {
808         memcpy (SZ_GetSpace(buf,length),data,length);         
809 }
810
811 void SZ_Print (sizebuf_t *buf, char *data)
812 {
813         int             len;
814         
815         len = strlen(data)+1;
816
817 // byte * cast to keep VC++ happy
818         if (buf->data[buf->cursize-1])
819                 memcpy ((byte *)SZ_GetSpace(buf, len),data,len); // no trailing 0
820         else
821                 memcpy ((byte *)SZ_GetSpace(buf, len-1)-1,data,len); // write over trailing 0
822 }
823
824
825 //============================================================================
826
827
828 /*
829 ============
830 COM_SkipPath
831 ============
832 */
833 char *COM_SkipPath (char *pathname)
834 {
835         char    *last;
836
837         last = pathname;
838         while (*pathname)
839         {
840                 if (*pathname=='/')
841                         last = pathname+1;
842                 pathname++;
843         }
844         return last;
845 }
846
847 /*
848 ============
849 COM_StripExtension
850 ============
851 */
852 // LordHavoc: replacement for severely broken COM_StripExtension that was used in original quake.
853 void COM_StripExtension (char *in, char *out)
854 {
855         char *last = NULL;
856         while (*in)
857         {
858                 if (*in == '.')
859                         last = in;
860                 if ((*in == '/') || (*in == '\\') || (*in == ':'))
861                         last = NULL;
862                 *out++ = *in++;
863         }
864         if (last)
865                 *last = 0;
866 }
867
868 /*
869 ============
870 COM_FileExtension
871 ============
872 */
873 char *COM_FileExtension (char *in)
874 {
875         static char exten[8];
876         int             i;
877
878         while (*in && *in != '.')
879                 in++;
880         if (!*in)
881                 return "";
882         in++;
883         for (i=0 ; i<7 && *in ; i++,in++)
884                 exten[i] = *in;
885         exten[i] = 0;
886         return exten;
887 }
888
889 /*
890 ============
891 COM_FileBase
892 ============
893 */
894 void COM_FileBase (char *in, char *out)
895 {
896         char *slash, *dot;
897         char *s;
898
899         slash = in;
900         dot = NULL;
901         s = in;
902         while(*s)
903         {
904                 if (*s == '/')
905                         slash = s + 1;
906                 if (*s == '.')
907                         dot = s;
908                 s++;
909         }
910         if (dot == NULL)
911                 dot = s;
912         if (dot - slash < 2)
913                 strcpy (out,"?model?");
914         else
915         {
916                 while (slash < dot)
917                         *out++ = *slash++;
918                 *out++ = 0;
919         }
920 }
921
922
923 /*
924 ==================
925 COM_DefaultExtension
926 ==================
927 */
928 void COM_DefaultExtension (char *path, char *extension)
929 {
930         char    *src;
931 //
932 // if path doesn't have a .EXT, append extension
933 // (extension should include the .)
934 //
935         src = path + strlen(path) - 1;
936
937         while (*src != '/' && src != path)
938         {
939                 if (*src == '.')
940                         return;                 // it has an extension
941                 src--;
942         }
943
944         strcat (path, extension);
945 }
946
947
948 /*
949 ==============
950 COM_Parse
951
952 Parse a token out of a string
953 ==============
954 */
955 char *COM_Parse (char *data)
956 {
957         int             c;
958         int             len;
959         
960         len = 0;
961         com_token[0] = 0;
962         
963         if (!data)
964                 return NULL;
965                 
966 // skip whitespace
967 skipwhite:
968         while ( (c = *data) <= ' ')
969         {
970                 if (c == 0)
971                         return NULL;                    // end of file;
972                 data++;
973         }
974         
975 // skip // comments
976         if (c=='/' && data[1] == '/')
977         {
978                 while (*data && *data != '\n')
979                         data++;
980                 goto skipwhite;
981         }
982         
983
984 // handle quoted strings specially
985         if (c == '\"')
986         {
987                 data++;
988                 while (1)
989                 {
990                         c = *data++;
991                         if (c=='\"' || !c)
992                         {
993                                 com_token[len] = 0;
994                                 return data;
995                         }
996                         com_token[len] = c;
997                         len++;
998                 }
999         }
1000
1001 // parse single characters
1002         if (c=='{' || c=='}'|| c==')'|| c=='(' || c=='\'' || c==':')
1003         {
1004                 com_token[len] = c;
1005                 len++;
1006                 com_token[len] = 0;
1007                 return data+1;
1008         }
1009
1010 // parse a regular word
1011         do
1012         {
1013                 com_token[len] = c;
1014                 data++;
1015                 len++;
1016                 c = *data;
1017         if (c=='{' || c=='}'|| c==')'|| c=='(' || c=='\'' || c==':')
1018                         break;
1019         } while (c>32);
1020         
1021         com_token[len] = 0;
1022         return data;
1023 }
1024
1025
1026 /*
1027 ================
1028 COM_CheckParm
1029
1030 Returns the position (1 to argc-1) in the program's argument list
1031 where the given parameter apears, or 0 if not present
1032 ================
1033 */
1034 int COM_CheckParm (char *parm)
1035 {
1036         int             i;
1037         
1038         for (i=1 ; i<com_argc ; i++)
1039         {
1040                 if (!com_argv[i])
1041                         continue;               // NEXTSTEP sometimes clears appkit vars.
1042                 if (!strcmp (parm,com_argv[i]))
1043                         return i;
1044         }
1045                 
1046         return 0;
1047 }
1048
1049 /*
1050 ================
1051 COM_CheckRegistered
1052
1053 Looks for the pop.txt file and verifies it.
1054 Sets the "registered" cvar.
1055 Immediately exits out if an alternate game was attempted to be started without
1056 being registered.
1057 ================
1058 */
1059 void COM_CheckRegistered (void)
1060 {
1061         Cvar_Set ("cmdline", com_cmdline);
1062
1063 //      static_registered = 0;
1064
1065         if (!Sys_FileTime("gfx/pop.lmp"))
1066         {
1067                 if (com_modified)
1068                         Con_Printf ("Playing shareware version, with modification.\nwarning: most mods require full quake data.\n");
1069                 else
1070                         Con_Printf ("Playing shareware version.\n");
1071 //#if WINDED
1072 //      Sys_Error ("This dedicated server requires a full registered copy of Quake");
1073 //#endif
1074 //              Con_Printf ("Playing shareware version.\n");
1075 //              if (com_modified)
1076 //                      Sys_Error ("You must have the registered version to use modified games");
1077                 return;
1078         }
1079
1080 //      Cvar_Set ("cmdline", com_cmdline);
1081         Cvar_Set ("registered", "1");
1082 //      static_registered = 1;
1083         Con_Printf ("Playing registered version.\n");
1084 }
1085
1086
1087 void COM_Path_f (void);
1088
1089
1090 /*
1091 ================
1092 COM_InitArgv
1093 ================
1094 */
1095 void COM_InitArgv (int argc, char **argv)
1096 {
1097         qboolean        safe;
1098         int             i, j, n;
1099
1100 // reconstitute the command line for the cmdline externally visible cvar
1101         n = 0;
1102
1103         for (j=0 ; (j<MAX_NUM_ARGVS) && (j< argc) ; j++)
1104         {
1105                 i = 0;
1106
1107                 while ((n < (CMDLINE_LENGTH - 1)) && argv[j][i])
1108                 {
1109                         com_cmdline[n++] = argv[j][i++];
1110                 }
1111
1112                 if (n < (CMDLINE_LENGTH - 1))
1113                         com_cmdline[n++] = ' ';
1114                 else
1115                         break;
1116         }
1117
1118         com_cmdline[n] = 0;
1119
1120         safe = false;
1121
1122         for (com_argc=0 ; (com_argc<MAX_NUM_ARGVS) && (com_argc < argc) ;
1123                  com_argc++)
1124         {
1125                 largv[com_argc] = argv[com_argc];
1126                 if (!strcmp ("-safe", argv[com_argc]))
1127                         safe = true;
1128         }
1129
1130         if (safe)
1131         {
1132         // force all the safe-mode switches. Note that we reserved extra space in
1133         // case we need to add these, so we don't need an overflow check
1134                 for (i=0 ; i<NUM_SAFE_ARGVS ; i++)
1135                 {
1136                         largv[com_argc] = safeargvs[i];
1137                         com_argc++;
1138                 }
1139         }
1140
1141         largv[com_argc] = argvdummy;
1142         com_argv = largv;
1143
1144 #if ZYMOTIC
1145         gamemode = GAME_ZYMOTIC;
1146 #elif FIENDARENA
1147         gamemode = GAME_FIENDARENA;
1148 #elif NEHAHRA
1149         gamemode = GAME_NEHAHRA;
1150 #else
1151         if (COM_CheckParm ("-zymotic"))
1152                 gamemode = GAME_ZYMOTIC;
1153         else if (COM_CheckParm ("-fiendarena"))
1154                 gamemode = GAME_FIENDARENA;
1155         else if (COM_CheckParm ("-nehahra"))
1156                 gamemode = GAME_NEHAHRA;
1157         else if (COM_CheckParm ("-hipnotic"))
1158                 gamemode = GAME_HIPNOTIC;
1159         else if (COM_CheckParm ("-rogue"))
1160                 gamemode = GAME_ROGUE;
1161 #endif
1162         switch(gamemode)
1163         {
1164         case GAME_NORMAL:
1165                 gamename = "DarkPlaces";
1166                 break;
1167         case GAME_HIPNOTIC:
1168                 gamename = "Darkplaces-Hipnotic";
1169                 break;
1170         case GAME_ROGUE:
1171                 gamename = "Darkplaces-Rogue";
1172                 break;
1173         case GAME_NEHAHRA:
1174                 gamename = "DarkPlaces-Nehahra";
1175                 break;
1176         case GAME_FIENDARENA:
1177                 gamename = "FiendArena";
1178                 break;
1179         case GAME_ZYMOTIC:
1180                 gamename = "Zymotic";
1181                 break;
1182         default:
1183                 Sys_Error("COM_InitArgv: unknown gamemode %i\n", gamemode);
1184                 break;
1185         }
1186 }
1187
1188
1189 extern void Mathlib_Init(void);
1190
1191 /*
1192 ================
1193 COM_Init
1194 ================
1195 */
1196 void COM_Init (void)
1197 {
1198 #if !defined(ENDIAN_LITTLE) && !defined(ENDIAN_BIG)
1199         byte    swaptest[2] = {1,0};
1200
1201 // set the byte swapping variables in a portable manner
1202         if ( *(short *)swaptest == 1)
1203         {
1204                 BigShort = ShortSwap;
1205                 LittleShort = ShortNoSwap;
1206                 BigLong = LongSwap;
1207                 LittleLong = LongNoSwap;
1208                 BigFloat = FloatSwap;
1209                 LittleFloat = FloatNoSwap;
1210         }
1211         else
1212         {
1213                 BigShort = ShortNoSwap;
1214                 LittleShort = ShortSwap;
1215                 BigLong = LongNoSwap;
1216                 LittleLong = LongSwap;
1217                 BigFloat = FloatNoSwap;
1218                 LittleFloat = FloatSwap;
1219         }
1220 #endif
1221
1222         pak_mempool = Mem_AllocPool("paks");
1223
1224         Cvar_RegisterVariable (&registered);
1225         Cvar_RegisterVariable (&cmdline);
1226         Cmd_AddCommand ("path", COM_Path_f);
1227
1228         Mathlib_Init();
1229
1230         COM_InitFilesystem ();
1231         COM_CheckRegistered ();
1232 }
1233
1234
1235 /*
1236 ============
1237 va
1238
1239 does a varargs printf into a temp buffer, so I don't need to have
1240 varargs versions of all text functions.
1241 FIXME: make this buffer size safe someday
1242 ============
1243 */
1244 char    *va(char *format, ...)
1245 {
1246         va_list         argptr;
1247         static char             string[1024];
1248         
1249         va_start (argptr, format);
1250         vsprintf (string, format,argptr);
1251         va_end (argptr);
1252
1253         return string;  
1254 }
1255
1256
1257 /// just for debugging
1258 int     memsearch (byte *start, int count, int search)
1259 {
1260         int             i;
1261         
1262         for (i=0 ; i<count ; i++)
1263                 if (start[i] == search)
1264                         return i;
1265         return -1;
1266 }
1267
1268 /*
1269 =============================================================================
1270
1271 QUAKE FILESYSTEM
1272
1273 =============================================================================
1274 */
1275
1276 int     com_filesize;
1277
1278
1279 //
1280 // in memory
1281 //
1282
1283 typedef struct
1284 {
1285         char name[MAX_QPATH];
1286         int filepos, filelen;
1287 } packfile_t;
1288
1289 typedef struct pack_s
1290 {
1291         char filename[MAX_OSPATH];
1292         int handle;
1293         int numfiles;
1294         packfile_t *files;
1295         mempool_t *mempool;
1296         struct pack_s *next;
1297 } pack_t;
1298
1299 //
1300 // on disk
1301 //
1302 typedef struct
1303 {
1304         char name[56];
1305         int filepos, filelen;
1306 } dpackfile_t;
1307
1308 typedef struct
1309 {
1310         char id[4];
1311         int dirofs;
1312         int dirlen;
1313 } dpackheader_t;
1314
1315 // LordHavoc: was 2048, increased to 65536 and changed info[MAX_PACK_FILES] to a temporary alloc
1316 #define MAX_FILES_IN_PACK       65536
1317
1318 pack_t  *packlist = NULL;
1319
1320 #if CACHEENABLE
1321 char    com_cachedir[MAX_OSPATH];
1322 #endif
1323 char    com_gamedir[MAX_OSPATH];
1324
1325 typedef struct searchpath_s
1326 {
1327         char filename[MAX_OSPATH];
1328         pack_t *pack;          // only one of filename / pack will be used
1329         struct searchpath_s *next;
1330 } searchpath_t;
1331
1332 searchpath_t    *com_searchpaths;
1333
1334 /*
1335 ============
1336 COM_Path_f
1337
1338 ============
1339 */
1340 void COM_Path_f (void)
1341 {
1342         searchpath_t    *s;
1343
1344         Con_Printf ("Current search path:\n");
1345         for (s=com_searchpaths ; s ; s=s->next)
1346         {
1347                 if (s->pack)
1348                 {
1349                         Con_Printf ("%s (%i files)\n", s->pack->filename, s->pack->numfiles);
1350                 }
1351                 else
1352                         Con_Printf ("%s\n", s->filename);
1353         }
1354 }
1355
1356 /*
1357 ============
1358 COM_CreatePath
1359
1360 LordHavoc: Previously only used for CopyFile, now also used for COM_WriteFile.
1361 ============
1362 */
1363 void    COM_CreatePath (char *path)
1364 {
1365         char    *ofs, save;
1366
1367         for (ofs = path+1 ; *ofs ; ofs++)
1368         {
1369                 if (*ofs == '/' || *ofs == '\\' || *ofs == ':')
1370                 {       // create the directory
1371                         save = *ofs;
1372                         *ofs = 0;
1373                         Sys_mkdir (path);
1374                         *ofs = save;
1375                 }
1376         }
1377 }
1378
1379
1380 /*
1381 ============
1382 COM_WriteFile
1383
1384 The filename will be prefixed by the current game directory
1385 ============
1386 */
1387 void COM_WriteFile (char *filename, void *data, int len)
1388 {
1389         int             handle;
1390         char    name[MAX_OSPATH];
1391
1392         sprintf (name, "%s/%s", com_gamedir, filename);
1393
1394         // LordHavoc: added this
1395         COM_CreatePath (name); // create directories up to the file
1396
1397         handle = Sys_FileOpenWrite (name);
1398         if (handle == -1)
1399         {
1400                 Sys_Printf ("COM_WriteFile: failed on %s\n", name);
1401                 return;
1402         }
1403
1404         Con_Printf ("COM_WriteFile: %s\n", name);
1405         Sys_FileWrite (handle, data, len);
1406         Sys_FileClose (handle);
1407 }
1408
1409
1410 /*
1411 ===========
1412 COM_CopyFile
1413
1414 Copies a file over from the net to the local cache, creating any directories
1415 needed.  This is for the convenience of developers using ISDN from home.
1416 ===========
1417 */
1418 void COM_CopyFile (char *netpath, char *cachepath)
1419 {
1420         int             in, out;
1421         int             remaining, count;
1422         char    buf[4096];
1423
1424         remaining = Sys_FileOpenRead (netpath, &in);            
1425         COM_CreatePath (cachepath);     // create directories up to the cache file
1426         out = Sys_FileOpenWrite (cachepath);
1427         
1428         while (remaining)
1429         {
1430                 if (remaining < sizeof(buf))
1431                         count = remaining;
1432                 else
1433                         count = sizeof(buf);
1434                 Sys_FileRead (in, buf, count);
1435                 Sys_FileWrite (out, buf, count);
1436                 remaining -= count;
1437         }
1438
1439         Sys_FileClose (in);
1440         Sys_FileClose (out);    
1441 }
1442
1443 /*
1444 ===========
1445 COM_OpenRead
1446 ===========
1447 */
1448 QFile * COM_OpenRead (const char *path, int offs, int len, qboolean zip)
1449 {
1450         int                             fd = open (path, O_RDONLY);
1451         unsigned char   id[2];
1452         unsigned char   len_bytes[4];
1453
1454         if (fd == -1)
1455         {
1456                 Sys_Error ("Couldn't open %s", path);
1457                 return 0;
1458         }
1459         if (offs < 0 || len < 0)
1460         {
1461                 // normal file
1462                 offs = 0;
1463                 len = lseek (fd, 0, SEEK_END);
1464                 lseek (fd, 0, SEEK_SET);
1465         }
1466         lseek (fd, offs, SEEK_SET);
1467         if (zip)
1468         {
1469                 read (fd, id, 2);
1470                 if (id[0] == 0x1f && id[1] == 0x8b)
1471                 {
1472                         lseek (fd, offs + len - 4, SEEK_SET);
1473                         read (fd, len_bytes, 4);
1474                         len = ((len_bytes[3] << 24)
1475                                    | (len_bytes[2] << 16)
1476                                    | (len_bytes[1] << 8)
1477                                    | (len_bytes[0]));
1478                 }
1479         }
1480         lseek (fd, offs, SEEK_SET);
1481         com_filesize = len;
1482
1483 #ifdef WIN32
1484         setmode (fd, O_BINARY);
1485 #endif
1486         if (zip)
1487                 return Qdopen (fd, "rbz");
1488         else
1489                 return Qdopen (fd, "rb");
1490 }
1491
1492 /*
1493 ===========
1494 COM_FindFile
1495
1496 Finds the file in the search path.
1497 Sets com_filesize and one of handle or file
1498 ===========
1499 */
1500 int COM_FindFile (char *filename, QFile **file, qboolean quiet, qboolean zip)
1501 {
1502         searchpath_t    *search;
1503         char                    netpath[MAX_OSPATH];
1504 #if CACHEENABLE
1505         char                    cachepath[MAX_OSPATH];
1506         int                             cachetime;
1507 #endif
1508         pack_t                  *pak;
1509         int                             i;
1510         int                             findtime;
1511         char                    gzfilename[MAX_OSPATH];
1512         int                             filenamelen;
1513
1514         filenamelen = strlen (filename);
1515         sprintf (gzfilename, "%s.gz", filename);
1516
1517         if (!file)
1518                 Sys_Error ("COM_FindFile: file not set");
1519                 
1520 //
1521 // search through the path, one element at a time
1522 //
1523         search = com_searchpaths;
1524 //      if (proghack)
1525 //      {       // gross hack to use quake 1 progs with quake 2 maps
1526 //              if (!strcmp(filename, "progs.dat"))
1527 //                      search = search->next;
1528 //      }
1529
1530         for ( ; search ; search = search->next)
1531         {
1532         // is the element a pak file?
1533                 if (search->pack)
1534                 {
1535                 // look through all the pak file elements
1536                         pak = search->pack;
1537                         for (i=0 ; i<pak->numfiles ; i++)
1538                                 if (!strcmp (pak->files[i].name, filename)
1539                                     || !strcmp (pak->files[i].name, gzfilename))
1540                                 {       // found it!
1541                                         if (!quiet)
1542                                                 Sys_Printf ("PackFile: %s : %s\n",pak->filename, pak->files[i].name);
1543                                         // open a new file on the pakfile
1544                                         *file = COM_OpenRead (pak->filename, pak->files[i].filepos, pak->files[i].filelen, zip);
1545                                         return com_filesize;
1546                                 }
1547                 }
1548                 else
1549                 {               
1550         // check a file in the directory tree
1551 //                      if (!static_registered)
1552 //                      {       // if not a registered version, don't ever go beyond base
1553 //                              if ( strchr (filename, '/') || strchr (filename,'\\'))
1554 //                                      continue;
1555 //                      }
1556                         
1557                         sprintf (netpath, "%s/%s",search->filename, filename);
1558                         
1559                         findtime = Sys_FileTime (netpath);
1560                         if (findtime == -1)
1561                                 continue;
1562                                 
1563 #if CACHEENABLE
1564                         // see if the file needs to be updated in the cache
1565                         if (com_cachedir[0])
1566                         {       
1567 #if defined(_WIN32)
1568                                 if ((strlen(netpath) < 2) || (netpath[1] != ':'))
1569                                         sprintf (cachepath,"%s%s", com_cachedir, netpath);
1570                                 else
1571                                         sprintf (cachepath,"%s%s", com_cachedir, netpath+2);
1572 #else
1573                                 sprintf (cachepath,"%s%s", com_cachedir, netpath);
1574 #endif
1575
1576                                 cachetime = Sys_FileTime (cachepath);
1577                         
1578                                 if (cachetime < findtime)
1579                                         COM_CopyFile (netpath, cachepath);
1580                                 strcpy (netpath, cachepath);
1581                         }       
1582 #endif
1583
1584                         if (!quiet)
1585                                 Sys_Printf ("FindFile: %s\n",netpath);
1586                         *file = COM_OpenRead (netpath, -1, -1, zip);
1587                         return com_filesize;
1588                 }
1589                 
1590         }
1591         
1592         if (!quiet)
1593                 Sys_Printf ("FindFile: can't find %s\n", filename);
1594         
1595         *file = NULL;
1596         com_filesize = -1;
1597         return -1;
1598 }
1599
1600
1601 /*
1602 ===========
1603 COM_FOpenFile
1604
1605 If the requested file is inside a packfile, a new QFile * will be opened
1606 into the file.
1607 ===========
1608 */
1609 int COM_FOpenFile (char *filename, QFile **file, qboolean quiet, qboolean zip)
1610 {
1611         return COM_FindFile (filename, file, quiet, zip);
1612 }
1613
1614
1615 /*
1616 ============
1617 COM_LoadFile
1618
1619 Filename are reletive to the quake directory.
1620 Always appends a 0 byte.
1621 ============
1622 */
1623 byte                    *loadbuf;
1624 int                             loadsize;
1625 byte *COM_LoadFile (char *path, qboolean quiet)
1626 {
1627         QFile             *h;
1628         byte    *buf;
1629         char    base[1024];
1630         int             len;
1631
1632         buf = NULL;     // quiet compiler warning
1633         loadsize = 0;
1634
1635 // look for it in the filesystem or pack files
1636         len = COM_FOpenFile (path, &h, quiet, true);
1637         if (!h)
1638                 return NULL;
1639
1640         loadsize = len;
1641
1642 // extract the filename base name for hunk tag
1643         COM_FileBase (path, base);
1644
1645         buf = Mem_Alloc(tempmempool, len+1);
1646         if (!buf)
1647                 Sys_Error ("COM_LoadFile: not enough available memory for %s (size %i)", path, len);
1648
1649         ((byte *)buf)[len] = 0;
1650
1651         Qread (h, buf, len);
1652         Qclose (h);
1653
1654         return buf;
1655 }
1656
1657 /*
1658 =================
1659 COM_LoadPackFile
1660
1661 Takes an explicit (not game tree related) path to a pak file.
1662
1663 Loads the header and directory, adding the files at the beginning
1664 of the list so they override previous pack files.
1665 =================
1666 */
1667 pack_t *COM_LoadPackFile (char *packfile)
1668 {
1669         dpackheader_t   header;
1670         int                             i;
1671         int                             numpackfiles;
1672         pack_t                  *pack;
1673         int                             packhandle;
1674         // LordHavoc: changed from stack array to temporary alloc, allowing huge pack directories
1675         dpackfile_t             *info;
1676
1677         if (Sys_FileOpenRead (packfile, &packhandle) == -1)
1678         {
1679                 //Con_Printf ("Couldn't open %s\n", packfile);
1680                 return NULL;
1681         }
1682         Sys_FileRead (packhandle, (void *)&header, sizeof(header));
1683         if (memcmp(header.id, "PACK", 4))
1684                 Sys_Error ("%s is not a packfile", packfile);
1685         header.dirofs = LittleLong (header.dirofs);
1686         header.dirlen = LittleLong (header.dirlen);
1687
1688         if (header.dirlen % sizeof(dpackfile_t))
1689                 Sys_Error ("%s has an invalid directory size", packfile);
1690
1691         numpackfiles = header.dirlen / sizeof(dpackfile_t);
1692
1693         if (numpackfiles > MAX_FILES_IN_PACK)
1694                 Sys_Error ("%s has %i files", packfile, numpackfiles);
1695
1696         pack = Mem_Alloc(pak_mempool, sizeof (pack_t));
1697         strcpy (pack->filename, packfile);
1698         pack->handle = packhandle;
1699         pack->numfiles = numpackfiles;
1700         pack->mempool = Mem_AllocPool(packfile);
1701         pack->files = Mem_Alloc(pack->mempool, numpackfiles * sizeof(packfile_t));
1702         pack->next = packlist;
1703         packlist = pack;
1704
1705         info = Mem_Alloc(tempmempool, sizeof(*info) * numpackfiles);
1706         Sys_FileSeek (packhandle, header.dirofs);
1707         Sys_FileRead (packhandle, (void *)info, header.dirlen);
1708
1709 // parse the directory
1710         for (i = 0;i < numpackfiles;i++)
1711         {
1712                 strcpy (pack->files[i].name, info[i].name);
1713                 pack->files[i].filepos = LittleLong(info[i].filepos);
1714                 pack->files[i].filelen = LittleLong(info[i].filelen);
1715         }
1716
1717         Mem_Free(info);
1718
1719         Con_Printf ("Added packfile %s (%i files)\n", packfile, numpackfiles);
1720         return pack;
1721 }
1722
1723
1724 /*
1725 ================
1726 COM_AddGameDirectory
1727
1728 Sets com_gamedir, adds the directory to the head of the path,
1729 then loads and adds pak1.pak pak2.pak ...
1730 ================
1731 */
1732 void COM_AddGameDirectory (char *dir)
1733 {
1734         int                             i;
1735         searchpath_t    *search;
1736         pack_t                  *pak;
1737         char                    pakfile[MAX_OSPATH];
1738
1739         strcpy (com_gamedir, dir);
1740
1741 //
1742 // add the directory to the search path
1743 //
1744         search = Mem_Alloc(pak_mempool, sizeof(searchpath_t));
1745         strcpy (search->filename, dir);
1746         search->next = com_searchpaths;
1747         com_searchpaths = search;
1748
1749 //
1750 // add any pak files in the format pak0.pak pak1.pak, ...
1751 //
1752         for (i=0 ; ; i++)
1753         {
1754                 sprintf (pakfile, "%s/pak%i.pak", dir, i);
1755                 pak = COM_LoadPackFile (pakfile);
1756                 if (!pak)
1757                         break;
1758                 search = Mem_Alloc(pak_mempool, sizeof(searchpath_t));
1759                 search->pack = pak;
1760                 search->next = com_searchpaths;
1761                 com_searchpaths = search;
1762         }
1763
1764 //
1765 // add the contents of the parms.txt file to the end of the command line
1766 //
1767
1768 }
1769
1770 /*
1771 ================
1772 COM_InitFilesystem
1773 ================
1774 */
1775 void COM_InitFilesystem (void)
1776 {
1777         int             i, j;
1778         char    basedir[MAX_OSPATH];
1779         searchpath_t    *search;
1780
1781 //
1782 // -basedir <path>
1783 // Overrides the system supplied base directory (under GAMENAME)
1784 //
1785         i = COM_CheckParm ("-basedir");
1786         if (i && i < com_argc-1)
1787                 strcpy (basedir, com_argv[i+1]);
1788         else
1789                 strcpy (basedir, host_parms.basedir);
1790
1791         j = strlen (basedir);
1792
1793         if (j > 0)
1794         {
1795                 if ((basedir[j-1] == '\\') || (basedir[j-1] == '/'))
1796                         basedir[j-1] = 0;
1797         }
1798
1799 #if CACHEENABLE
1800 //
1801 // -cachedir <path>
1802 // Overrides the system supplied cache directory (NULL or /qcache)
1803 // -cachedir - will disable caching.
1804 //
1805         i = COM_CheckParm ("-cachedir");
1806         if (i && i < com_argc-1)
1807         {
1808                 if (com_argv[i+1][0] == '-')
1809                         com_cachedir[0] = 0;
1810                 else
1811                         strcpy (com_cachedir, com_argv[i+1]);
1812         }
1813         else if (host_parms.cachedir)
1814                 strcpy (com_cachedir, host_parms.cachedir);
1815         else
1816                 com_cachedir[0] = 0;
1817 #endif
1818
1819 // start up with GAMENAME by default (id1)
1820         COM_AddGameDirectory (va("%s/"GAMENAME, basedir) );
1821
1822         switch(gamemode)
1823         {
1824         case GAME_NORMAL:
1825                 break;
1826         case GAME_HIPNOTIC:
1827                 COM_AddGameDirectory (va("%s/hipnotic", basedir) );
1828                 break;
1829         case GAME_ROGUE:
1830                 COM_AddGameDirectory (va("%s/rogue", basedir) );
1831                 break;
1832         case GAME_NEHAHRA:
1833                 COM_AddGameDirectory (va("%s/nehahra", basedir) );
1834                 break;
1835         case GAME_FIENDARENA:
1836                 COM_AddGameDirectory (va("%s/fiendarena", basedir) );
1837                 break;
1838         case GAME_ZYMOTIC:
1839                 COM_AddGameDirectory (va("%s/zymotic", basedir) );
1840                 break;
1841         default:
1842                 Sys_Error("COM_InitFilesystem: unknown gamemode %i\n", gamemode);
1843                 break;
1844         }
1845
1846 //
1847 // -game <gamedir>
1848 // Adds basedir/gamedir as an override game
1849 //
1850         i = COM_CheckParm ("-game");
1851         if (i && i < com_argc-1)
1852         {
1853                 com_modified = true;
1854                 COM_AddGameDirectory (va("%s/%s", basedir, com_argv[i+1]));
1855         }
1856
1857 //
1858 // -path <dir or packfile> [<dir or packfile>] ...
1859 // Fully specifies the exact search path, overriding the generated one
1860 //
1861         i = COM_CheckParm ("-path");
1862         if (i)
1863         {
1864                 com_modified = true;
1865                 com_searchpaths = NULL;
1866                 while (++i < com_argc)
1867                 {
1868                         if (!com_argv[i] || com_argv[i][0] == '+' || com_argv[i][0] == '-')
1869                                 break;
1870
1871                         search = Mem_Alloc(pak_mempool, sizeof(searchpath_t));
1872                         if ( !strcmp(COM_FileExtension(com_argv[i]), "pak") )
1873                         {
1874                                 search->pack = COM_LoadPackFile (com_argv[i]);
1875                                 if (!search->pack)
1876                                         Sys_Error ("Couldn't load packfile: %s", com_argv[i]);
1877                         }
1878                         else
1879                                 strcpy (search->filename, com_argv[i]);
1880                         search->next = com_searchpaths;
1881                         com_searchpaths = search;
1882                 }
1883         }
1884
1885 //      if (COM_CheckParm ("-proghack"))
1886 //              proghack = true;
1887 }
1888
1889 int COM_FileExists(char *filename)
1890 {
1891         searchpath_t    *search;
1892         char                    netpath[MAX_OSPATH];
1893         pack_t                  *pak;
1894         int                             i;
1895         int                             findtime;
1896
1897         for (search = com_searchpaths;search;search = search->next)
1898         {
1899                 if (search->pack)
1900                 {
1901                         pak = search->pack;
1902                         for (i = 0;i < pak->numfiles;i++)
1903                                 if (!strcmp (pak->files[i].name, filename))
1904                                         return true;
1905                 }
1906                 else
1907                 {
1908                         sprintf (netpath, "%s/%s",search->filename, filename);
1909                         findtime = Sys_FileTime (netpath);
1910                         if (findtime != -1)
1911                                 return true;
1912                 }               
1913         }
1914
1915         return false;
1916 }
1917
1918
1919 //======================================
1920 // LordHavoc: added these because they are useful
1921
1922 void COM_ToLowerString(char *in, char *out)
1923 {
1924         while (*in)
1925         {
1926                 if (*in >= 'A' && *in <= 'Z')
1927                         *out++ = *in++ + 'a' - 'A';
1928                 else
1929                         *out++ = *in++;
1930         }
1931 }
1932
1933 void COM_ToUpperString(char *in, char *out)
1934 {
1935         while (*in)
1936         {
1937                 if (*in >= 'a' && *in <= 'z')
1938                         *out++ = *in++ + 'A' - 'a';
1939                 else
1940                         *out++ = *in++;
1941         }
1942 }