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 < (int) 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 < (int) 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 || path[0] == '/' || path[0] == '\\' || path[1] == ':') {
 254                 strcpy( full, path );
 255                 return full;
 256         }
 257         sprintf (full, "%s%s", qdir, path);
 258         return full;
 259 }
 260
 261 char *ExpandGamePath (const char *path)
 262 {
 263         static char full[1024];
 264         if (!*gamedir)
 265                 Error ("ExpandGamePath called without gamedir set");
 266         if (path[0] == '/' || path[0] == '\\' || path[1] == ':') {
 267                 strcpy( full, path );
 268                 return full;
 269         }
 270         sprintf (full, "%s%s", gamedir, path);
 271         return full;
 272 }
 273
 274 char *ExpandPathAndArchive (const char *path)
 275 {
 276         char    *expanded;
 277         char    archivename[1024];
 278
 279         expanded = ExpandPath (path);
 280
 281         if (archive)
 282         {
 283                 sprintf (archivename, "%s/%s", archivedir, path);
 284                 QCopyFile (expanded, archivename);
 285         }
 286         return expanded;
 287 }
 288
 289
 290 char *copystring(const char *s)
 291 {
 292         char    *b;
 293         b = safe_malloc(strlen(s)+1);
 294         strcpy (b, s);
 295         return b;
 296 }
 297
 298
 299
 300 /*
 301 ================
 302 I_FloatTime
 303 ================
 304 */
 305 double I_FloatTime (void)
 306 {
 307         time_t  t;
 308
 309         time (&t);
 310
 311         return t;
 312 #if 0
 313 // more precise, less portable
 314         struct timeval tp;
 315         struct timezone tzp;
 316         static int              secbase;
 317
 318         gettimeofday(&tp, &tzp);
 319
 320         if (!secbase)
 321         {
 322                 secbase = tp.tv_sec;
 323                 return tp.tv_usec/1000000.0;
 324         }
 325
 326         return (tp.tv_sec - secbase) + tp.tv_usec/1000000.0;
 327 #endif
 328 }
 329
 330 void Q_getwd (char *out)
 331 {
 332         int i = 0;
 333
 334 #ifdef WIN32
 335    _getcwd (out, 256);
 336    strcat (out, "\\");
 337 #else
 338    // Gef: Changed from getwd() to getcwd() to avoid potential buffer overflow
 339    getcwd (out, 256);
 340    strcat (out, "/");
 341 #endif
 342    while ( out[i] != 0 )
 343    {
 344            if ( out[i] == '\\' )
 345                    out[i] = '/';
 346            i++;
 347    }
 348 }
 349
 350
 351 void Q_mkdir (const char *path)
 352 {
 353         char parentbuf[256];
 354         const char *p = NULL;
 355         int retry = 2;
 356         while(retry--)
 357         {
 358 #ifdef WIN32
 359                 const char *q = NULL;
 360                 if (_mkdir (path) != -1)
 361                         return;
 362                 if(errno == ENOENT)
 363                 {
 364                         p = strrchr(path, '/');
 365                         q = strrchr(path, '\\');
 366                         if(q && (!p || q < p))
 367                                 p = q;
 368                 }
 369 #else
 370                 if (mkdir (path, 0777) != -1)
 371                         return;
 372                 if(errno == ENOENT)
 373                         p = strrchr(path, '/');
 374 #endif
 375                 if(p)
 376                 {
 377                         strncpy(parentbuf, path, sizeof(parentbuf));
 378                         if((int) (p - path) < (int) sizeof(parentbuf))
 379                         {
 380                                 parentbuf[p - path] = 0;
 381                                 Sys_Printf ("mkdir: %s: creating parent %s first\n", path, parentbuf);
 382                                 Q_mkdir(parentbuf);
 383                                 continue;
 384                         }
 385                 }
 386                 break;
 387         }
 388         if (errno != EEXIST)
 389                 Error ("mkdir %s: %s",path, strerror(errno));
 390 }
 391
 392 /*
 393 ============
 394 FileTime
 395
 396 returns -1 if not present
 397 ============
 398 */
 399 int     FileTime (const char *path)
 400 {
 401         struct  stat    buf;
 402
 403         if (stat (path,&buf) == -1)
 404                 return -1;
 405
 406         return buf.st_mtime;
 407 }
 408
 409
 410
 411 /*
 412 ==============
 413 COM_Parse
 414
 415 Parse a token out of a string
 416 ==============
 417 */
 418 char *COM_Parse (char *data)
 419 {
 420         int             c;
 421         int             len;
 422
 423         len = 0;
 424         com_token[0] = 0;
 425
 426         if (!data)
 427                 return NULL;
 428
 429 // skip whitespace
 430 skipwhite:
 431         while ( (c = *data) <= ' ')
 432         {
 433                 if (c == 0)
 434                 {
 435                         com_eof = qtrue;
 436                         return NULL;                    // end of file;
 437                 }
 438                 data++;
 439         }
 440
 441 // skip // comments
 442         if (c=='/' && data[1] == '/')
 443         {
 444                 while (*data && *data != '\n')
 445                         data++;
 446                 goto skipwhite;
 447         }
 448
 449
 450 // handle quoted strings specially
 451         if (c == '\"')
 452         {
 453                 data++;
 454                 do
 455                 {
 456                         c = *data++;
 457                         if (c=='\"')
 458                         {
 459                                 com_token[len] = 0;
 460                                 return data;
 461                         }
 462                         com_token[len] = c;
 463                         len++;
 464                 } while (1);
 465         }
 466
 467 // parse single characters
 468         if (c=='{' || c=='}'|| c==')'|| c=='(' || c=='\'' || c==':')
 469         {
 470                 com_token[len] = c;
 471                 len++;
 472                 com_token[len] = 0;
 473                 return data+1;
 474         }
 475
 476 // parse a regular word
 477         do
 478         {
 479                 com_token[len] = c;
 480                 data++;
 481                 len++;
 482                 c = *data;
 483         if (c=='{' || c=='}'|| c==')'|| c=='(' || c=='\'' || c==':')
 484                         break;
 485         } while (c>32);
 486
 487         com_token[len] = 0;
 488         return data;
 489 }
 490
 491 int Q_strncasecmp (const char *s1, const char *s2, int n)
 492 {
 493         int             c1, c2;
 494
 495         do
 496         {
 497                 c1 = *s1++;
 498                 c2 = *s2++;
 499
 500                 if (!n--)
 501                         return 0;               // strings are equal until end point
 502
 503                 if (c1 != c2)
 504                 {
 505                         if (c1 >= 'a' && c1 <= 'z')
 506                                 c1 -= ('a' - 'A');
 507                         if (c2 >= 'a' && c2 <= 'z')
 508                                 c2 -= ('a' - 'A');
 509                         if (c1 != c2)
 510                                 return -1;              // strings not equal
 511                 }
 512         } while (c1);
 513
 514         return 0;               // strings are equal
 515 }
 516
 517 int Q_stricmp (const char *s1, const char *s2)
 518 {
 519         return Q_strncasecmp (s1, s2, 99999);
 520 }
 521
 522 // NOTE TTimo when switching to Multithread DLL (Release/Debug) in the config
 523 //   started getting warnings about that function, prolly a duplicate with the runtime function
 524 //   maybe we still need to have it in linux builds
 525 /*
 526 char *strupr (char *start)
 527 {
 528         char    *in;
 529         in = start;
 530         while (*in)
 531         {
 532                 *in = toupper(*in);
 533                 in++;
 534         }
 535         return start;
 536 }
 537 */
 538
 539 char *strlower (char *start)
 540 {
 541         char    *in;
 542         in = start;
 543         while (*in)
 544         {
 545                 *in = tolower(*in);
 546                 in++;
 547         }
 548         return start;
 549 }
 550
 551
 552 /*
 553 =============================================================================
 554
 555                                                 MISC FUNCTIONS
 556
 557 =============================================================================
 558 */
 559
 560
 561 /*
 562 =================
 563 CheckParm
 564
 565 Checks for the given parameter in the program's command line arguments
 566 Returns the argument number (1 to argc-1) or 0 if not present
 567 =================
 568 */
 569 int CheckParm (const char *check)
 570 {
 571         int             i;
 572
 573         for (i = 1;i<myargc;i++)
 574         {
 575                 if ( !Q_stricmp(check, myargv[i]) )
 576                         return i;
 577         }
 578
 579         return 0;
 580 }
 581
 582
 583
 584 /*
 585 ================
 586 Q_filelength
 587 ================
 588 */
 589 int Q_filelength (FILE *f)
 590 {
 591         int             pos;
 592         int             end;
 593
 594         pos = ftell (f);
 595         fseek (f, 0, SEEK_END);
 596         end = ftell (f);
 597         fseek (f, pos, SEEK_SET);
 598
 599         return end;
 600 }
 601
 602
 603 FILE *SafeOpenWrite (const char *filename)
 604 {
 605         FILE    *f;
 606
 607         f = fopen(filename, "wb");
 608
 609         if (!f)
 610                 Error ("Error opening %s: %s",filename,strerror(errno));
 611
 612         return f;
 613 }
 614
 615 FILE *SafeOpenRead (const char *filename)
 616 {
 617         FILE    *f;
 618
 619         f = fopen(filename, "rb");
 620
 621         if (!f)
 622                 Error ("Error opening %s: %s",filename,strerror(errno));
 623
 624         return f;
 625 }
 626
 627
 628 void SafeRead (FILE *f, void *buffer, int count)
 629 {
 630         if ( fread (buffer, 1, count, f) != (size_t)count)
 631                 Error ("File read failure");
 632 }
 633
 634
 635 void SafeWrite (FILE *f, const void *buffer, int count)
 636 {
 637         if (fwrite (buffer, 1, count, f) != (size_t)count)
 638                 Error ("File write failure");
 639 }
 640
 641
 642 /*
 643 ==============
 644 FileExists
 645 ==============
 646 */
 647 qboolean        FileExists (const char *filename)
 648 {
 649         FILE    *f;
 650
 651         f = fopen (filename, "r");
 652         if (!f)
 653                 return qfalse;
 654         fclose (f);
 655         return qtrue;
 656 }
 657
 658 /*
 659 ==============
 660 LoadFile
 661 ==============
 662 */
 663 int    LoadFile( const char *filename, void **bufferptr )
 664 {
 665         FILE    *f;
 666         int    length;
 667         void    *buffer;
 668
 669         f = SafeOpenRead (filename);
 670         length = Q_filelength (f);
 671         buffer = safe_malloc (length+1);
 672         ((char *)buffer)[length] = 0;
 673         SafeRead (f, buffer, length);
 674         fclose (f);
 675
 676         *bufferptr = buffer;
 677         return length;
 678 }
 679
 680
 681 /*
 682 ==============
 683 LoadFileBlock
 684 -
 685 rounds up memory allocation to 4K boundry
 686 -
 687 ==============
 688 */
 689 int    LoadFileBlock( const char *filename, void **bufferptr )
 690 {
 691         FILE    *f;
 692         int    length, nBlock, nAllocSize;
 693         void    *buffer;
 694
 695         f = SafeOpenRead (filename);
 696         length = Q_filelength (f);
 697   nAllocSize = length;
 698   nBlock = nAllocSize % MEM_BLOCKSIZE;
 699   if ( nBlock > 0) {
 700     nAllocSize += MEM_BLOCKSIZE - nBlock;
 701   }
 702         buffer = safe_malloc (nAllocSize+1);
 703   memset(buffer, 0, nAllocSize+1);
 704         SafeRead (f, buffer, length);
 705         fclose (f);
 706
 707         *bufferptr = buffer;
 708         return length;
 709 }
 710
 711
 712 /*
 713 ==============
 714 TryLoadFile
 715
 716 Allows failure
 717 ==============
 718 */
 719 int    TryLoadFile (const char *filename, void **bufferptr)
 720 {
 721         FILE    *f;
 722         int    length;
 723         void    *buffer;
 724
 725         *bufferptr = NULL;
 726
 727         f = fopen (filename, "rb");
 728         if (!f)
 729                 return -1;
 730         length = Q_filelength (f);
 731         buffer = safe_malloc (length+1);
 732         ((char *)buffer)[length] = 0;
 733         SafeRead (f, buffer, length);
 734         fclose (f);
 735
 736         *bufferptr = buffer;
 737         return length;
 738 }
 739
 740
 741 /*
 742 ==============
 743 SaveFile
 744 ==============
 745 */
 746 void    SaveFile (const char *filename, const void *buffer, int count)
 747 {
 748         FILE    *f;
 749
 750         f = SafeOpenWrite (filename);
 751         SafeWrite (f, buffer, count);
 752         fclose (f);
 753 }
 754
 755
 756
 757 void DefaultExtension (char *path, const char *extension)
 758 {
 759         char    *src;
 760 //
 761 // if path doesnt have a .EXT, append extension
 762 // (extension should include the .)
 763 //
 764         src = path + strlen(path) - 1;
 765
 766         while (*src != '/' && *src != '\\' && src != path)
 767         {
 768                 if (*src == '.')
 769                         return;                 // it has an extension
 770                 src--;
 771         }
 772
 773         strcat (path, extension);
 774 }
 775
 776
 777 void DefaultPath (char *path, const char *basepath)
 778 {
 779         char    temp[128];
 780
 781         if( path[ 0 ] == '/' || path[ 0 ] == '\\' )
 782                 return;                   // absolute path location
 783         strcpy (temp,path);
 784         strcpy (path,basepath);
 785         strcat (path,temp);
 786 }
 787
 788
 789 void    StripFilename (char *path)
 790 {
 791         int             length;
 792
 793         length = strlen(path)-1;
 794         while (length > 0 && path[length] != '/' && path[ length ] != '\\' )
 795                 length--;
 796         path[length] = 0;
 797 }
 798
 799 void    StripExtension (char *path)
 800 {
 801         int             length;
 802
 803         length = strlen(path)-1;
 804         while (length > 0 && path[length] != '.')
 805         {
 806                 length--;
 807                 if (path[length] == '/' || path[ length ] == '\\' )
 808                         return;         // no extension
 809         }
 810         if (length)
 811                 path[length] = 0;
 812 }
 813
 814
 815 /*
 816 ====================
 817 Extract file parts
 818 ====================
 819 */
 820 // FIXME: should include the slash, otherwise
 821 // backing to an empty path will be wrong when appending a slash
 822 void ExtractFilePath (const char *path, char *dest)
 823 {
 824         const char    *src;
 825
 826         src = path + strlen(path) - 1;
 827
 828 //
 829 // back up until a \ or the start
 830 //
 831         while (src != path && *(src-1) != '\\' && *(src-1) != '/')
 832                 src--;
 833
 834         memcpy (dest, path, src-path);
 835         dest[src-path] = 0;
 836 }
 837
 838 void ExtractFileBase (const char *path, char *dest)
 839 {
 840         const char    *src;
 841
 842         src = path + strlen(path) - 1;
 843
 844 //
 845 // back up until a \ or the start
 846 //
 847         while (src != path && *(src-1) != '/' && *(src-1) != '\\' )
 848                 src--;
 849
 850         while (*src && *src != '.')
 851         {
 852                 *dest++ = *src++;
 853         }
 854         *dest = 0;
 855 }
 856
 857 void ExtractFileExtension (const char *path, char *dest)
 858 {
 859         const char    *src;
 860
 861         src = path + strlen(path) - 1;
 862
 863 //
 864 // back up until a . or the start
 865 //
 866         while (src != path && *(src-1) != '.')
 867                 src--;
 868         if (src == path)
 869         {
 870                 *dest = 0;      // no extension
 871                 return;
 872         }
 873
 874         strcpy (dest,src);
 875 }
 876
 877
 878 /*
 879 ==============
 880 ParseNum / ParseHex
 881 ==============
 882 */
 883 int ParseHex (const char *hex)
 884 {
 885         const char    *str;
 886         int    num;
 887
 888         num = 0;
 889         str = hex;
 890
 891         while (*str)
 892         {
 893                 num <<= 4;
 894                 if (*str >= '0' && *str <= '9')
 895                         num += *str-'0';
 896                 else if (*str >= 'a' && *str <= 'f')
 897                         num += 10 + *str-'a';
 898                 else if (*str >= 'A' && *str <= 'F')
 899                         num += 10 + *str-'A';
 900                 else
 901                         Error ("Bad hex number: %s",hex);
 902                 str++;
 903         }
 904
 905         return num;
 906 }
 907
 908
 909 int ParseNum (const char *str)
 910 {
 911         if (str[0] == '$')
 912                 return ParseHex (str+1);
 913         if (str[0] == '0' && str[1] == 'x')
 914                 return ParseHex (str+2);
 915         return atol (str);
 916 }
 917
 918
 919
 920 /*
 921 ============================================================================
 922
 923                                         BYTE ORDER FUNCTIONS
 924
 925 ============================================================================
 926 */
 927
 928 #ifdef _SGI_SOURCE
 929 #define __BIG_ENDIAN__
 930 #endif
 931
 932 #ifdef __BIG_ENDIAN__
 933
 934 short   LittleShort (short l)
 935 {
 936         byte    b1,b2;
 937
 938         b1 = l&255;
 939         b2 = (l>>8)&255;
 940
 941         return (b1<<8) + b2;
 942 }
 943
 944 short   BigShort (short l)
 945 {
 946         return l;
 947 }
 948
 949
 950 int    LittleLong (int l)
 951 {
 952         byte    b1,b2,b3,b4;
 953
 954         b1 = l&255;
 955         b2 = (l>>8)&255;
 956         b3 = (l>>16)&255;
 957         b4 = (l>>24)&255;
 958
 959         return ((int)b1<<24) + ((int)b2<<16) + ((int)b3<<8) + b4;
 960 }
 961
 962 int    BigLong (int l)
 963 {
 964         return l;
 965 }
 966
 967
 968 float   LittleFloat (float l)
 969 {
 970         union {byte b[4]; float f;} in, out;
 971
 972         in.f = l;
 973         out.b[0] = in.b[3];
 974         out.b[1] = in.b[2];
 975         out.b[2] = in.b[1];
 976         out.b[3] = in.b[0];
 977
 978         return out.f;
 979 }
 980
 981 float   BigFloat (float l)
 982 {
 983         return l;
 984 }
 985
 986
 987 #else
 988
 989
 990 short   BigShort (short l)
 991 {
 992         byte    b1,b2;
 993
 994         b1 = l&255;
 995         b2 = (l>>8)&255;
 996
 997         return (b1<<8) + b2;
 998 }
 999
