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  * The OpenGL SI's __GLimports structure allows per-context specification of
  16  * replacements for the standard C lib functions.  In practice that's probably
  17  * never needed; compile-time replacements are far more likely.
  18  *
  19  * The _mesa_*() functions defined here don't in general take a context
  20  * parameter.  I guess we can change that someday, if need be.
  21  * So for now, the __GLimports stuff really isn't used.
  22  *
  23  * \todo Functions still needed:
  24  * - scanf
  25  * - qsort
  26  * - bsearch
  27  * - rand and RAND_MAX
  28  *
  29  * \note When compiled into a XFree86 module these functions wrap around
  30  * XFree86 own wrappers.
  31  */
  32
  33 /*
  34  * Mesa 3-D graphics library
  35  * Version:  6.2
  36  *
  37  * Copyright (C) 1999-2004  Brian Paul   All Rights Reserved.
  38  *
  39  * Permission is hereby granted, free of charge, to any person obtaining a
  40  * copy of this software and associated documentation files (the "Software"),
  41  * to deal in the Software without restriction, including without limitation
  42  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  43  * and/or sell copies of the Software, and to permit persons to whom the
  44  * Software is furnished to do so, subject to the following conditions:
  45  *
  46  * The above copyright notice and this permission notice shall be included
  47  * in all copies or substantial portions of the Software.
  48  *
  49  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  50  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  51  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  52  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  53  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  54  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  55  */
  56
  57
  58
  59 #include "imports.h"
  60 #include "context.h"
  61 #include "version.h"
  62
  63
  64 #define MAXSTRING 4000  /* for vsnprintf() */
  65
  66 #ifdef WIN32
  67 #define vsnprintf _vsnprintf
  68 #elif defined(__IBMC__) || defined(__IBMCPP__) || ( defined(__VMS) && __CRTL_VER < 70312000 )
  69 extern int vsnprintf(char *str, size_t count, const char *fmt, va_list arg);
  70 #ifdef __VMS
  71 #include "vsnprintf.c"
  72 #endif
  73 #endif
  74
  75
  76 /**********************************************************************/
  77 /** \name Memory */
  78 /*@{*/
  79
  80 /** Wrapper around either malloc() or xf86malloc() */
  81 void *
  82 _mesa_malloc(size_t bytes)
  83 {
  84 #if defined(XFree86LOADER) && defined(IN_MODULE)
  85    return xf86malloc(bytes);
  86 #else
  87    return malloc(bytes);
  88 #endif
  89 }
  90
  91 /** Wrapper around either calloc() or xf86calloc() */
  92 void *
  93 _mesa_calloc(size_t bytes)
  94 {
  95 #if defined(XFree86LOADER) && defined(IN_MODULE)
  96    return xf86calloc(1, bytes);
  97 #else
  98    return calloc(1, bytes);
  99 #endif
 100 }
 101
 102 /** Wrapper around either free() or xf86free() */
 103 void
 104 _mesa_free(void *ptr)
 105 {
 106 #if defined(XFree86LOADER) && defined(IN_MODULE)
 107    xf86free(ptr);
 108 #else
 109    free(ptr);
 110 #endif
 111 }
 112
 113 /**
 114  * Allocate aligned memory.
 115  *
 116  * \param bytes number of bytes to allocate.
 117  * \param alignment alignment (must be greater than zero).
 118  *
 119  * Allocates extra memory to accommodate rounding up the address for
 120  * alignment and to record the real malloc address.
 121  *
 122  * \sa _mesa_align_free().
 123  */
 124 void *
 125 _mesa_align_malloc(size_t bytes, unsigned long alignment)
 126 {
 127    unsigned long ptr, buf;
 128
 129    ASSERT( alignment > 0 );
 130
 131    ptr = (unsigned long) _mesa_malloc(bytes + alignment + sizeof(void *));
 132    if (!ptr)
 133       return NULL;
 134
 135    buf = (ptr + alignment + sizeof(void *)) & ~(unsigned long)(alignment - 1);
 136    *(unsigned long *)(buf - sizeof(void *)) = ptr;
 137
 138 #ifdef DEBUG
 139    /* mark the non-aligned area */
 140    while ( ptr < buf - sizeof(void *) ) {
 141       *(unsigned long *)ptr = 0xcdcdcdcd;
 142       ptr += sizeof(unsigned long);
 143    }
 144 #endif
 145
 146    return (void *) buf;
 147 }
 148
 149 /** Same as _mesa_align_malloc(), but using _mesa_calloc() instead of
 150  * _mesa_malloc() */
 151 void *
 152 _mesa_align_calloc(size_t bytes, unsigned long alignment)
 153 {
 154    unsigned long ptr, buf;
 155
 156    ASSERT( alignment > 0 );
 157
 158    ptr = (unsigned long) _mesa_calloc(bytes + alignment + sizeof(void *));
 159    if (!ptr)
 160       return NULL;
 161
 162    buf = (ptr + alignment + sizeof(void *)) & ~(unsigned long)(alignment - 1);
 163    *(unsigned long *)(buf - sizeof(void *)) = ptr;
 164
 165 #ifdef DEBUG
 166    /* mark the non-aligned area */
 167    while ( ptr < buf - sizeof(void *) ) {
 168       *(unsigned long *)ptr = 0xcdcdcdcd;
 169       ptr += sizeof(unsigned long);
 170    }
 171 #endif
 172
 173    return (void *)buf;
 174 }
 175
 176 /**
 177  * Free memory allocated with _mesa_align_malloc() or _mesa_align_calloc().
 178  *
 179  * \param ptr pointer to the memory to be freed.
 180  *
 181  * The actual address to free is stored in the word immediately before the
 182  * address the client sees.
 183  */
 184 void
 185 _mesa_align_free(void *ptr)
 186 {
 187 #if 0
 188    _mesa_free( (void *)(*(unsigned long *)((unsigned long)ptr - sizeof(void *))) );
 189 #else
 190    void **cubbyHole = (void **) ((char *) ptr - sizeof(void *));
 191    void *realAddr = *cubbyHole;
 192    _mesa_free(realAddr);
 193 #endif
 194 }
 195
 196 /** Wrapper around either memcpy() or xf86memcpy() */
 197 void *
 198 _mesa_realloc(void *oldBuffer, size_t oldSize, size_t newSize)
 199 {
 200    const size_t copySize = (oldSize < newSize) ? oldSize : newSize;
 201    void *newBuffer = _mesa_malloc(newSize);
 202    if (newBuffer && copySize > 0)
 203       _mesa_memcpy(newBuffer, oldBuffer, copySize);
 204    if (oldBuffer)
 205       _mesa_free(oldBuffer);
 206    return newBuffer;
 207 }
 208
 209
 210 void *
 211 _mesa_memcpy(void *dest, const void *src, size_t n)
 212 {
 213 #if defined(XFree86LOADER) && defined(IN_MODULE)
 214    return xf86memcpy(dest, src, n);
 215 #elif defined(SUNOS4)
 216    return memcpy((char *) dest, (char *) src, (int) n);
 217 #else
 218    return memcpy(dest, src, n);
 219 #endif
 220 }
 221
 222 /** Wrapper around either memset() or xf86memset() */
 223 void
 224 _mesa_memset( void *dst, int val, size_t n )
 225 {
 226 #if defined(XFree86LOADER) && defined(IN_MODULE)
 227    xf86memset( dst, val, n );
 228 #elif defined(SUNOS4)
 229    memset( (char *) dst, (int) val, (int) n );
 230 #else
 231    memset(dst, val, n);
 232 #endif
 233 }
 234
 235 /** Fill memory with a constant 16bit word.
 236  *
 237  * \param dst destination pointer.
 238  * \param val value.
 239  * \param n number of words.
 240  */
 241 void
 242 _mesa_memset16( unsigned short *dst, unsigned short val, size_t n )
 243 {
 244    while (n-- > 0)
 245       *dst++ = val;
 246 }
 247
 248 /** Wrapper around either memcpy() or xf86memcpy() or bzero() */
 249 void
 250 _mesa_bzero( void *dst, size_t n )
 251 {
 252 #if defined(XFree86LOADER) && defined(IN_MODULE)
 253    xf86memset( dst, 0, n );
 254 #elif defined(__FreeBSD__)
 255    bzero( dst, n );
 256 #else
 257    memset( dst, 0, n );
 258 #endif
 259 }
 260
 261 /*@}*/
 262
 263
 264 /**********************************************************************/
 265 /** \name Math */
 266 /*@{*/
 267
 268 /** Wrapper around either sin() or xf86sin() */
 269 double
 270 _mesa_sin(double a)
 271 {
 272 #if defined(XFree86LOADER) && defined(IN_MODULE)
 273    return xf86sin(a);
 274 #else
 275    return sin(a);
 276 #endif
 277 }
 278
 279 /** Wrapper around either cos() or xf86cos() */
 280 double
 281 _mesa_cos(double a)
 282 {
 283 #if defined(XFree86LOADER) && defined(IN_MODULE)
 284    return xf86cos(a);
 285 #else
 286    return cos(a);
 287 #endif
 288 }
 289
 290 /** Wrapper around either sqrt() or xf86sqrt() */
 291 double
 292 _mesa_sqrtd(double x)
 293 {
 294 #if defined(XFree86LOADER) && defined(IN_MODULE)
 295    return xf86sqrt(x);
 296 #else
 297    return sqrt(x);
 298 #endif
 299 }
 300
 301
 302 /*
 303  * A High Speed, Low Precision Square Root
 304  * by Paul Lalonde and Robert Dawson
 305  * from "Graphics Gems", Academic Press, 1990
 306  *
 307  * SPARC implementation of a fast square root by table
 308  * lookup.
 309  * SPARC floating point format is as follows:
 310  *
 311  * BIT 31       30      23      22      0
 312  *     sign     exponent        mantissa
 313  */
 314 static short sqrttab[0x100];    /* declare table of square roots */
 315
 316 static void init_sqrt_table(void)
 317 {
 318 #if defined(USE_IEEE) && !defined(DEBUG)
 319    unsigned short i;
 320    fi_type fi;     /* to access the bits of a float in  C quickly  */
 321                    /* we use a union defined in glheader.h         */
 322
 323    for(i=0; i<= 0x7f; i++) {
 324       fi.i = 0;
 325
 326       /*
 327        * Build a float with the bit pattern i as mantissa
 328        * and an exponent of 0, stored as 127
 329        */
 330
 331       fi.i = (i << 16) | (127 << 23);
 332       fi.f = _mesa_sqrtd(fi.f);
 333
 334       /*
 335        * Take the square root then strip the first 7 bits of
 336        * the mantissa into the table
 337        */
 338
 339       sqrttab[i] = (fi.i & 0x7fffff) >> 16;
 340
 341       /*
 342        * Repeat the process, this time with an exponent of
 343        * 1, stored as 128
 344        */
 345
 346       fi.i = 0;
 347       fi.i = (i << 16) | (128 << 23);
 348       fi.f = sqrt(fi.f);
 349       sqrttab[i+0x80] = (fi.i & 0x7fffff) >> 16;
 350    }
 351 #else
 352    (void) sqrttab;  /* silence compiler warnings */
 353 #endif /*HAVE_FAST_MATH*/
 354 }
 355
 356
 357 /**
 358  * Single precision square root.
 359  */
 360 float
 361 _mesa_sqrtf( float x )
 362 {
 363 #if defined(USE_IEEE) && !defined(DEBUG)
 364    fi_type num;
 365                                 /* to access the bits of a float in C
 366                                  * we use a union from glheader.h     */
 367
 368    short e;                     /* the exponent */
 369    if (x == 0.0F) return 0.0F;  /* check for square root of 0 */
 370    num.f = x;
 371    e = (num.i >> 23) - 127;     /* get the exponent - on a SPARC the */
 372                                 /* exponent is stored with 127 added */
 373    num.i &= 0x7fffff;           /* leave only the mantissa */
 374    if (e & 0x01) num.i |= 0x800000;
 375                                 /* the exponent is odd so we have to */
 376                                 /* look it up in the second half of  */
 377                                 /* the lookup table, so we set the   */
 378                                 /* high bit                                */
 379    e >>= 1;                     /* divide the exponent by two */
 380                                 /* note that in C the shift */
 381                                 /* operators are sign preserving */
 382                                 /* for signed operands */
 383    /* Do the table lookup, based on the quaternary mantissa,
 384     * then reconstruct the result back into a float
 385     */
 386    num.i = ((sqrttab[num.i >> 16]) << 16) | ((e + 127) << 23);
 387
 388    return num.f;
 389 #else
 390    return (float) _mesa_sqrtd((double) x);
 391 #endif
 392 }
 393
 394
 395 /**
 396  inv_sqrt - A single precision 1/sqrt routine for IEEE format floats.
 397  written by Josh Vanderhoof, based on newsgroup posts by James Van Buskirk
 398  and Vesa Karvonen.
 399 */
 400 float
 401 _mesa_inv_sqrtf(float n)
 402 {
 403 #if defined(USE_IEEE) && !defined(DEBUG)
 404         float r0, x0, y0;
 405         float r1, x1, y1;
 406         float r2, x2, y2;
 407 #if 0 /* not used, see below -BP */
 408         float r3, x3, y3;
 409 #endif
 410         union { float f; unsigned int i; } u;
 411         unsigned int magic;
 412
 413         /*
 414          Exponent part of the magic number -
 415
 416          We want to:
 417          1. subtract the bias from the exponent,
 418          2. negate it
 419          3. divide by two (rounding towards -inf)
 420          4. add the bias back
 421
 422          Which is the same as subtracting the exponent from 381 and dividing
 423          by 2.
 424
 425          floor(-(x - 127) / 2) + 127 = floor((381 - x) / 2)
 426         */
 427
 428         magic = 381 << 23;
 429
 430         /*
 431          Significand part of magic number -
 432
 433          With the current magic number, "(magic - u.i) >> 1" will give you:
 434
 435          for 1 <= u.f <= 2: 1.25 - u.f / 4
 436          for 2 <= u.f <= 4: 1.00 - u.f / 8
 437
 438          This isn't a bad approximation of 1/sqrt.  The maximum difference from
 439          1/sqrt will be around .06.  After three Newton-Raphson iterations, the
 440          maximum difference is less than 4.5e-8.  (Which is actually close
 441          enough to make the following bias academic...)
 442
 443          To get a better approximation you can add a bias to the magic
 444          number.  For example, if you subtract 1/2 of the maximum difference in
 445          the first approximation (.03), you will get the following function:
 446
 447          for 1 <= u.f <= 2:    1.22 - u.f / 4
 448          for 2 <= u.f <= 3.76: 0.97 - u.f / 8
 449          for 3.76 <= u.f <= 4: 0.72 - u.f / 16
 450          (The 3.76 to 4 range is where the result is < .5.)
 451
 452          This is the closest possible initial approximation, but with a maximum
 453          error of 8e-11 after three NR iterations, it is still not perfect.  If
 454          you subtract 0.0332281 instead of .03, the maximum error will be
 455          2.5e-11 after three NR iterations, which should be about as close as
 456          is possible.
 457
 458          for 1 <= u.f <= 2:    1.2167719 - u.f / 4
 459          for 2 <= u.f <= 3.73: 0.9667719 - u.f / 8
 460          for 3.73 <= u.f <= 4: 0.7167719 - u.f / 16
 461
 462         */
 463
 464         magic -= (int)(0.0332281 * (1 << 25));
 465
 466         u.f = n;
 467         u.i = (magic - u.i) >> 1;
 468
 469         /*
 470          Instead of Newton-Raphson, we use Goldschmidt's algorithm, which
 471          allows more parallelism.  From what I understand, the parallelism
 472          comes at the cost of less precision, because it lets error
 473          accumulate across iterations.
 474         */
 475         x0 = 1.0f;
 476         y0 = 0.5f * n;
 477         r0 = u.f;
 478
 479         x1 = x0 * r0;
 480         y1 = y0 * r0 * r0;
 481         r1 = 1.5f - y1;
 482
 483         x2 = x1 * r1;
 484         y2 = y1 * r1 * r1;
 485         r2 = 1.5f - y2;
 486
 487 #if 1
 488         return x2 * r2;  /* we can stop here, and be conformant -BP */
 489 #else
 490         x3 = x2 * r2;
 491         y3 = y2 * r2 * r2;
 492         r3 = 1.5f - y3;
 493
 494         return x3 * r3;
 495 #endif
 496 #elif defined(XFree86LOADER) && defined(IN_MODULE)
 497         return 1.0F / xf86sqrt(n);
 498 #else
 499         return (float) (1.0 / sqrt(n));
 500 #endif
 501 }
 502
 503
 504 /**
 505  * Wrapper around either pow() or xf86pow().
 506  */
 507 double
 508 _mesa_pow(double x, double y)
 509 {
 510 #if defined(XFree86LOADER) && defined(IN_MODULE)
 511    return xf86pow(x, y);
 512 #else
 513    return pow(x, y);
 514 #endif
 515 }
 516
 517
 518 /**
 519  * Return number of bits set in given GLuint.
 520  */
 521 unsigned int
 522 _mesa_bitcount(unsigned int n)
 523 {
 524    unsigned int bits;
 525    for (bits = 0; n > 0; n = n >> 1) {
 526       bits += (n & 1);
 527    }
 528    return bits;
 529 }
 530
 531
 532 /**
 533  * Convert a 4-byte float to a 2-byte half float.
 534  * Based on code from:
 535  * http://www.opengl.org/discussion_boards/ubb/Forum3/HTML/008786.html
 536  */
 537 GLhalfARB
 538 _mesa_float_to_half(float val)
 539 {
 540    const int flt = *((int *) (void *) &val);
 541    const int flt_m = flt & 0x7fffff;
 542    const int flt_e = (flt >> 23) & 0xff;
 543    const int flt_s = (flt >> 31) & 0x1;
 544    int s, e, m = 0;
 545    GLhalfARB result;
 546
 547    /* sign bit */
 548    s = flt_s;
 549
 550    /* handle special cases */
 551    if ((flt_e == 0) && (flt_m == 0)) {
 552       /* zero */
 553       /* m = 0; - already set */
 554       e = 0;
 555    }
 556    else if ((flt_e == 0) && (flt_m != 0)) {
 557       /* denorm -- denorm float maps to 0 half */
 558       /* m = 0; - already set */
 559       e = 0;
 560    }
 561    else if ((flt_e == 0xff) && (flt_m == 0)) {
 562       /* infinity */
 563       /* m = 0; - already set */
 564       e = 31;
 565    }
 566    else if ((flt_e == 0xff) && (flt_m != 0)) {
 567       /* NaN */
 568       m = 1;
 569       e = 31;
 570    }
 571    else {
 572       /* regular number */
 573       const int new_exp = flt_e - 127;
 574       if (new_exp < -24) {
 575          /* this maps to 0 */
 576          /* m = 0; - already set */
 577          e = 0;
 578       }
 579       else if (new_exp < -14) {
 580          /* this maps to a denorm */
 581          unsigned int exp_val = (unsigned int) (-14 - new_exp); /* 2^-exp_val*/
 582          e = 0;
 583          switch (exp_val) {
 584             case 0:
 585                _mesa_warning(NULL,
 586                    "float_to_half: logical error in denorm creation!\n");
 587                /* m = 0; - already set */
 588                break;
 589             case 1: m = 512 + (flt_m >> 14); break;
 590             case 2: m = 256 + (flt_m >> 15); break;
 591             case 3: m = 128 + (flt_m >> 16); break;
 592             case 4: m = 64 + (flt_m >> 17); break;
 593             case 5: m = 32 + (flt_m >> 18); break;
 594             case 6: m = 16 + (flt_m >> 19); break;
 595             case 7: m = 8 + (flt_m >> 20); break;
 596             case 8: m = 4 + (flt_m >> 21); break;
 597             case 9: m = 2 + (flt_m >> 22); break;
 598             case 10: m = 1; break;
 599          }
 600       }
 601       else if (new_exp > 15) {
 602          /* map this value to infinity */
 603          /* m = 0; - already set */
 604          e = 31;
 605       }
 606       else {
 607          /* regular */
 608          e = new_exp + 15;
 609          m = flt_m >> 13;
 610       }
 611    }
 612
 613    result = (s << 15) | (e << 10) | m;
 614    return result;
 615 }
 616
 617
 618 /**
 619  * Convert a 2-byte half float to a 4-byte float.
 620  * Based on code from:
 621  * http://www.opengl.org/discussion_boards/ubb/Forum3/HTML/008786.html
 622  */
 623 float
 624 _mesa_half_to_float(GLhalfARB val)
 625 {
 626    /* XXX could also use a 64K-entry lookup table */
 627    const int m = val & 0x3ff;
 628    const int e = (val >> 10) & 0x1f;
 629    const int s = (val >> 15) & 0x1;
 630    int flt_m, flt_e, flt_s, flt;
 631    float result;
 632
 633    /* sign bit */
 634    flt_s = s;
 635
 636    /* handle special cases */
 637    if ((e == 0) && (m == 0)) {
 638       /* zero */
 639       flt_m = 0;
 640       flt_e = 0;
 641    }
 642    else if ((e == 0) && (m != 0)) {
 643       /* denorm -- denorm half will fit in non-denorm single */
 644       const float half_denorm = 1.0f / 16384.0f; /* 2^-14 */
 645       float mantissa = ((float) (m)) / 1024.0f;
 646       float sign = s ? -1.0f : 1.0f;
 647       return sign * mantissa * half_denorm;
 648    }
 649    else if ((e == 31) && (m == 0)) {
 650       /* infinity */
 651       flt_e = 0xff;
 652       flt_m = 0;
 653    }
 654    else if ((e == 31) && (m != 0)) {
 655       /* NaN */
 656       flt_e = 0xff;
 657       flt_m = 1;
 658    }
 659    else {
 660       /* regular */
 661       flt_e = e + 112;
 662       flt_m = m << 13;
 663    }
 664
 665    flt = (flt_s << 31) | (flt_e << 23) | flt_m;
 666    result = *((float *) (void *) &flt);
 667    return result;
 668 }
 669
 670 /*@}*/
 671
 672
 673 /**********************************************************************/
 674 /** \name Environment vars */
 675 /*@{*/
 676
 677 /**
 678  * Wrapper for getenv().
 679  */
 680 char *
 681 _mesa_getenv( const char *var )
 682 {
 683 #if defined(XFree86LOADER) && defined(IN_MODULE)
 684    return xf86getenv(var);
 685 #else
 686    return getenv(var);
 687 #endif
 688 }
 689
 690 /*@}*/
 691
 692
 693 /**********************************************************************/
 694 /** \name String */
 695 /*@{*/
 696
 697 /** Wrapper around either strstr() or xf86strstr() */
 698 char *
 699 _mesa_strstr( const char *haystack, const char *needle )
 700 {
 701 #if defined(XFree86LOADER) && defined(IN_MODULE)
 702    return xf86strstr(haystack, needle);
 703 #else
 704    return strstr(haystack, needle);
 705 #endif
 706 }
 707
 708 /** Wrapper around either strncat() or xf86strncat() */
 709 char *
 710 _mesa_strncat( char *dest, const char *src, size_t n )
 711 {
 712 #if defined(XFree86LOADER) && defined(IN_MODULE)
 713    return xf86strncat(dest, src, n);
 714 #else
 715    return strncat(dest, src, n);
 716 #endif
 717 }
 718
 719 /** Wrapper around either strcpy() or xf86strcpy() */
 720 char *
 721 _mesa_strcpy( char *dest, const char *src )
 722 {
 723 #if defined(XFree86LOADER) && defined(IN_MODULE)
 724    return xf86strcpy(dest, src);
 725 #else
 726    return strcpy(dest, src);
 727 #endif
 728 }
 729
 730 /** Wrapper around either strncpy() or xf86strncpy() */
 731 char *
 732 _mesa_strncpy( char *dest, const char *src, size_t n )
 733 {
 734 #if defined(XFree86LOADER) && defined(IN_MODULE)
 735    return xf86strncpy(dest, src, n);
 736 #else
 737    return strncpy(dest, src, n);
 738 #endif
 739 }
 740
 741 /** Wrapper around either strlen() or xf86strlen() */
 742 size_t
 743 _mesa_strlen( const char *s )
 744 {
 745 #if defined(XFree86LOADER) && defined(IN_MODULE)
 746    return xf86strlen(s);
 747 #else
 748    return strlen(s);
 749 #endif
 750 }
 751
 752 /** Wrapper around either strcmp() or xf86strcmp() */
 753 int
 754 _mesa_strcmp( const char *s1, const char *s2 )
 755 {
 756 #if defined(XFree86LOADER) && defined(IN_MODULE)
 757    return xf86strcmp(s1, s2);
 758 #else
 759    return strcmp(s1, s2);
 760 #endif
 761 }
 762
 763 /** Wrapper around either strncmp() or xf86strncmp() */
 764 int
 765 _mesa_strncmp( const char *s1, const char *s2, size_t n )
 766 {
 767 #if defined(XFree86LOADER) && defined(IN_MODULE)
 768    return xf86strncmp(s1, s2, n);
 769 #else
 770    return strncmp(s1, s2, n);
 771 #endif
 772 }
 773
 774 /** Implemented using _mesa_malloc() and _mesa_strcpy */
 775 char *
 776 _mesa_strdup( const char *s )
 777 {
 778    int l = _mesa_strlen(s);
 779    char *s2 = (char *) _mesa_malloc(l + 1);
 780    if (s2)
 781       _mesa_strcpy(s2, s);
 782    return s2;
 783 }
 784
 785 /** Wrapper around either atoi() or xf86atoi() */
 786 int
 787 _mesa_atoi(const char *s)
 788 {
 789 #if defined(XFree86LOADER) && defined(IN_MODULE)
 790    return xf86atoi(s);
 791 #else
 792    return atoi(s);
 793 #endif
 794 }
 795
 796 /** Wrapper around either strtod() or xf86strtod() */
 797 double
 798 _mesa_strtod( const char *s, char **end )
 799 {
 800 #if defined(XFree86LOADER) && defined(IN_MODULE)
 801    return xf86strtod(s, end);
 802 #else
 803    return strtod(s, end);
 804 #endif
 805 }
 806
 807 /*@}*/
 808
 809
 810 /**********************************************************************/
 811 /** \name I/O */
 812 /*@{*/
 813
 814 /** Wrapper around either vsprintf() or xf86vsprintf() */
 815 int
 816 _mesa_sprintf( char *str, const char *fmt, ... )
 817 {
 818    int r;
 819    va_list args;
 820    va_start( args, fmt );
 821    va_end( args );
 822 #if defined(XFree86LOADER) && defined(IN_MODULE)
 823    r = xf86vsprintf( str, fmt, args );
 824 #else
 825    r = vsprintf( str, fmt, args );
 826 #endif
 827    return r;
 828 }
 829
 830 /** Wrapper around either printf() or xf86printf(), using vsprintf() for
 831  * the formatting. */
 832 void
 833 _mesa_printf( const char *fmtString, ... )
 834 {
 835    char s[MAXSTRING];
 836    va_list args;
 837    va_start( args, fmtString );
 838    vsnprintf(s, MAXSTRING, fmtString, args);
 839    va_end( args );
 840 #if defined(XFree86LOADER) && defined(IN_MODULE)
 841    xf86printf("%s", s);
 842 #else
 843    printf("%s", s);
 844 #endif
 845 }
 846
 847 /*@}*/
 848
 849
 850 /**********************************************************************/
 851 /** \name Diagnostics */
 852 /*@{*/
 853
 854 /**
 855  * Display a warning.
 856  *
 857  * \param ctx GL context.
 858  * \param fmtString printf() alike format string.
 859  *
 860  * If debugging is enabled (either at compile-time via the DEBUG macro, or
 861  * run-time via the MESA_DEBUG environment variable), prints the warning to
 862  * stderr, either via fprintf() or xf86printf().
 863  */
 864 void
 865 _mesa_warning( GLcontext *ctx, const char *fmtString, ... )
 866 {
 867    GLboolean debug;
 868    char str[MAXSTRING];
 869    va_list args;
 870    (void) ctx;
 871    va_start( args, fmtString );
 872    (void) vsnprintf( str, MAXSTRING, fmtString, args );
 873    va_end( args );
 874 #ifdef DEBUG
 875    debug = GL_TRUE; /* always print warning */
 876 #else
 877    debug = _mesa_getenv("MESA_DEBUG") ? GL_TRUE : GL_FALSE;
 878 #endif
 879    if (debug) {
 880 #if defined(XFree86LOADER) && defined(IN_MODULE)
 881       xf86fprintf(stderr, "Mesa warning: %s\n", str);
 882 #else
 883       fprintf(stderr, "Mesa warning: %s\n", str);
 884 #endif
 885    }
 886 }
 887
 888 /**
 889  * This function is called when the Mesa user has stumbled into a code
 890  * path which may not be implemented fully or correctly.
 891  *
 892  * \param ctx GL context.
 893  * \param s problem description string.
 894  *
 895  * Prints the message to stderr, either via fprintf() or xf86fprintf().
 896  */
 897 void
 898 _mesa_problem( const GLcontext *ctx, const char *fmtString, ... )
 899 {
 900    va_list args;
 901    char str[MAXSTRING];
 902    (void) ctx;
 903
 904    va_start( args, fmtString );
 905    vsnprintf( str, MAXSTRING, fmtString, args );
 906    va_end( args );
 907
 908 #if defined(XFree86LOADER) && defined(IN_MODULE)
 909    xf86fprintf(stderr, "Mesa %s implementation error: %s\n", MESA_VERSION_STRING, str);
 910    xf86fprintf(stderr, "Please report to the DRI project at dri.sourceforge.net\n");
 911 #else
 912    fprintf(stderr, "Mesa %s implementation error: %s\n", MESA_VERSION_STRING, str);
 913    fprintf(stderr, "Please report to the Mesa bug database at www.mesa3d.org\n" );
 914 #endif
 915 }
 916
 917 /**
 918  * Display an error message.
 919  *
 920  * If in debug mode, print error message.
 921  * Also, record the error code by calling _mesa_record_error().
 922  *
 923  * \param ctx the GL context.
 924  * \param error the error value.
 925  * \param fmtString printf() style format string, followed by optional args
 926  *
 927  * If debugging is enabled (either at compile-time via the DEBUG macro, or
 928  * run-time via the MESA_DEBUG environment variable), interperts the error code and
 929  * prints the error message via _mesa_debug().
 930  */
 931 void
 932 _mesa_error( GLcontext *ctx, GLenum error, const char *fmtString, ... )
 933 {
 934    const char *debugEnv;
 935    GLboolean debug;
 936
 937    debugEnv = _mesa_getenv("MESA_DEBUG");
 938
 939 #ifdef DEBUG
 940    if (debugEnv && _mesa_strstr(debugEnv, "silent"))
 941       debug = GL_FALSE;
 942    else
 943       debug = GL_TRUE;
 944 #else
 945    if (debugEnv)
 946       debug = GL_TRUE;
 947    else
 948       debug = GL_FALSE;
 949 #endif
 950
 951    if (debug) {
 952       va_list args;
 953       char where[MAXSTRING];
 954       const char *errstr;
 955
 956       va_start( args, fmtString );
 957       vsnprintf( where, MAXSTRING, fmtString, args );
 958       va_end( args );
 959
 960       switch (error) {
 961          case GL_NO_ERROR:
 962             errstr = "GL_NO_ERROR";
 963             break;
 964          case GL_INVALID_VALUE:
 965             errstr = "GL_INVALID_VALUE";
 966             break;
 967          case GL_INVALID_ENUM:
 968             errstr = "GL_INVALID_ENUM";
 969             break;
 970          case GL_INVALID_OPERATION:
 971             errstr = "GL_INVALID_OPERATION";
 972             break;
 973          case GL_STACK_OVERFLOW:
 974             errstr = "GL_STACK_OVERFLOW";
 975             break;
 976          case GL_STACK_UNDERFLOW:
 977             errstr = "GL_STACK_UNDERFLOW";
 978             break;
 979          case GL_OUT_OF_MEMORY:
 980             errstr = "GL_OUT_OF_MEMORY";
 981             break;
 982          case GL_TABLE_TOO_LARGE:
 983             errstr = "GL_TABLE_TOO_LARGE";
 984             break;
 985          default:
 986             errstr = "unknown";
 987             break;
 988       }
 989       _mesa_debug(ctx, "User error: %s in %s\n", errstr, where);
 990    }
 991
 992    _mesa_record_error(ctx, error);
 993 }
 994
 995 /**
 996  * Report debug information.
 997  *
 998  * \param ctx GL context.
 999  * \param fmtString printf() alike format string.
1000  *
1001  * Prints the message to stderr, either via fprintf() or xf86printf().
1002  */
1003 void
1004 _mesa_debug( const GLcontext *ctx, const char *fmtString, ... )
1005 {
1006    char s[MAXSTRING];
1007    va_list args;
1008    (void) ctx;
1009    va_start(args, fmtString);
1010    vsnprintf(s, MAXSTRING, fmtString, args);
1011    va_end(args);
1012 #if defined(XFree86LOADER) && defined(IN_MODULE)
1013    xf86fprintf(stderr, "Mesa: %s", s);
1014 #else
1015    fprintf(stderr, "Mesa: %s", s);
1016 #endif
1017 }
1018
1019 /*@}*/
1020
1021
1022 /**********************************************************************/
1023 /** \name Default Imports Wrapper */
1024 /*@{*/
1025
1026 /** Wrapper around _mesa_malloc() */
1027 static void *
1028 default_malloc(__GLcontext *gc, size_t size)
1029 {
1030    (void) gc;
1031    return _mesa_malloc(size);
1032 }
1033
1034 /** Wrapper around _mesa_malloc() */
1035 static void *
1036 default_calloc(__GLcontext *gc, size_t numElem, size_t elemSize)
1037 {
1038    (void) gc;
1039    return _mesa_calloc(numElem * elemSize);
1040 }
1041
1042 /** Wrapper around either realloc() or xf86realloc() */
1043 static void *
1044 default_realloc(__GLcontext *gc, void *oldAddr, size_t newSize)
1045 {
1046    (void) gc;
1047 #if defined(XFree86LOADER) && defined(IN_MODULE)
1048    return xf86realloc(oldAddr, newSize);
1049 #else
1050    return realloc(oldAddr, newSize);
1051 #endif
1052 }
1053
1054 /** Wrapper around _mesa_free() */
1055 static void
1056 default_free(__GLcontext *gc, void *addr)
1057 {
1058    (void) gc;
1059    _mesa_free(addr);
1060 }
1061
1062 /** Wrapper around _mesa_getenv() */
1063 static char * CAPI
1064 default_getenv( __GLcontext *gc, const char *var )
1065 {
1066    (void) gc;
1067    return _mesa_getenv(var);
1068 }
1069
1070 /** Wrapper around _mesa_warning() */
1071 static void
1072 default_warning(__GLcontext *gc, char *str)
1073 {
1074    _mesa_warning(gc, str);
1075 }
1076
1077 /** Wrapper around _mesa_problem() */
1078 static void
1079 default_fatal(__GLcontext *gc, char *str)
1080 {
1081    _mesa_problem(gc, str);
1082    abort();
1083 }
1084
1085 /** Wrapper around atoi() */
1086 static int CAPI
1087 default_atoi(__GLcontext *gc, const char *str)
1088 {
1089    (void) gc;
1090    return atoi(str);
1091 }
1092
1093 /** Wrapper around vsprintf() */
1094 static int CAPI
1095 default_sprintf(__GLcontext *gc, char *str, const char *fmt, ...)
1096 {
1097    int r;
1098    va_list args;
1099    (void) gc;
1100    va_start( args, fmt );
1101    r = vsprintf( str, fmt, args );
1102    va_end( args );
1103    return r;
1104 }
1105
1106 /** Wrapper around fopen() */
1107 static void * CAPI
1108 default_fopen(__GLcontext *gc, const char *path, const char *mode)
1109 {
1110    (void) gc;
1111    return fopen(path, mode);
1112 }
1113
1114 /** Wrapper around fclose() */
1115 static int CAPI
1116 default_fclose(__GLcontext *gc, void *stream)
1117 {
1118    (void) gc;
1119    return fclose((FILE *) stream);
1120 }
1121
1122 /** Wrapper around vfprintf() */
1123 static int CAPI
1124 default_fprintf(__GLcontext *gc, void *stream, const char *fmt, ...)
1125 {
1126    int r;
1127    va_list args;
1128    (void) gc;
1129    va_start( args, fmt );
1130    r = vfprintf( (FILE *) stream, fmt, args );
1131    va_end( args );
1132    return r;
1133 }
1134
1135 /**
1136  * \todo this really is driver-specific and can't be here
1137  */
1138 static __GLdrawablePrivate *
1139 default_GetDrawablePrivate(__GLcontext *gc)
1140 {
1141    (void) gc;
1142    return NULL;
1143 }
1144
1145 /*@}*/
1146
1147
1148 /**
1149  * Initialize a __GLimports object to point to the functions in this
1150  * file.
1151  *
1152  * This is to be called from device drivers.
1153  *
1154  * Also, do some one-time initializations.
1155  *
1156  * \param imports the object to initialize.
1157  * \param driverCtx pointer to device driver-specific data.
1158  */
1159 void
1160 _mesa_init_default_imports(__GLimports *imports, void *driverCtx)
1161 {
1162    /* XXX maybe move this one-time init stuff into context.c */
1163    static GLboolean initialized = GL_FALSE;
1164    if (!initialized) {
1165       init_sqrt_table();
1166
1167 #if defined(_FPU_GETCW) && defined(_FPU_SETCW)
1168       {
1169          const char *debug = _mesa_getenv("MESA_DEBUG");
1170          if (debug && _mesa_strcmp(debug, "FP")==0) {
1171             /* die on FP exceptions */
1172             fpu_control_t mask;
1173             _FPU_GETCW(mask);
1174             mask &= ~(_FPU_MASK_IM | _FPU_MASK_DM | _FPU_MASK_ZM
1175                       | _FPU_MASK_OM | _FPU_MASK_UM);
1176             _FPU_SETCW(mask);
1177          }
1178       }
1179 #endif
1180       initialized = GL_TRUE;
1181    }
1182
1183    imports->malloc = default_malloc;
1184    imports->calloc = default_calloc;
1185    imports->realloc = default_realloc;
1186    imports->free = default_free;
1187    imports->warning = default_warning;
1188    imports->fatal = default_fatal;
1189    imports->getenv = default_getenv; /* not used for now */
1190    imports->atoi = default_atoi;
1191    imports->sprintf = default_sprintf;
1192    imports->fopen = default_fopen;
1193    imports->fclose = default_fclose;
1194    imports->fprintf = default_fprintf;
1195    imports->getDrawablePrivate = default_GetDrawablePrivate;
1196    imports->other = driverCtx;
1197 }