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