1000 short   LittleShort (short l)
1001 {
1002         return l;
1003 }
1004
1005
1006 int    BigLong (int l)
1007 {
1008         byte    b1,b2,b3,b4;
1009
1010         b1 = l&255;
1011         b2 = (l>>8)&255;
1012         b3 = (l>>16)&255;
1013         b4 = (l>>24)&255;
1014
1015         return ((int)b1<<24) + ((int)b2<<16) + ((int)b3<<8) + b4;
1016 }
1017
1018 int    LittleLong (int l)
1019 {
1020         return l;
1021 }
1022
1023 float   BigFloat (float l)
1024 {
1025         union {byte b[4]; float f;} in, out;
1026
1027         in.f = l;
1028         out.b[0] = in.b[3];
1029         out.b[1] = in.b[2];
1030         out.b[2] = in.b[1];
1031         out.b[3] = in.b[0];
1032
1033         return out.f;
1034 }
1035
1036 float   LittleFloat (float l)
1037 {
1038         return l;
1039 }
1040
1041
1042 #endif
1043
1044
1045 //=======================================================
1046
1047
1048 // FIXME: byte swap?
1049
1050 // this is a 16 bit, non-reflected CRC using the polynomial 0x1021
1051 // and the initial and final xor values shown below...  in other words, the
1052 // CCITT standard CRC used by XMODEM
1053
1054 #define CRC_INIT_VALUE  0xffff
1055 #define CRC_XOR_VALUE   0x0000
1056
1057 static unsigned short crctable[256] =
1058 {
1059         0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7,
1060         0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef,
1061         0x1231, 0x0210, 0x3273, 0x2252, 0x52b5, 0x4294, 0x72f7, 0x62d6,
1062         0x9339, 0x8318, 0xb37b, 0xa35a, 0xd3bd, 0xc39c, 0xf3ff, 0xe3de,
1063         0x2462, 0x3443, 0x0420, 0x1401, 0x64e6, 0x74c7, 0x44a4, 0x5485,
1064         0xa56a, 0xb54b, 0x8528, 0x9509, 0xe5ee, 0xf5cf, 0xc5ac, 0xd58d,
1065         0x3653, 0x2672, 0x1611, 0x0630, 0x76d7, 0x66f6, 0x5695, 0x46b4,
1066         0xb75b, 0xa77a, 0x9719, 0x8738, 0xf7df, 0xe7fe, 0xd79d, 0xc7bc,
1067         0x48c4, 0x58e5, 0x6886, 0x78a7, 0x0840, 0x1861, 0x2802, 0x3823,
1068         0xc9cc, 0xd9ed, 0xe98e, 0xf9af, 0x8948, 0x9969, 0xa90a, 0xb92b,
1069         0x5af5, 0x4ad4, 0x7ab7, 0x6a96, 0x1a71, 0x0a50, 0x3a33, 0x2a12,
1070         0xdbfd, 0xcbdc, 0xfbbf, 0xeb9e, 0x9b79, 0x8b58, 0xbb3b, 0xab1a,
1071         0x6ca6, 0x7c87, 0x4ce4, 0x5cc5, 0x2c22, 0x3c03, 0x0c60, 0x1c41,
1072         0xedae, 0xfd8f, 0xcdec, 0xddcd, 0xad2a, 0xbd0b, 0x8d68, 0x9d49,
1073         0x7e97, 0x6eb6, 0x5ed5, 0x4ef4, 0x3e13, 0x2e32, 0x1e51, 0x0e70,
1074         0xff9f, 0xefbe, 0xdfdd, 0xcffc, 0xbf1b, 0xaf3a, 0x9f59, 0x8f78,
1075         0x9188, 0x81a9, 0xb1ca, 0xa1eb, 0xd10c, 0xc12d, 0xf14e, 0xe16f,
1076         0x1080, 0x00a1, 0x30c2, 0x20e3, 0x5004, 0x4025, 0x7046, 0x6067,
1077         0x83b9, 0x9398, 0xa3fb, 0xb3da, 0xc33d, 0xd31c, 0xe37f, 0xf35e,
1078         0x02b1, 0x1290, 0x22f3, 0x32d2, 0x4235, 0x5214, 0x6277, 0x7256,
1079         0xb5ea, 0xa5cb, 0x95a8, 0x8589, 0xf56e, 0xe54f, 0xd52c, 0xc50d,
1080         0x34e2, 0x24c3, 0x14a0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
1081         0xa7db, 0xb7fa, 0x8799, 0x97b8, 0xe75f, 0xf77e, 0xc71d, 0xd73c,
1082         0x26d3, 0x36f2, 0x0691, 0x16b0, 0x6657, 0x7676, 0x4615, 0x5634,
1083         0xd94c, 0xc96d, 0xf90e, 0xe92f, 0x99c8, 0x89e9, 0xb98a, 0xa9ab,
1084         0x5844, 0x4865, 0x7806, 0x6827, 0x18c0, 0x08e1, 0x3882, 0x28a3,
1085         0xcb7d, 0xdb5c, 0xeb3f, 0xfb1e, 0x8bf9, 0x9bd8, 0xabbb, 0xbb9a,
1086         0x4a75, 0x5a54, 0x6a37, 0x7a16, 0x0af1, 0x1ad0, 0x2ab3, 0x3a92,
1087         0xfd2e, 0xed0f, 0xdd6c, 0xcd4d, 0xbdaa, 0xad8b, 0x9de8, 0x8dc9,
1088         0x7c26, 0x6c07, 0x5c64, 0x4c45, 0x3ca2, 0x2c83, 0x1ce0, 0x0cc1,
1089         0xef1f, 0xff3e, 0xcf5d, 0xdf7c, 0xaf9b, 0xbfba, 0x8fd9, 0x9ff8,
1090         0x6e17, 0x7e36, 0x4e55, 0x5e74, 0x2e93, 0x3eb2, 0x0ed1, 0x1ef0
1091 };
1092
1093 void CRC_Init(unsigned short *crcvalue)
1094 {
1095         *crcvalue = CRC_INIT_VALUE;
1096 }
1097
1098 void CRC_ProcessByte(unsigned short *crcvalue, byte data)
1099 {
1100         *crcvalue = (*crcvalue << 8) ^ crctable[(*crcvalue >> 8) ^ data];
1101 }
1102
1103 unsigned short CRC_Value(unsigned short crcvalue)
1104 {
1105         return crcvalue ^ CRC_XOR_VALUE;
1106 }
1107 //=============================================================================
1108
1109 /*
1110 ============
1111 CreatePath
1112 ============
1113 */
1114 void    CreatePath (const char *path)
1115 {
1116         const char      *ofs;
1117         char            c;
1118         char            dir[1024];
1119
1120 #ifdef _WIN32
1121         int             olddrive = -1;
1122
1123         if ( path[1] == ':' )
1124         {
1125                 olddrive = _getdrive();
1126                 _chdrive( toupper( path[0] ) - 'A' + 1 );
1127         }
1128 #endif
1129
1130         if (path[1] == ':')
1131                 path += 2;
1132
1133         for (ofs = path+1 ; *ofs ; ofs++)
1134         {
1135                 c = *ofs;
1136                 if (c == '/' || c == '\\')
1137                 {       // create the directory
1138                         memcpy( dir, path, ofs - path );
1139                         dir[ ofs - path ] = 0;
1140                         Q_mkdir( dir );
1141                 }
1142         }
1143
1144 #ifdef _WIN32
1145         if ( olddrive != -1 )
1146         {
1147                 _chdrive( olddrive );
1148         }
1149 #endif
1150 }
1151
1152
1153 /*
1154 ============
1155 QCopyFile
1156
1157   Used to archive source files
1158 ============
1159 */
1160 void QCopyFile (const char *from, const char *to)
1161 {
1162         void    *buffer;
1163         int             length;
1164
1165         length = LoadFile (from, &buffer);
1166         CreatePath (to);
1167         SaveFile (to, buffer, length);
1168         free (buffer);
1169 }
1170
1171 void Sys_Sleep(int n)
1172 {
1173 #ifdef WIN32
1174   Sleep (n);
1175 #endif
1176 #if defined (__linux__) || defined (__APPLE__)
1177   usleep (n * 1000);
1178 #endif
1179 }