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