allow 64 directories, no longer 8
[divverent/netradiant.git] / tools / quake3 / common / cmdlib.c
1 /*
2 Copyright (C) 1999-2006 Id Software, Inc. and contributors.
3 For a list of contributors, see the accompanying CONTRIBUTORS file.
4
5 This file is part of GtkRadiant.
6
7 GtkRadiant is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
12 GtkRadiant is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GtkRadiant; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
20 */
21
22 // cmdlib.c
23 // TTimo 09/30/2000
24 // from an intial copy of common/cmdlib.c
25 // stripped out the Sys_Printf Sys_Printf stuff
26
27 // SPoG 05/27/2001
28 // merging alpha branch into trunk
29 // replaced qprintf with Sys_Printf 
30
31 #include "cmdlib.h"
32 #include "mathlib.h"
33 #include "inout.h"
34 #include <sys/types.h>
35 #include <sys/stat.h>
36
37 #ifdef WIN32
38 #include <direct.h>
39 #include <windows.h>
40 #endif
41
42 #if defined (__linux__) || defined (__APPLE__)
43 #include <unistd.h>
44 #endif
45
46 #ifdef NeXT
47 #include <libc.h>
48 #endif
49
50 #define BASEDIRNAME     "quake"         // assumed to have a 2 or 3 following
51 #define PATHSEPERATOR   '/'
52
53 #ifdef SAFE_MALLOC
54 void *safe_malloc( size_t size )
55 {
56   void *p;
57
58   p = malloc(size);
59   if(!p)
60     Error ("safe_malloc failed on allocation of %i bytes", size);
61
62   return p;
63 }
64
65 void *safe_malloc_info( size_t size, char* info )
66 {
67   void *p;
68
69   p = malloc(size);
70   if(!p)
71     Error ("%s: safe_malloc failed on allocation of %i bytes", info, size);
72
73   return p;
74 }
75 #endif
76
77 // set these before calling CheckParm
78 int myargc;
79 char **myargv;
80
81 char            com_token[1024];
82 qboolean        com_eof;
83
84 qboolean                archive;
85 char                    archivedir[1024];
86
87
88 /*
89 ===================
90 ExpandWildcards
91
92 Mimic unix command line expansion
93 ===================
94 */
95 #define MAX_EX_ARGC     1024
96 int             ex_argc;
97 char    *ex_argv[MAX_EX_ARGC];
98 #ifdef _WIN32
99 #include "io.h"
100 void ExpandWildcards( int *argc, char ***argv )
101 {
102         struct _finddata_t fileinfo;
103         int             handle;
104         int             i;
105         char    filename[1024];
106         char    filebase[1024];
107         char    *path;
108
109         ex_argc = 0;
110         for (i=0 ; i<*argc ; i++)
111         {
112                 path = (*argv)[i];
113                 if ( path[0] == '-'
114                         || ( !strstr(path, "*") && !strstr(path, "?") ) )
115                 {
116                         ex_argv[ex_argc++] = path;
117                         continue;
118                 }
119
120                 handle = _findfirst (path, &fileinfo);
121                 if (handle == -1)
122                         return;
123
124                 ExtractFilePath (path, filebase);
125
126                 do
127                 {
128                         sprintf (filename, "%s%s", filebase, fileinfo.name);
129                         ex_argv[ex_argc++] = copystring (filename);
130                 } while (_findnext( handle, &fileinfo ) != -1);
131
132                 _findclose (handle);
133         }
134
135         *argc = ex_argc;
136         *argv = ex_argv;
137 }
138 #else
139 void ExpandWildcards (int *argc, char ***argv)
140 {
141 }
142 #endif
143
144 /*
145
146 qdir will hold the path up to the quake directory, including the slash
147
148   f:\quake\
149   /raid/quake/
150
151 gamedir will hold qdir + the game directory (id1, id2, etc)
152
153 */
154
155 char            qdir[1024];
156 char            gamedir[1024];
157 char            writedir[1024];
158
159 void SetQdirFromPath( const char *path )
160 {
161         char    temp[1024];
162         const char      *c;
163   const char *sep;
164         int             len, count;
165
166         if (!(path[0] == '/' || path[0] == '\\' || path[1] == ':'))
167         {       // path is partial
168                 Q_getwd (temp);
169                 strcat (temp, path);
170                 path = temp;
171         }
172
173         // search for "quake2" in path
174
175         len = strlen(BASEDIRNAME);
176         for (c=path+strlen(path)-1 ; c != path ; c--)
177         {
178                 int i;
179
180                 if (!Q_strncasecmp (c, BASEDIRNAME, len))
181                 {
182       //
183                         //strncpy (qdir, path, c+len+2-path);
184       // the +2 assumes a 2 or 3 following quake which is not the
185       // case with a retail install
186       // so we need to add up how much to the next separator
187       sep = c + len;
188       count = 1;
189       while (*sep && *sep != '/' && *sep != '\\')
190       {
191         sep++;
192         count++;
193       }
194                         strncpy (qdir, path, c+len+count-path);
195                         Sys_Printf ("qdir: %s\n", qdir);
196                         for ( i = 0; i < strlen( qdir ); i++ )
197                         {
198                                 if ( qdir[i] == '\\' ) 
199                                         qdir[i] = '/';
200                         }
201
202                         c += len+count;
203                         while (*c)
204                         {
205                                 if (*c == '/' || *c == '\\')
206                                 {
207                                         strncpy (gamedir, path, c+1-path);
208
209                                         for ( i = 0; i < strlen( gamedir ); i++ )
210                                         {
211                                                 if ( gamedir[i] == '\\' ) 
212                                                         gamedir[i] = '/';
213                                         }
214
215                                         Sys_Printf ("gamedir: %s\n", gamedir);
216
217                                         if ( !writedir[0] )
218                                                 strcpy( writedir, gamedir );
219                                         else if ( writedir[strlen( writedir )-1] != '/' )
220                                         {
221                                                 writedir[strlen( writedir )] = '/';
222                                                 writedir[strlen( writedir )+1] = 0;
223                                         }
224
225                                         return;
226                                 }
227                                 c++;
228                         }
229                         Error ("No gamedir in %s", path);
230                         return;
231                 }
232         }
233         Error ("SetQdirFromPath: no '%s' in %s", BASEDIRNAME, path);
234 }
235
236 char *ExpandArg (const char *path)
237 {
238         static char full[1024];
239
240         if (path[0] != '/' && path[0] != '\\' && path[1] != ':')
241         {
242                 Q_getwd (full);
243                 strcat (full, path);
244         }
245         else
246                 strcpy (full, path);
247         return full;
248 }
249
250 char *ExpandPath (const char *path)
251 {
252         static char full[1024];
253         if (!qdir)
254                 Error ("ExpandPath called without qdir set");
255         if (path[0] == '/' || path[0] == '\\' || path[1] == ':') {
256                 strcpy( full, path );
257                 return full;
258         }
259         sprintf (full, "%s%s", qdir, path);
260         return full;
261 }
262
263 char *ExpandGamePath (const char *path)
264 {
265         static char full[1024];
266         if (!qdir)
267                 Error ("ExpandGamePath called without qdir set");
268         if (path[0] == '/' || path[0] == '\\' || path[1] == ':') {
269                 strcpy( full, path );
270                 return full;
271         }
272         sprintf (full, "%s%s", gamedir, path);
273         return full;
274 }
275
276 char *ExpandPathAndArchive (const char *path)
277 {
278         char    *expanded;
279         char    archivename[1024];
280
281         expanded = ExpandPath (path);
282
283         if (archive)
284         {
285                 sprintf (archivename, "%s/%s", archivedir, path);
286                 QCopyFile (expanded, archivename);
287         }
288         return expanded;
289 }
290
291
292 char *copystring(const char *s)
293 {
294         char    *b;
295         b = safe_malloc(strlen(s)+1);
296         strcpy (b, s);
297         return b;
298 }
299
300
301
302 /*
303 ================
304 I_FloatTime
305 ================
306 */
307 double I_FloatTime (void)
308 {
309         time_t  t;
310         
311         time (&t);
312         
313         return t;
314 #if 0
315 // more precise, less portable
316         struct timeval tp;
317         struct timezone tzp;
318         static int              secbase;
319
320         gettimeofday(&tp, &tzp);
321         
322         if (!secbase)
323         {
324                 secbase = tp.tv_sec;
325                 return tp.tv_usec/1000000.0;
326         }
327         
328         return (tp.tv_sec - secbase) + tp.tv_usec/1000000.0;
329 #endif
330 }
331
332 void Q_getwd (char *out)
333 {
334         int i = 0;
335
336 #ifdef WIN32
337    _getcwd (out, 256);
338    strcat (out, "\\");
339 #else
340    // Gef: Changed from getwd() to getcwd() to avoid potential buffer overflow
341    getcwd (out, 256);
342    strcat (out, "/");
343 #endif
344    while ( out[i] != 0 )
345    {
346            if ( out[i] == '\\' )
347                    out[i] = '/';
348            i++;
349    }
350 }
351
352
353 void Q_mkdir (const char *path)
354 {
355         char parentbuf[256];
356         const char *p = NULL;
357         int retry = 2;
358         while(retry--)
359         {
360 #ifdef WIN32
361                 const char *q = NULL;
362                 if (_mkdir (path) != -1)
363                         return;
364                 if(errno == ENOENT)
365                 {
366                         p = strrchr(path, '/');
367                         q = strrchr(path, '\\');
368                         if(q && (!p || q < p))
369                                 p = q;
370                 }
371 #else
372                 if (mkdir (path, 0777) != -1)
373                         return;
374                 if(errno == ENOENT)
375                         p = strrchr(path, '/');
376 #endif
377                 if(p)
378                 {
379                         strncpy(parentbuf, path, sizeof(parentbuf));
380                         if((int) (p - path) < (int) sizeof(parentbuf))
381                         {
382                                 parentbuf[p - path] = 0;
383                                 Sys_Printf ("mkdir: %s: creating parent %s first\n", path, parentbuf);
384                                 Q_mkdir(parentbuf);
385                                 continue;
386                         }
387                 }
388                 break;
389         }
390         if (errno != EEXIST)
391                 Error ("mkdir %s: %s",path, strerror(errno));
392 }
393
394 /*
395 ============
396 FileTime
397
398 returns -1 if not present
399 ============
400 */
401 int     FileTime (const char *path)
402 {
403         struct  stat    buf;
404         
405         if (stat (path,&buf) == -1)
406                 return -1;
407         
408         return buf.st_mtime;
409 }
410
411
412
413 /*
414 ==============
415 COM_Parse
416
417 Parse a token out of a string
418 ==============
419 */
420 char *COM_Parse (char *data)
421 {
422         int             c;
423         int             len;
424         
425         len = 0;
426         com_token[0] = 0;
427         
428         if (!data)
429                 return NULL;
430                 
431 // skip whitespace
432 skipwhite:
433         while ( (c = *data) <= ' ')
434         {
435                 if (c == 0)
436                 {
437                         com_eof = qtrue;
438                         return NULL;                    // end of file;
439                 }
440                 data++;
441         }
442         
443 // skip // comments
444         if (c=='/' && data[1] == '/')
445         {
446                 while (*data && *data != '\n')
447                         data++;
448                 goto skipwhite;
449         }
450         
451
452 // handle quoted strings specially
453         if (c == '\"')
454         {
455                 data++;
456                 do
457                 {
458                         c = *data++;
459                         if (c=='\"')
460                         {
461                                 com_token[len] = 0;
462                                 return data;
463                         }
464                         com_token[len] = c;
465                         len++;
466                 } while (1);
467         }
468
469 // parse single characters
470         if (c=='{' || c=='}'|| c==')'|| c=='(' || c=='\'' || c==':')
471         {
472                 com_token[len] = c;
473                 len++;
474                 com_token[len] = 0;
475                 return data+1;
476         }
477
478 // parse a regular word
479         do
480         {
481                 com_token[len] = c;
482                 data++;
483                 len++;
484                 c = *data;
485         if (c=='{' || c=='}'|| c==')'|| c=='(' || c=='\'' || c==':')
486                         break;
487         } while (c>32);
488         
489         com_token[len] = 0;
490         return data;
491 }
492
493 int Q_strncasecmp (const char *s1, const char *s2, int n)
494 {
495         int             c1, c2;
496         
497         do
498         {
499                 c1 = *s1++;
500                 c2 = *s2++;
501
502                 if (!n--)
503                         return 0;               // strings are equal until end point
504                 
505                 if (c1 != c2)
506                 {
507                         if (c1 >= 'a' && c1 <= 'z')
508                                 c1 -= ('a' - 'A');
509                         if (c2 >= 'a' && c2 <= 'z')
510                                 c2 -= ('a' - 'A');
511                         if (c1 != c2)
512                                 return -1;              // strings not equal
513                 }
514         } while (c1);
515         
516         return 0;               // strings are equal
517 }
518
519 int Q_stricmp (const char *s1, const char *s2)
520 {
521         return Q_strncasecmp (s1, s2, 99999);
522 }
523
524 // NOTE TTimo when switching to Multithread DLL (Release/Debug) in the config
525 //   started getting warnings about that function, prolly a duplicate with the runtime function
526 //   maybe we still need to have it in linux builds
527 /*
528 char *strupr (char *start)
529 {
530         char    *in;
531         in = start;
532         while (*in)
533         {
534                 *in = toupper(*in);
535                 in++;
536         }
537         return start;
538 }
539 */
540
541 char *strlower (char *start)
542 {
543         char    *in;
544         in = start;
545         while (*in)
546         {
547                 *in = tolower(*in); 
548                 in++;
549         }
550         return start;
551 }
552
553
554 /*
555 =============================================================================
556
557                                                 MISC FUNCTIONS
558
559 =============================================================================
560 */
561
562
563 /*
564 =================
565 CheckParm
566
567 Checks for the given parameter in the program's command line arguments
568 Returns the argument number (1 to argc-1) or 0 if not present
569 =================
570 */
571 int CheckParm (const char *check)
572 {
573         int             i;
574
575         for (i = 1;i<myargc;i++)
576         {
577                 if ( !Q_stricmp(check, myargv[i]) )
578                         return i;
579         }
580
581         return 0;
582 }
583
584
585
586 /*
587 ================
588 Q_filelength
589 ================
590 */
591 int Q_filelength (FILE *f)
592 {
593         int             pos;
594         int             end;
595
596         pos = ftell (f);
597         fseek (f, 0, SEEK_END);
598         end = ftell (f);
599         fseek (f, pos, SEEK_SET);
600
601         return end;
602 }
603
604
605 FILE *SafeOpenWrite (const char *filename)
606 {
607         FILE    *f;
608
609         f = fopen(filename, "wb");
610
611         if (!f)
612                 Error ("Error opening %s: %s",filename,strerror(errno));
613
614         return f;
615 }
616
617 FILE *SafeOpenRead (const char *filename)
618 {
619         FILE    *f;
620
621         f = fopen(filename, "rb");
622
623         if (!f)
624                 Error ("Error opening %s: %s",filename,strerror(errno));
625
626         return f;
627 }
628
629
630 void SafeRead (FILE *f, void *buffer, int count)
631 {
632         if ( fread (buffer, 1, count, f) != (size_t)count)
633                 Error ("File read failure");
634 }
635
636
637 void SafeWrite (FILE *f, const void *buffer, int count)
638 {
639         if (fwrite (buffer, 1, count, f) != (size_t)count)
640                 Error ("File write failure");
641 }
642
643
644 /*
645 ==============
646 FileExists
647 ==============
648 */
649 qboolean        FileExists (const char *filename)
650 {
651         FILE    *f;
652
653         f = fopen (filename, "r");
654         if (!f)
655                 return qfalse;
656         fclose (f);
657         return qtrue;
658 }
659
660 /*
661 ==============
662 LoadFile
663 ==============
664 */
665 int    LoadFile( const char *filename, void **bufferptr )
666 {
667         FILE    *f;
668         int    length;
669         void    *buffer;
670
671         f = SafeOpenRead (filename);
672         length = Q_filelength (f);
673         buffer = safe_malloc (length+1);
674         ((char *)buffer)[length] = 0;
675         SafeRead (f, buffer, length);
676         fclose (f);
677
678         *bufferptr = buffer;
679         return length;
680 }
681
682
683 /*
684 ==============
685 LoadFileBlock
686 -
687 rounds up memory allocation to 4K boundry
688 -
689 ==============
690 */
691 int    LoadFileBlock( const char *filename, void **bufferptr )
692 {
693         FILE    *f;
694         int    length, nBlock, nAllocSize;
695         void    *buffer;
696
697         f = SafeOpenRead (filename);
698         length = Q_filelength (f);
699   nAllocSize = length;
700   nBlock = nAllocSize % MEM_BLOCKSIZE;
701   if ( nBlock > 0) {
702     nAllocSize += MEM_BLOCKSIZE - nBlock;
703   }
704         buffer = safe_malloc (nAllocSize+1);
705   memset(buffer, 0, nAllocSize+1);
706         SafeRead (f, buffer, length);
707         fclose (f);
708
709         *bufferptr = buffer;
710         return length;
711 }
712
713
714 /*
715 ==============
716 TryLoadFile
717
718 Allows failure
719 ==============
720 */
721 int    TryLoadFile (const char *filename, void **bufferptr)
722 {
723         FILE    *f;
724         int    length;
725         void    *buffer;
726
727         *bufferptr = NULL;
728
729         f = fopen (filename, "rb");
730         if (!f)
731                 return -1;
732         length = Q_filelength (f);
733         buffer = safe_malloc (length+1);
734         ((char *)buffer)[length] = 0;
735         SafeRead (f, buffer, length);
736         fclose (f);
737
738         *bufferptr = buffer;
739         return length;
740 }
741
742
743 /*
744 ==============
745 SaveFile
746 ==============
747 */
748 void    SaveFile (const char *filename, const void *buffer, int count)
749 {
750         FILE    *f;
751
752         f = SafeOpenWrite (filename);
753         SafeWrite (f, buffer, count);
754         fclose (f);
755 }
756
757
758
759 void DefaultExtension (char *path, const char *extension)
760 {
761         char    *src;
762 //
763 // if path doesnt have a .EXT, append extension
764 // (extension should include the .)
765 //
766         src = path + strlen(path) - 1;
767
768         while (*src != '/' && *src != '\\' && src != path)
769         {
770                 if (*src == '.')
771                         return;                 // it has an extension
772                 src--;
773         }
774
775         strcat (path, extension);
776 }
777
778
779 void DefaultPath (char *path, const char *basepath)
780 {
781         char    temp[128];
782
783         if( path[ 0 ] == '/' || path[ 0 ] == '\\' )
784                 return;                   // absolute path location
785         strcpy (temp,path);
786         strcpy (path,basepath);
787         strcat (path,temp);
788 }
789
790
791 void    StripFilename (char *path)
792 {
793         int             length;
794
795         length = strlen(path)-1;
796         while (length > 0 && path[length] != '/' && path[ length ] != '\\' )
797                 length--;
798         path[length] = 0;
799 }
800
801 void    StripExtension (char *path)
802 {
803         int             length;
804
805         length = strlen(path)-1;
806         while (length > 0 && path[length] != '.')
807         {
808                 length--;
809                 if (path[length] == '/' || path[ length ] == '\\' )
810                         return;         // no extension
811         }
812         if (length)
813                 path[length] = 0;
814 }
815
816
817 /*
818 ====================
819 Extract file parts
820 ====================
821 */
822 // FIXME: should include the slash, otherwise
823 // backing to an empty path will be wrong when appending a slash
824 void ExtractFilePath (const char *path, char *dest)
825 {
826         const char    *src;
827
828         src = path + strlen(path) - 1;
829
830 //
831 // back up until a \ or the start
832 //
833         while (src != path && *(src-1) != '\\' && *(src-1) != '/')
834                 src--;
835
836         memcpy (dest, path, src-path);
837         dest[src-path] = 0;
838 }
839
840 void ExtractFileBase (const char *path, char *dest)
841 {
842         const char    *src;
843
844         src = path + strlen(path) - 1;
845
846 //
847 // back up until a \ or the start
848 //
849         while (src != path && *(src-1) != '/' && *(src-1) != '\\' )
850                 src--;
851
852         while (*src && *src != '.')
853         {
854                 *dest++ = *src++;
855         }
856         *dest = 0;
857 }
858
859 void ExtractFileExtension (const char *path, char *dest)
860 {
861         const char    *src;
862
863         src = path + strlen(path) - 1;
864
865 //
866 // back up until a . or the start
867 //
868         while (src != path && *(src-1) != '.')
869                 src--;
870         if (src == path)
871         {
872                 *dest = 0;      // no extension
873                 return;
874         }
875
876         strcpy (dest,src);
877 }
878
879
880 /*
881 ==============
882 ParseNum / ParseHex
883 ==============
884 */
885 int ParseHex (const char *hex)
886 {
887         const char    *str;
888         int    num;
889
890         num = 0;
891         str = hex;
892
893         while (*str)
894         {
895                 num <<= 4;
896                 if (*str >= '0' && *str <= '9')
897                         num += *str-'0';
898                 else if (*str >= 'a' && *str <= 'f')
899                         num += 10 + *str-'a';
900                 else if (*str >= 'A' && *str <= 'F')
901                         num += 10 + *str-'A';
902                 else
903                         Error ("Bad hex number: %s",hex);
904                 str++;
905         }
906
907         return num;
908 }
909
910
911 int ParseNum (const char *str)
912 {
913         if (str[0] == '$')
914                 return ParseHex (str+1);
915         if (str[0] == '0' && str[1] == 'x')
916                 return ParseHex (str+2);
917         return atol (str);
918 }
919
920
921
922 /*
923 ============================================================================
924
925                                         BYTE ORDER FUNCTIONS
926
927 ============================================================================
928 */
929
930 #ifdef _SGI_SOURCE
931 #define __BIG_ENDIAN__
932 #endif
933
934 #ifdef __BIG_ENDIAN__
935
936 short   LittleShort (short l)
937 {
938         byte    b1,b2;
939
940         b1 = l&255;
941         b2 = (l>>8)&255;
942
943         return (b1<<8) + b2;
944 }
945
946 short   BigShort (short l)
947 {
948         return l;
949 }
950
951
952 int    LittleLong (int l)
953 {
954         byte    b1,b2,b3,b4;
955
956         b1 = l&255;
957         b2 = (l>>8)&255;
958         b3 = (l>>16)&255;
959         b4 = (l>>24)&255;
960
961         return ((int)b1<<24) + ((int)b2<<16) + ((int)b3<<8) + b4;
962 }
963
964 int    BigLong (int l)
965 {
966         return l;
967 }
968
969
970 float   LittleFloat (float l)
971 {
972         union {byte b[4]; float f;} in, out;
973         
974         in.f = l;
975         out.b[0] = in.b[3];
976         out.b[1] = in.b[2];
977         out.b[2] = in.b[1];
978         out.b[3] = in.b[0];
979         
980         return out.f;
981 }
982
983 float   BigFloat (float l)
984 {
985         return l;
986 }
987
988
989 #else
990
991
992 short   BigShort (short l)
993 {
994         byte    b1,b2;
995
996         b1 = l&255;
997         b2 = (l>>8)&255;
998
999         return (b1<<8) + b2;
1000 }
1001
1002 short   LittleShort (short l)
1003 {
1004         return l;
1005 }
1006
1007
1008 int    BigLong (int l)
1009 {
1010         byte    b1,b2,b3,b4;
1011
1012         b1 = l&255;
1013         b2 = (l>>8)&255;
1014         b3 = (l>>16)&255;
1015         b4 = (l>>24)&255;
1016
1017         return ((int)b1<<24) + ((int)b2<<16) + ((int)b3<<8) + b4;
1018 }
1019
1020 int    LittleLong (int l)
1021 {
1022         return l;
1023 }
1024
1025 float   BigFloat (float l)
1026 {
1027         union {byte b[4]; float f;} in, out;
1028         
1029         in.f = l;
1030         out.b[0] = in.b[3];
1031         out.b[1] = in.b[2];
1032         out.b[2] = in.b[1];
1033         out.b[3] = in.b[0];
1034         
1035         return out.f;
1036 }
1037
1038 float   LittleFloat (float l)
1039 {
1040         return l;
1041 }
1042
1043
1044 #endif
1045
1046
1047 //=======================================================
1048
1049
1050 // FIXME: byte swap?
1051
1052 // this is a 16 bit, non-reflected CRC using the polynomial 0x1021
1053 // and the initial and final xor values shown below...  in other words, the
1054 // CCITT standard CRC used by XMODEM
1055
1056 #define CRC_INIT_VALUE  0xffff
1057 #define CRC_XOR_VALUE   0x0000
1058
1059 static unsigned short crctable[256] =
1060 {
1061         0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7,
1062         0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef,
1063         0x1231, 0x0210, 0x3273, 0x2252, 0x52b5, 0x4294, 0x72f7, 0x62d6,
1064         0x9339, 0x8318, 0xb37b, 0xa35a, 0xd3bd, 0xc39c, 0xf3ff, 0xe3de,
1065         0x2462, 0x3443, 0x0420, 0x1401, 0x64e6, 0x74c7, 0x44a4, 0x5485,
1066         0xa56a, 0xb54b, 0x8528, 0x9509, 0xe5ee, 0xf5cf, 0xc5ac, 0xd58d,
1067         0x3653, 0x2672, 0x1611, 0x0630, 0x76d7, 0x66f6, 0x5695, 0x46b4,
1068         0xb75b, 0xa77a, 0x9719, 0x8738, 0xf7df, 0xe7fe, 0xd79d, 0xc7bc,
1069         0x48c4, 0x58e5, 0x6886, 0x78a7, 0x0840, 0x1861, 0x2802, 0x3823,
1070         0xc9cc, 0xd9ed, 0xe98e, 0xf9af, 0x8948, 0x9969, 0xa90a, 0xb92b,
1071         0x5af5, 0x4ad4, 0x7ab7, 0x6a96, 0x1a71, 0x0a50, 0x3a33, 0x2a12,
1072         0xdbfd, 0xcbdc, 0xfbbf, 0xeb9e, 0x9b79, 0x8b58, 0xbb3b, 0xab1a,
1073         0x6ca6, 0x7c87, 0x4ce4, 0x5cc5, 0x2c22, 0x3c03, 0x0c60, 0x1c41,
1074         0xedae, 0xfd8f, 0xcdec, 0xddcd, 0xad2a, 0xbd0b, 0x8d68, 0x9d49,
1075         0x7e97, 0x6eb6, 0x5ed5, 0x4ef4, 0x3e13, 0x2e32, 0x1e51, 0x0e70,
1076         0xff9f, 0xefbe, 0xdfdd, 0xcffc, 0xbf1b, 0xaf3a, 0x9f59, 0x8f78,
1077         0x9188, 0x81a9, 0xb1ca, 0xa1eb, 0xd10c, 0xc12d, 0xf14e, 0xe16f,
1078         0x1080, 0x00a1, 0x30c2, 0x20e3, 0x5004, 0x4025, 0x7046, 0x6067,
1079         0x83b9, 0x9398, 0xa3fb, 0xb3da, 0xc33d, 0xd31c, 0xe37f, 0xf35e,
1080         0x02b1, 0x1290, 0x22f3, 0x32d2, 0x4235, 0x5214, 0x6277, 0x7256,
1081         0xb5ea, 0xa5cb, 0x95a8, 0x8589, 0xf56e, 0xe54f, 0xd52c, 0xc50d,
1082         0x34e2, 0x24c3, 0x14a0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
1083         0xa7db, 0xb7fa, 0x8799, 0x97b8, 0xe75f, 0xf77e, 0xc71d, 0xd73c,
1084         0x26d3, 0x36f2, 0x0691, 0x16b0, 0x6657, 0x7676, 0x4615, 0x5634,
1085         0xd94c, 0xc96d, 0xf90e, 0xe92f, 0x99c8, 0x89e9, 0xb98a, 0xa9ab,
1086         0x5844, 0x4865, 0x7806, 0x6827, 0x18c0, 0x08e1, 0x3882, 0x28a3,
1087         0xcb7d, 0xdb5c, 0xeb3f, 0xfb1e, 0x8bf9, 0x9bd8, 0xabbb, 0xbb9a,
1088         0x4a75, 0x5a54, 0x6a37, 0x7a16, 0x0af1, 0x1ad0, 0x2ab3, 0x3a92,
1089         0xfd2e, 0xed0f, 0xdd6c, 0xcd4d, 0xbdaa, 0xad8b, 0x9de8, 0x8dc9,
1090         0x7c26, 0x6c07, 0x5c64, 0x4c45, 0x3ca2, 0x2c83, 0x1ce0, 0x0cc1,
1091         0xef1f, 0xff3e, 0xcf5d, 0xdf7c, 0xaf9b, 0xbfba, 0x8fd9, 0x9ff8,
1092         0x6e17, 0x7e36, 0x4e55, 0x5e74, 0x2e93, 0x3eb2, 0x0ed1, 0x1ef0
1093 };
1094
1095 void CRC_Init(unsigned short *crcvalue)
1096 {
1097         *crcvalue = CRC_INIT_VALUE;
1098 }
1099
1100 void CRC_ProcessByte(unsigned short *crcvalue, byte data)
1101 {
1102         *crcvalue = (*crcvalue << 8) ^ crctable[(*crcvalue >> 8) ^ data];
1103 }
1104
1105 unsigned short CRC_Value(unsigned short crcvalue)
1106 {
1107         return crcvalue ^ CRC_XOR_VALUE;
1108 }
1109 //=============================================================================
1110
1111 /*
1112 ============
1113 CreatePath
1114 ============
1115 */
1116 void    CreatePath (const char *path)
1117 {
1118         const char      *ofs;
1119         char            c;
1120         char            dir[1024];
1121
1122 #ifdef _WIN32
1123         int             olddrive = -1;
1124
1125         if ( path[1] == ':' )
1126         {
1127                 olddrive = _getdrive();
1128                 _chdrive( toupper( path[0] ) - 'A' + 1 );
1129         }
1130 #endif
1131
1132         if (path[1] == ':')
1133                 path += 2;
1134
1135         for (ofs = path+1 ; *ofs ; ofs++)
1136         {
1137                 c = *ofs;
1138                 if (c == '/' || c == '\\')
1139                 {       // create the directory
1140                         memcpy( dir, path, ofs - path );
1141                         dir[ ofs - path ] = 0;
1142                         Q_mkdir( dir );
1143                 }
1144         }
1145
1146 #ifdef _WIN32
1147         if ( olddrive != -1 )
1148         {
1149                 _chdrive( olddrive );
1150         }
1151 #endif
1152 }
1153
1154
1155 /*
1156 ============
1157 QCopyFile
1158
1159   Used to archive source files
1160 ============
1161 */
1162 void QCopyFile (const char *from, const char *to)
1163 {
1164         void    *buffer;
1165         int             length;
1166
1167         length = LoadFile (from, &buffer);
1168         CreatePath (to);
1169         SaveFile (to, buffer, length);
1170         free (buffer);
1171 }
1172
1173 void Sys_Sleep(int n)
1174 {
1175 #ifdef WIN32
1176   Sleep (n);
1177 #endif
1178 #if defined (__linux__) || defined (__APPLE__)
1179   usleep (n * 1000);
1180 #endif
1181 }