tools/quake3/common/cmdlib.c

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