libs/splines/q_shared.cpp

   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 // q_shared.c -- stateless support routines that are included in each code dll
  23 #include "q_shared.h"
  24
  25 /*
  26    ============================================================================
  27
  28    GROWLISTS
  29
  30    ============================================================================
  31  */
  32
  33 // malloc / free all in one place for debugging
  34 extern "C" void *Com_Allocate( int bytes );
  35 extern "C" void Com_Dealloc( void *ptr );
  36
  37 void Com_InitGrowList( growList_t *list, int maxElements ) {
  38         list->maxElements = maxElements;
  39         list->currentElements = 0;
  40         list->elements = (void **)Com_Allocate( list->maxElements * sizeof( void * ) );
  41 }
  42
  43 int Com_AddToGrowList( growList_t *list, void *data ) {
  44         void    **old;
  45
  46         if ( list->currentElements != list->maxElements ) {
  47                 list->elements[list->currentElements] = data;
  48                 return list->currentElements++;
  49         }
  50
  51         // grow, reallocate and move
  52         old = list->elements;
  53
  54         if ( list->maxElements < 0 ) {
  55                 Com_Error( ERR_FATAL, "Com_AddToGrowList: maxElements = %i", list->maxElements );
  56         }
  57
  58         if ( list->maxElements == 0 ) {
  59                 // initialize the list to hold 100 elements
  60                 Com_InitGrowList( list, 100 );
  61                 return Com_AddToGrowList( list, data );
  62         }
  63
  64         list->maxElements *= 2;
  65
  66         Com_DPrintf( "Resizing growlist to %i maxElements\n", list->maxElements );
  67
  68         list->elements = (void **)Com_Allocate( list->maxElements * sizeof( void * ) );
  69
  70         if ( !list->elements ) {
  71                 Com_Error( ERR_DROP, "Growlist alloc failed" );
  72         }
  73
  74         memcpy( list->elements, old, list->currentElements * sizeof( void * ) );
  75
  76         Com_Dealloc( old );
  77
  78         return Com_AddToGrowList( list, data );
  79 }
  80
  81 void *Com_GrowListElement( const growList_t *list, int index ) {
  82         if ( index < 0 || index >= list->currentElements ) {
  83                 Com_Error( ERR_DROP, "Com_GrowListElement: %i out of range of %i",
  84                                    index, list->currentElements );
  85         }
  86         return list->elements[index];
  87 }
  88
  89 int Com_IndexForGrowListElement( const growList_t *list, const void *element ) {
  90         int i;
  91
  92         for ( i = 0 ; i < list->currentElements ; i++ ) {
  93                 if ( list->elements[i] == element ) {
  94                         return i;
  95                 }
  96         }
  97         return -1;
  98 }
  99
 100 //============================================================================
 101
 102
 103 float Com_Clamp( float min, float max, float value ) {
 104         if ( value < min ) {
 105                 return min;
 106         }
 107         if ( value > max ) {
 108                 return max;
 109         }
 110         return value;
 111 }
 112
 113 /*
 114    ============
 115    Com_StringContains
 116    ============
 117  */
 118 const char *Com_StringContains( const char *str1, const char *str2, int casesensitive ) {
 119         int len, i, j;
 120
 121         len = strlen( str1 ) - strlen( str2 );
 122         for ( i = 0; i <= len; i++, str1++ ) {
 123                 for ( j = 0; str2[j]; j++ ) {
 124                         if ( casesensitive ) {
 125                                 if ( str1[j] != str2[j] ) {
 126                                         break;
 127                                 }
 128                         }
 129                         else {
 130                                 if ( toupper( str1[j] ) != toupper( str2[j] ) ) {
 131                                         break;
 132                                 }
 133                         }
 134                 }
 135                 if ( !str2[j] ) {
 136                         return str1;
 137                 }
 138         }
 139         return NULL;
 140 }
 141
 142 /*
 143    ============
 144    Com_Filter
 145    ============
 146  */
 147 int Com_Filter( const char *filter, const char *name, int casesensitive ){
 148         char buf[MAX_TOKEN_CHARS];
 149         const char *ptr;
 150         int i, found;
 151
 152         while ( *filter ) {
 153                 if ( *filter == '*' ) {
 154                         filter++;
 155                         for ( i = 0; *filter; i++ ) {
 156                                 if ( *filter == '*' || *filter == '?' ) {
 157                                         break;
 158                                 }
 159                                 buf[i] = *filter;
 160                                 filter++;
 161                         }
 162                         buf[i] = '\0';
 163                         if ( strlen( buf ) ) {
 164                                 ptr = Com_StringContains( name, buf, casesensitive );
 165                                 if ( !ptr ) {
 166                                         return qfalse;
 167                                 }
 168                                 name = ptr + strlen( buf );
 169                         }
 170                 }
 171                 else if ( *filter == '?' ) {
 172                         filter++;
 173                         name++;
 174                 }
 175                 else if ( *filter == '[' && *( filter + 1 ) == '[' ) {
 176                         filter++;
 177                 }
 178                 else if ( *filter == '[' ) {
 179                         filter++;
 180                         found = qfalse;
 181                         while ( *filter && !found ) {
 182                                 if ( *filter == ']' && *( filter + 1 ) != ']' ) {
 183                                         break;
 184                                 }
 185                                 if ( *( filter + 1 ) == '-' && *( filter + 2 ) && ( *( filter + 2 ) != ']' || *( filter + 3 ) == ']' ) ) {
 186                                         if ( casesensitive ) {
 187                                                 if ( *name >= *filter && *name <= *( filter + 2 ) ) {
 188                                                         found = qtrue;
 189                                                 }
 190                                         }
 191                                         else {
 192                                                 if ( toupper( *name ) >= toupper( *filter ) &&
 193                                                          toupper( *name ) <= toupper( *( filter + 2 ) ) ) {
 194                                                         found = qtrue;
 195                                                 }
 196                                         }
 197                                         filter += 3;
 198                                 }
 199                                 else {
 200                                         if ( casesensitive ) {
 201                                                 if ( *filter == *name ) {
 202                                                         found = qtrue;
 203                                                 }
 204                                         }
 205                                         else {
 206                                                 if ( toupper( *filter ) == toupper( *name ) ) {
 207                                                         found = qtrue;
 208                                                 }
 209                                         }
 210                                         filter++;
 211                                 }
 212                         }
 213                         if ( !found ) {
 214                                 return qfalse;
 215                         }
 216                         while ( *filter ) {
 217                                 if ( *filter == ']' && *( filter + 1 ) != ']' ) {
 218                                         break;
 219                                 }
 220                                 filter++;
 221                         }
 222                         filter++;
 223                         name++;
 224                 }
 225                 else {
 226                         if ( casesensitive ) {
 227                                 if ( *filter != *name ) {
 228                                         return qfalse;
 229                                 }
 230                         }
 231                         else {
 232                                 if ( toupper( *filter ) != toupper( *name ) ) {
 233                                         return qfalse;
 234                                 }
 235                         }
 236                         filter++;
 237                         name++;
 238                 }
 239         }
 240         return qtrue;
 241 }
 242
 243
 244 /*
 245    ================
 246    Com_HashString
 247
 248    ================
 249  */
 250 int Com_HashString( const char *fname ) {
 251         int i;
 252         long hash;
 253         char letter;
 254
 255         hash = 0;
 256         i = 0;
 257         while ( fname[i] != '\0' ) {
 258                 letter = tolower( fname[i] );
 259                 if ( letter == '.' ) {
 260                         break;                              // don't include extension
 261                 }
 262                 if ( letter == '\\' ) {
 263                         letter = '/';                       // damn path names
 264                 }
 265                 hash += (long)( letter ) * ( i + 119 );
 266                 i++;
 267         }
 268         hash &= ( FILE_HASH_SIZE - 1 );
 269         return hash;
 270 }
 271
 272
 273 /*
 274    ============
 275    Com_SkipPath
 276    ============
 277  */
 278 char *Com_SkipPath( char *pathname ){
 279         char    *last;
 280
 281         last = pathname;
 282         while ( *pathname )
 283         {
 284                 if ( *pathname == '/' ) {
 285                         last = pathname + 1;
 286                 }
 287                 pathname++;
 288         }
 289         return last;
 290 }
 291
 292 /*
 293    ============
 294    Com_StripExtension
 295    ============
 296  */
 297 void Com_StripExtension( const char *in, char *out ) {
 298         while ( *in && *in != '.' ) {
 299                 *out++ = *in++;
 300         }
 301         *out = 0;
 302 }
 303
 304
 305 /*
 306    ==================
 307    Com_DefaultExtension
 308    ==================
 309  */
 310 void Com_DefaultExtension( char *path, int maxSize, const char *extension ) {
 311         char oldPath[MAX_QPATH];
 312         char    *src;
 313
 314 //
 315 // if path doesn't have a .EXT, append extension
 316 // (extension should include the .)
 317 //
 318         src = path + strlen( path ) - 1;
 319
 320         while ( *src != '/' && src != path ) {
 321                 if ( *src == '.' ) {
 322                         return;                 // it has an extension
 323                 }
 324                 src--;
 325         }
 326
 327         Q_strncpyz( oldPath, path, sizeof( oldPath ) );
 328         Com_sprintf( path, maxSize, "%s%s", oldPath, extension );
 329 }
 330
 331 /*
 332    ============================================================================
 333
 334                     BYTE ORDER FUNCTIONS
 335
 336    ============================================================================
 337  */
 338
 339 // can't just use function pointers, or dll linkage can
 340 // mess up when qcommon is included in multiple places
 341 static short ( *_BigShort )( short l );
 342 static short ( *_LittleShort )( short l );
 343 static int ( *_BigLong )( int l );
 344 static int ( *_LittleLong )( int l );
 345 static float ( *_BigFloat )( float l );
 346 static float ( *_LittleFloat )( float l );
 347
 348 short   BigShort( short l ){return _BigShort( l ); }
 349 short   LittleShort( short l ) {return _LittleShort( l ); }
 350 int     BigLong( int l ) {return _BigLong( l ); }
 351 int     LittleLong( int l ) {return _LittleLong( l ); }
 352 float   BigFloat( float l ) {return _BigFloat( l ); }
 353 float   LittleFloat( float l ) {return _LittleFloat( l ); }
 354
 355 short   ShortSwap( short l ){
 356         byte b1,b2;
 357
 358         b1 = l & 255;
 359         b2 = ( l >> 8 ) & 255;
 360
 361         return ( b1 << 8 ) + b2;
 362 }
 363
 364 short   ShortNoSwap( short l ){
 365         return l;
 366 }
 367
 368 int    LongSwap( int l ){
 369         byte b1,b2,b3,b4;
 370
 371         b1 = l & 255;
 372         b2 = ( l >> 8 ) & 255;
 373         b3 = ( l >> 16 ) & 255;
 374         b4 = ( l >> 24 ) & 255;
 375
 376         return ( (int)b1 << 24 ) + ( (int)b2 << 16 ) + ( (int)b3 << 8 ) + b4;
 377 }
 378
 379 int LongNoSwap( int l ){
 380         return l;
 381 }
 382
 383 float FloatSwap( float f ){
 384         union
 385         {
 386                 float f;
 387                 byte b[4];
 388         } dat1, dat2;
 389
 390
 391         dat1.f = f;
 392         dat2.b[0] = dat1.b[3];
 393         dat2.b[1] = dat1.b[2];
 394         dat2.b[2] = dat1.b[1];
 395         dat2.b[3] = dat1.b[0];
 396         return dat2.f;
 397 }
 398
 399 float FloatNoSwap( float f ){
 400         return f;
 401 }
 402
 403 /*
 404    ================
 405    Swap_Init
 406    ================
 407  */
 408 void Swap_Init( void ){
 409         byte swaptest[2] = {1,0};
 410
 411 // set the byte swapping variables in a portable manner
 412         if ( *(short *)swaptest == 1 ) {
 413                 _BigShort = ShortSwap;
 414                 _LittleShort = ShortNoSwap;
 415                 _BigLong = LongSwap;
 416                 _LittleLong = LongNoSwap;
 417                 _BigFloat = FloatSwap;
 418                 _LittleFloat = FloatNoSwap;
 419         }
 420         else
 421         {
 422                 _BigShort = ShortNoSwap;
 423                 _LittleShort = ShortSwap;
 424                 _BigLong = LongNoSwap;
 425                 _LittleLong = LongSwap;
 426                 _BigFloat = FloatNoSwap;
 427                 _LittleFloat = FloatSwap;
 428         }
 429
 430 }
 431
 432 /*
 433    ===============
 434    Com_ParseInfos
 435    ===============
 436  */
 437 int Com_ParseInfos( const char *buf, int max, char infos[][MAX_INFO_STRING] ) {
 438         const char  *token;
 439         int count;
 440         char key[MAX_TOKEN_CHARS];
 441
 442         count = 0;
 443
 444         while ( 1 ) {
 445                 token = Com_Parse( &buf );
 446                 if ( !token[0] ) {
 447                         break;
 448                 }
 449                 if ( strcmp( token, "{" ) ) {
 450                         Com_Printf( "Missing { in info file\n" );
 451                         break;
 452                 }
 453
 454                 if ( count == max ) {
 455                         Com_Printf( "Max infos exceeded\n" );
 456                         break;
 457                 }
 458
 459                 infos[count][0] = 0;
 460                 while ( 1 ) {
 461                         token = Com_Parse( &buf );
 462                         if ( !token[0] ) {
 463                                 Com_Printf( "Unexpected end of info file\n" );
 464                                 break;
 465                         }
 466                         if ( !strcmp( token, "}" ) ) {
 467                                 break;
 468                         }
 469                         Q_strncpyz( key, token, sizeof( key ) );
 470
 471                         token = Com_ParseOnLine( &buf );
 472                         if ( !token[0] ) {
 473                                 token = "<NULL>";
 474                         }
 475                         Info_SetValueForKey( infos[count], key, token );
 476                 }
 477                 count++;
 478         }
 479
 480         return count;
 481 }
 482
 483
 484
 485 /*
 486    ============================================================================
 487
 488                     LIBRARY REPLACEMENT FUNCTIONS
 489
 490    ============================================================================
 491  */
 492
 493 int Q_isprint( int c ){
 494         if ( c >= 0x20 && c <= 0x7E ) {
 495                 return ( 1 );
 496         }
 497         return ( 0 );
 498 }
 499
 500 int Q_islower( int c ){
 501         if ( c >= 'a' && c <= 'z' ) {
 502                 return ( 1 );
 503         }
 504         return ( 0 );
 505 }
 506
 507 int Q_isupper( int c ){
 508         if ( c >= 'A' && c <= 'Z' ) {
 509                 return ( 1 );
 510         }
 511         return ( 0 );
 512 }
 513
 514 int Q_isalpha( int c ){
 515         if ( ( c >= 'a' && c <= 'z' ) || ( c >= 'A' && c <= 'Z' ) ) {
 516                 return ( 1 );
 517         }
 518         return ( 0 );
 519 }
 520
 521 char* Q_strrchr( const char* string, int c ){
 522         char cc = c;
 523         char *s;
 524         char *sp = (char *)0;
 525
 526         s = (char*)string;
 527
 528         while ( *s )
 529         {
 530                 if ( *s == cc ) {
 531                         sp = s;
 532                 }
 533                 s++;
 534         }
 535         if ( cc == 0 ) {
 536                 sp = s;
 537         }
 538
 539         return sp;
 540 }
 541
 542 /*
 543    =============
 544    Q_strncpyz
 545
 546    Safe strncpy that ensures a trailing zero
 547    =============
 548  */
 549 void Q_strncpyz( char *dest, const char *src, std::size_t destsize ) {
 550         if ( !src ) {
 551                 Com_Error( ERR_FATAL, "Q_strncpyz: NULL src" );
 552         }
 553         if ( destsize < 1 ) {
 554                 Com_Error( ERR_FATAL,"Q_strncpyz: destsize < 1" );
 555         }
 556
 557         strncpy( dest, src, destsize - 1 );
 558         dest[destsize - 1] = 0;
 559 }
 560
 561 int Q_stricmpn( const char *s1, const char *s2, int n ) {
 562         int c1, c2;
 563
 564         do {
 565                 c1 = *s1++;
 566                 c2 = *s2++;
 567
 568                 if ( !n-- ) {
 569                         return 0;       // strings are equal until end point
 570                 }
 571
 572                 if ( c1 != c2 ) {
 573                         if ( c1 >= 'a' && c1 <= 'z' ) {
 574                                 c1 -= ( 'a' - 'A' );
 575                         }
 576                         if ( c2 >= 'a' && c2 <= 'z' ) {
 577                                 c2 -= ( 'a' - 'A' );
 578                         }
 579                         if ( c1 != c2 ) {
 580                                 return c1 < c2 ? -1 : 1;
 581                         }
 582                 }
 583         } while ( c1 );
 584
 585         return 0;       // strings are equal
 586 }
 587
 588 int Q_strncmp( const char *s1, const char *s2, int n ) {
 589         int c1, c2;
 590
 591         do {
 592                 c1 = *s1++;
 593                 c2 = *s2++;
 594
 595                 if ( !n-- ) {
 596                         return 0;       // strings are equal until end point
 597                 }
 598
 599                 if ( c1 != c2 ) {
 600                         return c1 < c2 ? -1 : 1;
 601                 }
 602         } while ( c1 );
 603
 604         return 0;       // strings are equal
 605 }
 606
 607 int Q_stricmp( const char *s1, const char *s2 ) {
 608         return Q_stricmpn( s1, s2, 99999 );
 609 }
 610
 611
 612 char *Q_strlwr( char *s1 ) {
 613         char    *s;
 614
 615         s = s1;
 616         while ( *s ) {
 617                 *s = tolower( *s );
 618                 s++;
 619         }
 620         return s1;
 621 }
 622
 623 char *Q_strupr( char *s1 ) {
 624         char    *s;
 625
 626         s = s1;
 627         while ( *s ) {
 628                 *s = toupper( *s );
 629                 s++;
 630         }
 631         return s1;
 632 }
 633
 634
 635 // never goes past bounds or leaves without a terminating 0
 636 void Q_strcat( char *dest, std::size_t size, const char *src ) {
 637         auto l1 = strlen( dest );
 638         if ( l1 >= size ) {
 639                 Com_Error( ERR_FATAL, "Q_strcat: already overflowed" );
 640         }
 641         Q_strncpyz( dest + l1, src, size - l1 );
 642 }
 643
 644
 645 int Q_PrintStrlen( const char *string ) {
 646         int len;
 647         const char  *p;
 648
 649         if ( !string ) {
 650                 return 0;
 651         }
 652
 653         len = 0;
 654         p = string;
 655         while ( *p ) {
 656                 if ( Q_IsColorString( p ) ) {
 657                         p += 2;
 658                         continue;
 659                 }
 660                 p++;
 661                 len++;
 662         }
 663
 664         return len;
 665 }
 666
 667
 668 char *Q_CleanStr( char *string ) {
 669         char*   d;
 670         char*   s;
 671         int c;
 672
 673         s = string;
 674         d = string;
 675         while ( ( c = *s ) != 0 ) {
 676                 if ( Q_IsColorString( s ) ) {
 677                         s++;
 678                 }
 679                 else if ( c >= 0x20 && c <= 0x7E ) {
 680                         *d++ = c;
 681                 }
 682                 s++;
 683         }
 684         *d = '\0';
 685
 686         return string;
 687 }
 688
 689
 690 void QDECL Com_sprintf( char *dest, std::size_t size, const char *fmt, ... ) {
 691         va_list argptr;
 692         char bigbuffer[32000];      // big, but small enough to fit in PPC stack
 693
 694         va_start( argptr,fmt );
 695         int ret = vsprintf( bigbuffer,fmt,argptr );
 696         va_end( argptr );
 697         if ( ret < 0 ) {
 698                 Com_Error(ERR_FATAL, "Com_sprintf: vsprintf failed");
 699         }
 700         auto len = static_cast<size_t>(ret);
 701         if ( len >= sizeof( bigbuffer ) ) {
 702                 Com_Error( ERR_FATAL, "Com_sprintf: overflowed bigbuffer" );
 703         }
 704         if ( len >= size ) {
 705                 Com_Printf( "Com_sprintf: overflow of %i in %i\n", len, size );
 706         }
 707         Q_strncpyz( dest, bigbuffer, size );
 708 }
 709
 710
 711 /*
 712    ============
 713    va
 714
 715    does a varargs printf into a temp buffer, so I don't need to have
 716    varargs versions of all text functions.
 717    FIXME: make this buffer size safe someday
 718    ============
 719  */
 720 char *QDECL va( const char *format, ... ) {
 721         va_list argptr;
 722         static char string[2][32000];       // in case va is called by nested functions
 723         static int index = 0;
 724         char    *buf;
 725
 726         buf = string[index & 1];
 727         index++;
 728
 729         va_start( argptr, format );
 730         vsprintf( buf, format,argptr );
 731         va_end( argptr );
 732
 733         return buf;
 734 }
 735
 736
 737 /*
 738    =====================================================================
 739
 740    INFO STRINGS
 741
 742    =====================================================================
 743  */
 744
 745 /*
 746    ===============
 747    Info_ValueForKey
 748
 749    Searches the string for the given
 750    key and returns the associated value, or an empty string.
 751    FIXME: overflow check?
 752    ===============
 753  */
 754 const char *Info_ValueForKey( const char *s, const char *key ) {
 755         char pkey[MAX_INFO_KEY];
 756         static char value[2][MAX_INFO_VALUE];   // use two buffers so compares
 757                                                 // work without stomping on each other
 758         static int valueindex = 0;
 759         char    *o;
 760
 761         if ( !s || !key ) {
 762                 return "";
 763         }
 764
 765         if ( strlen( s ) >= MAX_INFO_STRING ) {
 766                 Com_Error( ERR_DROP, "Info_ValueForKey: oversize infostring" );
 767         }
 768
 769         valueindex ^= 1;
 770         if ( *s == '\\' ) {
 771                 s++;
 772         }
 773         while ( 1 )
 774         {
 775                 o = pkey;
 776                 while ( *s != '\\' )
 777                 {
 778                         if ( !*s ) {
 779                                 return "";
 780                         }
 781                         *o++ = *s++;
 782                 }
 783                 *o = 0;
 784                 s++;
 785
 786                 o = value[valueindex];
 787
 788                 while ( *s != '\\' && *s )
 789                 {
 790                         *o++ = *s++;
 791                 }
 792                 *o = 0;
 793
 794                 if ( !Q_stricmp( key, pkey ) ) {
 795                         return value[valueindex];
 796                 }
 797
 798                 if ( !*s ) {
 799                         break;
 800                 }
 801                 s++;
 802         }
 803
 804         return "";
 805 }
 806
 807
 808 /*
 809    ===================
 810    Info_NextPair
 811
 812    Used to itterate through all the key/value pairs in an info string
 813    ===================
 814  */
 815 void Info_NextPair( const char *( *head ), char key[MAX_INFO_KEY], char value[MAX_INFO_VALUE] ) {
 816         char    *o;
 817         const char  *s;
 818
 819         s = *head;
 820
 821         if ( *s == '\\' ) {
 822                 s++;
 823         }
 824         key[0] = 0;
 825         value[0] = 0;
 826
 827         o = key;
 828         while ( *s != '\\' ) {
 829                 if ( !*s ) {
 830                         *o = 0;
 831                         *head = s;
 832                         return;
 833                 }
 834                 *o++ = *s++;
 835         }
 836         *o = 0;
 837         s++;
 838
 839         o = value;
 840         while ( *s != '\\' && *s ) {
 841                 *o++ = *s++;
 842         }
 843         *o = 0;
 844
 845         *head = s;
 846 }
 847
 848
 849 /*
 850    ===================
 851    Info_RemoveKey
 852    ===================
 853  */
 854 void Info_RemoveKey( char *s, const char *key ) {
 855         char    *start;
 856         char pkey[MAX_INFO_KEY];
 857         char value[MAX_INFO_VALUE];
 858         char    *o;
 859
 860         if ( strlen( s ) >= MAX_INFO_STRING ) {
 861                 Com_Error( ERR_DROP, "Info_RemoveKey: oversize infostring" );
 862         }
 863
 864         if ( strchr( key, '\\' ) ) {
 865                 return;
 866         }
 867
 868         while ( 1 )
 869         {
 870                 start = s;
 871                 if ( *s == '\\' ) {
 872                         s++;
 873                 }
 874                 o = pkey;
 875                 while ( *s != '\\' )
 876                 {
 877                         if ( !*s ) {
 878                                 return;
 879                         }
 880                         *o++ = *s++;
 881                 }
 882                 *o = 0;
 883                 s++;
 884
 885                 o = value;
 886                 while ( *s != '\\' && *s )
 887                 {
 888                         if ( !*s ) {
 889                                 return;
 890                         }
 891                         *o++ = *s++;
 892                 }
 893                 *o = 0;
 894
 895                 if ( !strcmp( key, pkey ) ) {
 896                         strcpy( start, s );  // remove this part
 897                         return;
 898                 }
 899
 900                 if ( !*s ) {
 901                         return;
 902                 }
 903         }
 904
 905 }
 906
 907
 908 /*
 909    ==================
 910    Info_Validate
 911
 912    Some characters are illegal in info strings because they
 913    can mess up the server's parsing
 914    ==================
 915  */
 916 qboolean Info_Validate( const char *s ) {
 917         if ( strchr( s, '\"' ) ) {
 918                 return qfalse;
 919         }
 920         if ( strchr( s, ';' ) ) {
 921                 return qfalse;
 922         }
 923         return qtrue;
 924 }
 925
 926 /*
 927    ==================
 928    Info_SetValueForKey
 929
 930    Changes or adds a key/value pair
 931    ==================
 932  */
 933 void Info_SetValueForKey( char *s, const char *key, const char *value ) {
 934         char newi[MAX_INFO_STRING];
 935
 936         if ( strlen( s ) >= MAX_INFO_STRING ) {
 937                 Com_Error( ERR_DROP, "Info_SetValueForKey: oversize infostring" );
 938         }
 939
 940         if ( strchr( key, '\\' ) || strchr( value, '\\' ) ) {
 941                 Com_Printf( "Can't use keys or values with a \\\n" );
 942                 return;
 943         }
 944
 945         if ( strchr( key, ';' ) || strchr( value, ';' ) ) {
 946                 Com_Printf( "Can't use keys or values with a semicolon\n" );
 947                 return;
 948         }
 949
 950         if ( strchr( key, '\"' ) || strchr( value, '\"' ) ) {
 951                 Com_Printf( "Can't use keys or values with a \"\n" );
 952                 return;
 953         }
 954
 955         Info_RemoveKey( s, key );
 956         if ( !value || !strlen( value ) ) {
 957                 return;
 958         }
 959
 960         Com_sprintf( newi, sizeof( newi ), "\\%s\\%s", key, value );
 961
 962         if ( strlen( newi ) + strlen( s ) > MAX_INFO_STRING ) {
 963                 Com_Printf( "Info string length exceeded\n" );
 964                 return;
 965         }
 966
 967         strcat( s, newi );
 968 }
 969
 970 //====================================================================
 971
 972
 973 /*
 974    ===============
 975    ParseHex
 976    ===============
 977  */
 978 int ParseHex( const char *text ) {
 979         int value;
 980         int c;
 981
 982         value = 0;
 983         while ( ( c = *text++ ) != 0 ) {
 984                 if ( c >= '0' && c <= '9' ) {
 985                         value = value * 16 + c - '0';
 986                         continue;
 987                 }
 988                 if ( c >= 'a' && c <= 'f' ) {
 989                         value = value * 16 + 10 + c - 'a';
 990                         continue;
 991                 }
 992                 if ( c >= 'A' && c <= 'F' ) {
 993                         value = value * 16 + 10 + c - 'A';
 994                         continue;
 995                 }
 996         }
 997
 998         return value;
 999 }