src/mesa/main/imports.c

   1 /**
   2  * \file imports.c
   3  * Standard C library function wrappers.
   4  *
   5  * Imports are services which the device driver or window system or
   6  * operating system provides to the core renderer.  The core renderer (Mesa)
   7  * will call these functions in order to do memory allocation, simple I/O,
   8  * etc.
   9  *
  10  * Some drivers will want to override/replace this file with something
  11  * specialized, but that'll be rare.
  12  *
  13  * Eventually, I want to move roll the glheader.h file into this.
  14  *
  15  * \todo Functions still needed:
  16  * - scanf
  17  * - qsort
  18  * - rand and RAND_MAX
  19  */
  20
  21 /*
  22  * Mesa 3-D graphics library
  23  * Version:  7.1
  24  *
  25  * Copyright (C) 1999-2007  Brian Paul   All Rights Reserved.
  26  *
  27  * Permission is hereby granted, free of charge, to any person obtaining a
  28  * copy of this software and associated documentation files (the "Software"),
  29  * to deal in the Software without restriction, including without limitation
  30  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  31  * and/or sell copies of the Software, and to permit persons to whom the
  32  * Software is furnished to do so, subject to the following conditions:
  33  *
  34  * The above copyright notice and this permission notice shall be included
  35  * in all copies or substantial portions of the Software.
  36  *
  37  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  38  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  39  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  40  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  41  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  42  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  43  */
  44
  45
  46
  47 #include "imports.h"
  48 #include "context.h"
  49 #include "version.h"
  50
  51 #ifdef _GNU_SOURCE
  52 #include <locale.h>
  53 #ifdef __APPLE__
  54 #include <xlocale.h>
  55 #endif
  56 #endif
  57
  58
  59 #define MAXSTRING 4000  /* for vsnprintf() */
  60
  61 #ifdef WIN32
  62 #define vsnprintf _vsnprintf
  63 #elif defined(__IBMC__) || defined(__IBMCPP__) || ( defined(__VMS) && __CRTL_VER < 70312000 )
  64 extern int vsnprintf(char *str, size_t count, const char *fmt, va_list arg);
  65 #ifdef __VMS
  66 #include "vsnprintf.c"
  67 #endif
  68 #endif
  69
  70 /**********************************************************************/
  71 /** \name Memory */
  72 /*@{*/
  73
  74 /**
  75  * Allocate aligned memory.
  76  *
  77  * \param bytes number of bytes to allocate.
  78  * \param alignment alignment (must be greater than zero).
  79  *
  80  * Allocates extra memory to accommodate rounding up the address for
  81  * alignment and to record the real malloc address.
  82  *
  83  * \sa _mesa_align_free().
  84  */
  85 void *
  86 _mesa_align_malloc(size_t bytes, unsigned long alignment)
  87 {
  88 #if defined(HAVE_POSIX_MEMALIGN)
  89    void *mem;
  90    int err = posix_memalign(& mem, alignment, bytes);
  91    (void) err;
  92    return mem;
  93 #elif defined(_WIN32) && defined(_MSC_VER)
  94    return _aligned_malloc(bytes, alignment);
  95 #else
  96    uintptr_t ptr, buf;
  97
  98    ASSERT( alignment > 0 );
  99
 100    ptr = (uintptr_t) malloc(bytes + alignment + sizeof(void *));
 101    if (!ptr)
 102       return NULL;
 103
 104    buf = (ptr + alignment + sizeof(void *)) & ~(uintptr_t)(alignment - 1);
 105    *(uintptr_t *)(buf - sizeof(void *)) = ptr;
 106
 107 #ifdef DEBUG
 108    /* mark the non-aligned area */
 109    while ( ptr < buf - sizeof(void *) ) {
 110       *(unsigned long *)ptr = 0xcdcdcdcd;
 111       ptr += sizeof(unsigned long);
 112    }
 113 #endif
 114
 115    return (void *) buf;
 116 #endif /* defined(HAVE_POSIX_MEMALIGN) */
 117 }
 118
 119 /**
 120  * Same as _mesa_align_malloc(), but using calloc(1, ) instead of
 121  * malloc()
 122  */
 123 void *
 124 _mesa_align_calloc(size_t bytes, unsigned long alignment)
 125 {
 126 #if defined(HAVE_POSIX_MEMALIGN)
 127    void *mem;
 128
 129    mem = _mesa_align_malloc(bytes, alignment);
 130    if (mem != NULL) {
 131       (void) memset(mem, 0, bytes);
 132    }
 133
 134    return mem;
 135 #elif defined(_WIN32) && defined(_MSC_VER)
 136    void *mem;
 137
 138    mem = _aligned_malloc(bytes, alignment);
 139    if (mem != NULL) {
 140       (void) memset(mem, 0, bytes);
 141    }
 142
 143    return mem;
 144 #else
 145    uintptr_t ptr, buf;
 146
 147    ASSERT( alignment > 0 );
 148
 149    ptr = (uintptr_t) calloc(1, bytes + alignment + sizeof(void *));
 150    if (!ptr)
 151       return NULL;
 152
 153    buf = (ptr + alignment + sizeof(void *)) & ~(uintptr_t)(alignment - 1);
 154    *(uintptr_t *)(buf - sizeof(void *)) = ptr;
 155
 156 #ifdef DEBUG
 157    /* mark the non-aligned area */
 158    while ( ptr < buf - sizeof(void *) ) {
 159       *(unsigned long *)ptr = 0xcdcdcdcd;
 160       ptr += sizeof(unsigned long);
 161    }
 162 #endif
 163
 164    return (void *)buf;
 165 #endif /* defined(HAVE_POSIX_MEMALIGN) */
 166 }
 167
 168 /**
 169  * Free memory which was allocated with either _mesa_align_malloc()
 170  * or _mesa_align_calloc().
 171  * \param ptr pointer to the memory to be freed.
 172  * The actual address to free is stored in the word immediately before the
 173  * address the client sees.
 174  */
 175 void
 176 _mesa_align_free(void *ptr)
 177 {
 178 #if defined(HAVE_POSIX_MEMALIGN)
 179    free(ptr);
 180 #elif defined(_WIN32) && defined(_MSC_VER)
 181    _aligned_free(ptr);
 182 #else
 183    void **cubbyHole = (void **) ((char *) ptr - sizeof(void *));
 184    void *realAddr = *cubbyHole;
 185    free(realAddr);
 186 #endif /* defined(HAVE_POSIX_MEMALIGN) */
 187 }
 188
 189 /**
 190  * Reallocate memory, with alignment.
 191  */
 192 void *
 193 _mesa_align_realloc(void *oldBuffer, size_t oldSize, size_t newSize,
 194                     unsigned long alignment)
 195 {
 196 #if defined(_WIN32) && defined(_MSC_VER)
 197    (void) oldSize;
 198    return _aligned_realloc(oldBuffer, newSize, alignment);
 199 #else
 200    const size_t copySize = (oldSize < newSize) ? oldSize : newSize;
 201    void *newBuf = _mesa_align_malloc(newSize, alignment);
 202    if (newBuf && oldBuffer && copySize > 0) {
 203       memcpy(newBuf, oldBuffer, copySize);
 204    }
 205    if (oldBuffer)
 206       _mesa_align_free(oldBuffer);
 207    return newBuf;
 208 #endif
 209 }
 210
 211
 212
 213 /** Reallocate memory */
 214 void *
 215 _mesa_realloc(void *oldBuffer, size_t oldSize, size_t newSize)
 216 {
 217    const size_t copySize = (oldSize < newSize) ? oldSize : newSize;
 218    void *newBuffer = malloc(newSize);
 219    if (newBuffer && oldBuffer && copySize > 0)
 220       memcpy(newBuffer, oldBuffer, copySize);
 221    if (oldBuffer)
 222       free(oldBuffer);
 223    return newBuffer;
 224 }
 225
 226 /**
 227  * Fill memory with a constant 16bit word.
 228  * \param dst destination pointer.
 229  * \param val value.
 230  * \param n number of words.
 231  */
 232 void
 233 _mesa_memset16( unsigned short *dst, unsigned short val, size_t n )
 234 {
 235    while (n-- > 0)
 236       *dst++ = val;
 237 }
 238
 239 /*@}*/
 240
 241
 242 /**********************************************************************/
 243 /** \name Math */
 244 /*@{*/
 245
 246 /** Wrapper around sin() */
 247 double
 248 _mesa_sin(double a)
 249 {
 250    return sin(a);
 251 }
 252
 253 /** Single precision wrapper around sin() */
 254 float
 255 _mesa_sinf(float a)
 256 {
 257    return (float) sin((double) a);
 258 }
 259
 260 /** Wrapper around cos() */
 261 double
 262 _mesa_cos(double a)
 263 {
 264    return cos(a);
 265 }
 266
 267 /** Single precision wrapper around asin() */
 268 float
 269 _mesa_asinf(float x)
 270 {
 271    return (float) asin((double) x);
 272 }
 273
 274 /** Single precision wrapper around atan() */
 275 float
 276 _mesa_atanf(float x)
 277 {
 278    return (float) atan((double) x);
 279 }
 280
 281 /** Wrapper around sqrt() */
 282 double
 283 _mesa_sqrtd(double x)
 284 {
 285    return sqrt(x);
 286 }
 287
 288
 289 /*
 290  * A High Speed, Low Precision Square Root
 291  * by Paul Lalonde and Robert Dawson
 292  * from "Graphics Gems", Academic Press, 1990
 293  *
 294  * SPARC implementation of a fast square root by table
 295  * lookup.
 296  * SPARC floating point format is as follows:
 297  *
 298  * BIT 31       30      23      22      0
 299  *     sign     exponent        mantissa
 300  */
 301 static short sqrttab[0x100];    /* declare table of square roots */
 302
 303 void
 304 _mesa_init_sqrt_table(void)
 305 {
 306 #if defined(USE_IEEE) && !defined(DEBUG)
 307    unsigned short i;
 308    fi_type fi;     /* to access the bits of a float in  C quickly  */
 309                    /* we use a union defined in glheader.h         */
 310
 311    for(i=0; i<= 0x7f; i++) {
 312       fi.i = 0;
 313
 314       /*
 315        * Build a float with the bit pattern i as mantissa
 316        * and an exponent of 0, stored as 127
 317        */
 318
 319       fi.i = (i << 16) | (127 << 23);
 320       fi.f = _mesa_sqrtd(fi.f);
 321
 322       /*
 323        * Take the square root then strip the first 7 bits of
 324        * the mantissa into the table
 325        */
 326
 327       sqrttab[i] = (fi.i & 0x7fffff) >> 16;
 328
 329       /*
 330        * Repeat the process, this time with an exponent of
 331        * 1, stored as 128
 332        */
 333
 334       fi.i = 0;
 335       fi.i = (i << 16) | (128 << 23);
 336       fi.f = sqrt(fi.f);
 337       sqrttab[i+0x80] = (fi.i & 0x7fffff) >> 16;
 338    }
 339 #else
 340    (void) sqrttab;  /* silence compiler warnings */
 341 #endif /*HAVE_FAST_MATH*/
 342 }
 343
 344
 345 /**
 346  * Single precision square root.
 347  */
 348 float
 349 _mesa_sqrtf( float x )
 350 {
 351 #if defined(USE_IEEE) && !defined(DEBUG)
 352    fi_type num;
 353                                 /* to access the bits of a float in C
 354                                  * we use a union from glheader.h     */
 355
 356    short e;                     /* the exponent */
 357    if (x == 0.0F) return 0.0F;  /* check for square root of 0 */
 358    num.f = x;
 359    e = (num.i >> 23) - 127;     /* get the exponent - on a SPARC the */
 360                                 /* exponent is stored with 127 added */
 361    num.i &= 0x7fffff;           /* leave only the mantissa */
 362    if (e & 0x01) num.i |= 0x800000;
 363                                 /* the exponent is odd so we have to */
 364                                 /* look it up in the second half of  */
 365                                 /* the lookup table, so we set the   */
 366                                 /* high bit                                */
 367    e >>= 1;                     /* divide the exponent by two */
 368                                 /* note that in C the shift */
 369                                 /* operators are sign preserving */
 370                                 /* for signed operands */
 371    /* Do the table lookup, based on the quaternary mantissa,
 372     * then reconstruct the result back into a float
 373     */
 374    num.i = ((sqrttab[num.i >> 16]) << 16) | ((e + 127) << 23);
 375
 376    return num.f;
 377 #else
 378    return (float) _mesa_sqrtd((double) x);
 379 #endif
 380 }
 381
 382
 383 /**
 384  inv_sqrt - A single precision 1/sqrt routine for IEEE format floats.
 385  written by Josh Vanderhoof, based on newsgroup posts by James Van Buskirk
 386  and Vesa Karvonen.
 387 */
 388 float
 389 _mesa_inv_sqrtf(float n)
 390 {
 391 #if defined(USE_IEEE) && !defined(DEBUG)
 392         float r0, x0, y0;
 393         float r1, x1, y1;
 394         float r2, x2, y2;
 395 #if 0 /* not used, see below -BP */
 396         float r3, x3, y3;
 397 #endif
 398         fi_type u;
 399         unsigned int magic;
 400
 401         /*
 402          Exponent part of the magic number -
 403
 404          We want to:
 405          1. subtract the bias from the exponent,
 406          2. negate it
 407          3. divide by two (rounding towards -inf)
 408          4. add the bias back
 409
 410          Which is the same as subtracting the exponent from 381 and dividing
 411          by 2.
 412
 413          floor(-(x - 127) / 2) + 127 = floor((381 - x) / 2)
 414         */
 415
 416         magic = 381 << 23;
 417
 418         /*
 419          Significand part of magic number -
 420
 421          With the current magic number, "(magic - u.i) >> 1" will give you:
 422
 423          for 1 <= u.f <= 2: 1.25 - u.f / 4
 424          for 2 <= u.f <= 4: 1.00 - u.f / 8
 425
 426          This isn't a bad approximation of 1/sqrt.  The maximum difference from
 427          1/sqrt will be around .06.  After three Newton-Raphson iterations, the
 428          maximum difference is less than 4.5e-8.  (Which is actually close
 429          enough to make the following bias academic...)
 430
 431          To get a better approximation you can add a bias to the magic
 432          number.  For example, if you subtract 1/2 of the maximum difference in
 433          the first approximation (.03), you will get the following function:
 434
 435          for 1 <= u.f <= 2:    1.22 - u.f / 4
 436          for 2 <= u.f <= 3.76: 0.97 - u.f / 8
 437          for 3.76 <= u.f <= 4: 0.72 - u.f / 16
 438          (The 3.76 to 4 range is where the result is < .5.)
 439
 440          This is the closest possible initial approximation, but with a maximum
 441          error of 8e-11 after three NR iterations, it is still not perfect.  If
 442          you subtract 0.0332281 instead of .03, the maximum error will be
 443          2.5e-11 after three NR iterations, which should be about as close as
 444          is possible.
 445
 446          for 1 <= u.f <= 2:    1.2167719 - u.f / 4
 447          for 2 <= u.f <= 3.73: 0.9667719 - u.f / 8
 448          for 3.73 <= u.f <= 4: 0.7167719 - u.f / 16
 449
 450         */
 451
 452         magic -= (int)(0.0332281 * (1 << 25));
 453
 454         u.f = n;
 455         u.i = (magic - u.i) >> 1;
 456
 457         /*
 458          Instead of Newton-Raphson, we use Goldschmidt's algorithm, which
 459          allows more parallelism.  From what I understand, the parallelism
 460          comes at the cost of less precision, because it lets error
 461          accumulate across iterations.
 462         */
 463         x0 = 1.0f;
 464         y0 = 0.5f * n;
 465         r0 = u.f;
 466
 467         x1 = x0 * r0;
 468         y1 = y0 * r0 * r0;
 469         r1 = 1.5f - y1;
 470
 471         x2 = x1 * r1;
 472         y2 = y1 * r1 * r1;
 473         r2 = 1.5f - y2;
 474
 475 #if 1
 476         return x2 * r2;  /* we can stop here, and be conformant -BP */
 477 #else
 478         x3 = x2 * r2;
 479         y3 = y2 * r2 * r2;
 480         r3 = 1.5f - y3;
 481
 482         return x3 * r3;
 483 #endif
 484 #else
 485         return (float) (1.0 / sqrt(n));
 486 #endif
 487 }
 488
 489
 490 /** Wrapper around pow() */
 491 double
 492 _mesa_pow(double x, double y)
 493 {
 494    return pow(x, y);
 495 }
 496
 497
 498 /**
 499  * Find the first bit set in a word.
 500  */
 501 int
 502 _mesa_ffs(int32_t i)
 503 {
 504 #if (defined(_WIN32) ) || defined(__IBMC__) || defined(__IBMCPP__)
 505    register int bit = 0;
 506    if (i != 0) {
 507       if ((i & 0xffff) == 0) {
 508          bit += 16;
 509          i >>= 16;
 510       }
 511       if ((i & 0xff) == 0) {
 512          bit += 8;
 513          i >>= 8;
 514       }
 515       if ((i & 0xf) == 0) {
 516          bit += 4;
 517          i >>= 4;
 518       }
 519       while ((i & 1) == 0) {
 520          bit++;
 521          i >>= 1;
 522       }
 523       bit++;
 524    }
 525    return bit;
 526 #else
 527    return ffs(i);
 528 #endif
 529 }
 530
 531
 532 /**
 533  * Find position of first bit set in given value.
 534  * XXX Warning: this function can only be used on 64-bit systems!
 535  * \return  position of least-significant bit set, starting at 1, return zero
 536  *          if no bits set.
 537  */
 538 int
 539 _mesa_ffsll(int64_t val)
 540 {
 541 #ifdef ffsll
 542    return ffsll(val);
 543 #else
 544    int bit;
 545
 546    assert(sizeof(val) == 8);
 547
 548    bit = _mesa_ffs((int32_t)val);
 549    if (bit != 0)
 550       return bit;
 551
 552    bit = _mesa_ffs((int32_t)(val >> 32));
 553    if (bit != 0)
 554       return 32 + bit;
 555
 556    return 0;
 557 #endif
 558 }
 559
 560
 561 /**
 562  * Return number of bits set in given GLuint.
 563  */
 564 unsigned int
 565 _mesa_bitcount(unsigned int n)
 566 {
 567 #if defined(__GNUC__)
 568    return __builtin_popcount(n);
 569 #else
 570    unsigned int bits;
 571    for (bits = 0; n > 0; n = n >> 1) {
 572       bits += (n & 1);
 573    }
 574    return bits;
 575 #endif
 576 }
 577
 578
 579 /**
 580  * Convert a 4-byte float to a 2-byte half float.
 581  * Based on code from:
 582  * http://www.opengl.org/discussion_boards/ubb/Forum3/HTML/008786.html
 583  */
 584 GLhalfARB
 585 _mesa_float_to_half(float val)
 586 {
 587    const fi_type fi = {val};
 588    const int flt_m = fi.i & 0x7fffff;
 589    const int flt_e = (fi.i >> 23) & 0xff;
 590    const int flt_s = (fi.i >> 31) & 0x1;
 591    int s, e, m = 0;
 592    GLhalfARB result;
 593
 594    /* sign bit */
 595    s = flt_s;
 596
 597    /* handle special cases */
 598    if ((flt_e == 0) && (flt_m == 0)) {
 599       /* zero */
 600       /* m = 0; - already set */
 601       e = 0;
 602    }
 603    else if ((flt_e == 0) && (flt_m != 0)) {
 604       /* denorm -- denorm float maps to 0 half */
 605       /* m = 0; - already set */
 606       e = 0;
 607    }
 608    else if ((flt_e == 0xff) && (flt_m == 0)) {
 609       /* infinity */
 610       /* m = 0; - already set */
 611       e = 31;
 612    }
 613    else if ((flt_e == 0xff) && (flt_m != 0)) {
 614       /* NaN */
 615       m = 1;
 616       e = 31;
 617    }
 618    else {
 619       /* regular number */
 620       const int new_exp = flt_e - 127;
 621       if (new_exp < -24) {
 622          /* this maps to 0 */
 623          /* m = 0; - already set */
 624          e = 0;
 625       }
 626       else if (new_exp < -14) {
 627          /* this maps to a denorm */
 628          unsigned int exp_val = (unsigned int) (-14 - new_exp); /* 2^-exp_val*/
 629          e = 0;
 630          switch (exp_val) {
 631             case 0:
 632                _mesa_warning(NULL,
 633                    "float_to_half: logical error in denorm creation!\n");
 634                /* m = 0; - already set */
 635                break;
 636             case 1: m = 512 + (flt_m >> 14); break;
 637             case 2: m = 256 + (flt_m >> 15); break;
 638             case 3: m = 128 + (flt_m >> 16); break;
 639             case 4: m = 64 + (flt_m >> 17); break;
 640             case 5: m = 32 + (flt_m >> 18); break;
 641             case 6: m = 16 + (flt_m >> 19); break;
 642             case 7: m = 8 + (flt_m >> 20); break;
 643             case 8: m = 4 + (flt_m >> 21); break;
 644             case 9: m = 2 + (flt_m >> 22); break;
 645             case 10: m = 1; break;
 646          }
 647       }
 648       else if (new_exp > 15) {
 649          /* map this value to infinity */
 650          /* m = 0; - already set */
 651          e = 31;
 652       }
 653       else {
 654          /* regular */
 655          e = new_exp + 15;
 656          m = flt_m >> 13;
 657       }
 658    }
 659
 660    result = (s << 15) | (e << 10) | m;
 661    return result;
 662 }
 663
 664
 665 /**
 666  * Convert a 2-byte half float to a 4-byte float.
 667  * Based on code from:
 668  * http://www.opengl.org/discussion_boards/ubb/Forum3/HTML/008786.html
 669  */
 670 float
 671 _mesa_half_to_float(GLhalfARB val)
 672 {
 673    /* XXX could also use a 64K-entry lookup table */
 674    const int m = val & 0x3ff;
 675    const int e = (val >> 10) & 0x1f;
 676    const int s = (val >> 15) & 0x1;
 677    int flt_m, flt_e, flt_s;
 678    fi_type fi;
 679    float result;
 680
 681    /* sign bit */
 682    flt_s = s;
 683
 684    /* handle special cases */
 685    if ((e == 0) && (m == 0)) {
 686       /* zero */
 687       flt_m = 0;
 688       flt_e = 0;
 689    }
 690    else if ((e == 0) && (m != 0)) {
 691       /* denorm -- denorm half will fit in non-denorm single */
 692       const float half_denorm = 1.0f / 16384.0f; /* 2^-14 */
 693       float mantissa = ((float) (m)) / 1024.0f;
 694       float sign = s ? -1.0f : 1.0f;
 695       return sign * mantissa * half_denorm;
 696    }
 697    else if ((e == 31) && (m == 0)) {
 698       /* infinity */
 699       flt_e = 0xff;
 700       flt_m = 0;
 701    }
 702    else if ((e == 31) && (m != 0)) {
 703       /* NaN */
 704       flt_e = 0xff;
 705       flt_m = 1;
 706    }
 707    else {
 708       /* regular */
 709       flt_e = e + 112;
 710       flt_m = m << 13;
 711    }
 712
 713    fi.i = (flt_s << 31) | (flt_e << 23) | flt_m;
 714    result = fi.f;
 715    return result;
 716 }
 717
 718 /*@}*/
 719
 720
 721 /**********************************************************************/
 722 /** \name Sort & Search */
 723 /*@{*/
 724
 725 /**
 726  * Wrapper for bsearch().
 727  */
 728 void *
 729 _mesa_bsearch( const void *key, const void *base, size_t nmemb, size_t size,
 730                int (*compar)(const void *, const void *) )
 731 {
 732 #if defined(_WIN32_WCE)
 733    void *mid;
 734    int cmp;
 735    while (nmemb) {
 736       nmemb >>= 1;
 737       mid = (char *)base + nmemb * size;
 738       cmp = (*compar)(key, mid);
 739       if (cmp == 0)
 740          return mid;
 741       if (cmp > 0) {
 742          base = (char *)mid + size;
 743          --nmemb;
 744       }
 745    }
 746    return NULL;
 747 #else
 748    return bsearch(key, base, nmemb, size, compar);
 749 #endif
 750 }
 751
 752 /*@}*/
 753
 754
 755 /**********************************************************************/
 756 /** \name Environment vars */
 757 /*@{*/
 758
 759 /**
 760  * Wrapper for getenv().
 761  */
 762 char *
 763 _mesa_getenv( const char *var )
 764 {
 765 #if defined(_XBOX) || defined(_WIN32_WCE)
 766    return NULL;
 767 #else
 768    return getenv(var);
 769 #endif
 770 }
 771
 772 /*@}*/
 773
 774
 775 /**********************************************************************/
 776 /** \name String */
 777 /*@{*/
 778
 779 /**
 780  * Implemented using malloc() and strcpy.
 781  * Note that NULL is handled accordingly.
 782  */
 783 char *
 784 _mesa_strdup( const char *s )
 785 {
 786    if (s) {
 787       size_t l = strlen(s);
 788       char *s2 = (char *) malloc(l + 1);
 789       if (s2)
 790          strcpy(s2, s);
 791       return s2;
 792    }
 793    else {
 794       return NULL;
 795    }
 796 }
 797
 798 /** Wrapper around strtof() */
 799 float
 800 _mesa_strtof( const char *s, char **end )
 801 {
 802 #ifdef _GNU_SOURCE
 803    static locale_t loc = NULL;
 804    if (!loc) {
 805       loc = newlocale(LC_CTYPE_MASK, "C", NULL);
 806    }
 807    return strtof_l(s, end, loc);
 808 #elif defined(_ISOC99_SOURCE) || (defined(_XOPEN_SOURCE) && _XOPEN_SOURCE >= 600)
 809    return strtof(s, end);
 810 #else
 811    return (float)strtod(s, end);
 812 #endif
 813 }
 814
 815 /** Compute simple checksum/hash for a string */
 816 unsigned int
 817 _mesa_str_checksum(const char *str)
 818 {
 819    /* This could probably be much better */
 820    unsigned int sum, i;
 821    const char *c;
 822    sum = i = 1;
 823    for (c = str; *c; c++, i++)
 824       sum += *c * (i % 100);
 825    return sum + i;
 826 }
 827
 828
 829 /*@}*/
 830
 831
 832 /** Wrapper around vsnprintf() */
 833 int
 834 _mesa_snprintf( char *str, size_t size, const char *fmt, ... )
 835 {
 836    int r;
 837    va_list args;
 838    va_start( args, fmt );
 839    r = vsnprintf( str, size, fmt, args );
 840    va_end( args );
 841    return r;
 842 }
 843
 844
 845 /**********************************************************************/
 846 /** \name Diagnostics */
 847 /*@{*/
 848
 849 static void
 850 output_if_debug(const char *prefixString, const char *outputString,
 851                 GLboolean newline)
 852 {
 853    static int debug = -1;
 854
 855    /* Check the MESA_DEBUG environment variable if it hasn't
 856     * been checked yet.  We only have to check it once...
 857     */
 858    if (debug == -1) {
 859       char *env = _mesa_getenv("MESA_DEBUG");
 860
 861       /* In a debug build, we print warning messages *unless*
 862        * MESA_DEBUG is 0.  In a non-debug build, we don't
 863        * print warning messages *unless* MESA_DEBUG is
 864        * set *to any value*.
 865        */
 866 #ifdef DEBUG
 867       debug = (env != NULL && atoi(env) == 0) ? 0 : 1;
 868 #else
 869       debug = (env != NULL) ? 1 : 0;
 870 #endif
 871    }
 872
 873    /* Now only print the string if we're required to do so. */
 874    if (debug) {
 875       fprintf(stderr, "%s: %s", prefixString, outputString);
 876       if (newline)
 877          fprintf(stderr, "\n");
 878
 879 #if defined(_WIN32) && !defined(_WIN32_WCE)
 880       /* stderr from windows applications without console is not usually
 881        * visible, so communicate with the debugger instead */
 882       {
 883          char buf[4096];
 884          _mesa_snprintf(buf, sizeof(buf), "%s: %s%s", prefixString, outputString, newline ? "\n" : "");
 885          OutputDebugStringA(buf);
 886       }
 887 #endif
 888    }
 889 }
 890
 891
 892 /**
 893  * Return string version of GL error code.
 894  */
 895 static const char *
 896 error_string( GLenum error )
 897 {
 898    switch (error) {
 899    case GL_NO_ERROR:
 900       return "GL_NO_ERROR";
 901    case GL_INVALID_VALUE:
 902       return "GL_INVALID_VALUE";
 903    case GL_INVALID_ENUM:
 904       return "GL_INVALID_ENUM";
 905    case GL_INVALID_OPERATION:
 906       return "GL_INVALID_OPERATION";
 907    case GL_STACK_OVERFLOW:
 908       return "GL_STACK_OVERFLOW";
 909    case GL_STACK_UNDERFLOW:
 910       return "GL_STACK_UNDERFLOW";
 911    case GL_OUT_OF_MEMORY:
 912       return "GL_OUT_OF_MEMORY";
 913    case GL_TABLE_TOO_LARGE:
 914       return "GL_TABLE_TOO_LARGE";
 915    case GL_INVALID_FRAMEBUFFER_OPERATION_EXT:
 916       return "GL_INVALID_FRAMEBUFFER_OPERATION";
 917    default:
 918       return "unknown";
 919    }
 920 }
 921
 922
 923 /**
 924  * When a new type of error is recorded, print a message describing
 925  * previous errors which were accumulated.
 926  */
 927 static void
 928 flush_delayed_errors( GLcontext *ctx )
 929 {
 930    char s[MAXSTRING];
 931
 932    if (ctx->ErrorDebugCount) {
 933       _mesa_snprintf(s, MAXSTRING, "%d similar %s errors",
 934                      ctx->ErrorDebugCount,
 935                      error_string(ctx->ErrorValue));
 936
 937       output_if_debug("Mesa", s, GL_TRUE);
 938
 939       ctx->ErrorDebugCount = 0;
 940    }
 941 }
 942
 943
 944 /**
 945  * Report a warning (a recoverable error condition) to stderr if
 946  * either DEBUG is defined or the MESA_DEBUG env var is set.
 947  *
 948  * \param ctx GL context.
 949  * \param fmtString printf()-like format string.
 950  */
 951 void
 952 _mesa_warning( GLcontext *ctx, const char *fmtString, ... )
 953 {
 954    char str[MAXSTRING];
 955    va_list args;
 956    va_start( args, fmtString );
 957    (void) vsnprintf( str, MAXSTRING, fmtString, args );
 958    va_end( args );
 959
 960    if (ctx)
 961       flush_delayed_errors( ctx );
 962
 963    output_if_debug("Mesa warning", str, GL_TRUE);
 964 }
 965
 966
 967 /**
 968  * Report an internal implementation problem.
 969  * Prints the message to stderr via fprintf().
 970  *
 971  * \param ctx GL context.
 972  * \param fmtString problem description string.
 973  */
 974 void
 975 _mesa_problem( const GLcontext *ctx, const char *fmtString, ... )
 976 {
 977    va_list args;
 978    char str[MAXSTRING];
 979    (void) ctx;
 980
 981    va_start( args, fmtString );
 982    vsnprintf( str, MAXSTRING, fmtString, args );
 983    va_end( args );
 984
 985    fprintf(stderr, "Mesa %s implementation error: %s\n", MESA_VERSION_STRING, str);
 986    fprintf(stderr, "Please report at bugzilla.freedesktop.org\n");
 987 }
 988
 989
 990 /**
 991  * Record an OpenGL state error.  These usually occur when the user
 992  * passes invalid parameters to a GL function.
 993  *
 994  * If debugging is enabled (either at compile-time via the DEBUG macro, or
 995  * run-time via the MESA_DEBUG environment variable), report the error with
 996  * _mesa_debug().
 997  *
 998  * \param ctx the GL context.
 999  * \param error the error value.
1000  * \param fmtString printf() style format string, followed by optional args
1001  */
1002 void
1003 _mesa_error( GLcontext *ctx, GLenum error, const char *fmtString, ... )
1004 {
1005    static GLint debug = -1;
1006
1007    /* Check debug environment variable only once:
1008     */
1009    if (debug == -1) {
1010       const char *debugEnv = _mesa_getenv("MESA_DEBUG");
1011
1012 #ifdef DEBUG
1013       if (debugEnv && strstr(debugEnv, "silent"))
1014          debug = GL_FALSE;
1015       else
1016          debug = GL_TRUE;
1017 #else
1018       if (debugEnv)
1019          debug = GL_TRUE;
1020       else
1021          debug = GL_FALSE;
1022 #endif
1023    }
1024
1025    if (debug) {
1026       if (ctx->ErrorValue == error &&
1027           ctx->ErrorDebugFmtString == fmtString) {
1028          ctx->ErrorDebugCount++;
1029       }
1030       else {
1031          char s[MAXSTRING], s2[MAXSTRING];
1032          va_list args;
1033
1034          flush_delayed_errors( ctx );
1035
1036          va_start(args, fmtString);
1037          vsnprintf(s, MAXSTRING, fmtString, args);
1038          va_end(args);
1039
1040          _mesa_snprintf(s2, MAXSTRING, "%s in %s", error_string(error), s);
1041          output_if_debug("Mesa: User error", s2, GL_TRUE);
1042
1043          ctx->ErrorDebugFmtString = fmtString;
1044          ctx->ErrorDebugCount = 0;
1045       }
1046    }
1047
1048    _mesa_record_error(ctx, error);
1049 }
1050
1051
1052 /**
1053  * Report debug information.  Print error message to stderr via fprintf().
1054  * No-op if DEBUG mode not enabled.
1055  *
1056  * \param ctx GL context.
1057  * \param fmtString printf()-style format string, followed by optional args.
1058  */
1059 void
1060 _mesa_debug( const GLcontext *ctx, const char *fmtString, ... )
1061 {
1062 #ifdef DEBUG
1063    char s[MAXSTRING];
1064    va_list args;
1065    va_start(args, fmtString);
1066    vsnprintf(s, MAXSTRING, fmtString, args);
1067    va_end(args);
1068    output_if_debug("Mesa", s, GL_FALSE);
1069 #endif /* DEBUG */
1070    (void) ctx;
1071    (void) fmtString;
1072 }
1073
1074 /*@}*/