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