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 "mtypes.h"
  50 #include "version.h"
  51
  52 #ifdef _GNU_SOURCE
  53 #include <locale.h>
  54 #ifdef __APPLE__
  55 #include <xlocale.h>
  56 #endif
  57 #endif
  58
  59
  60 #ifdef WIN32
  61 #define vsnprintf _vsnprintf
  62 #elif defined(__IBMC__) || defined(__IBMCPP__) || ( defined(__VMS) && __CRTL_VER < 70312000 )
  63 extern int vsnprintf(char *str, size_t count, const char *fmt, va_list arg);
  64 #ifdef __VMS
  65 #include "vsnprintf.c"
  66 #endif
  67 #endif
  68
  69 /**********************************************************************/
  70 /** \name Memory */
  71 /*@{*/
  72
  73 /**
  74  * Allocate aligned memory.
  75  *
  76  * \param bytes number of bytes to allocate.
  77  * \param alignment alignment (must be greater than zero).
  78  *
  79  * Allocates extra memory to accommodate rounding up the address for
  80  * alignment and to record the real malloc address.
  81  *
  82  * \sa _mesa_align_free().
  83  */
  84 void *
  85 _mesa_align_malloc(size_t bytes, unsigned long alignment)
  86 {
  87 #if defined(HAVE_POSIX_MEMALIGN)
  88    void *mem;
  89    int err = posix_memalign(& mem, alignment, bytes);
  90    if (err)
  91       return NULL;
  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 sqrt() */
 247 double
 248 _mesa_sqrtd(double x)
 249 {
 250    return sqrt(x);
 251 }
 252
 253
 254 /*
 255  * A High Speed, Low Precision Square Root
 256  * by Paul Lalonde and Robert Dawson
 257  * from "Graphics Gems", Academic Press, 1990
 258  *
 259  * SPARC implementation of a fast square root by table
 260  * lookup.
 261  * SPARC floating point format is as follows:
 262  *
 263  * BIT 31       30      23      22      0
 264  *     sign     exponent        mantissa
 265  */
 266 static short sqrttab[0x100];    /* declare table of square roots */
 267
 268 void
 269 _mesa_init_sqrt_table(void)
 270 {
 271 #if defined(USE_IEEE) && !defined(DEBUG)
 272    unsigned short i;
 273    fi_type fi;     /* to access the bits of a float in  C quickly  */
 274                    /* we use a union defined in glheader.h         */
 275
 276    for(i=0; i<= 0x7f; i++) {
 277       fi.i = 0;
 278
 279       /*
 280        * Build a float with the bit pattern i as mantissa
 281        * and an exponent of 0, stored as 127
 282        */
 283
 284       fi.i = (i << 16) | (127 << 23);
 285       fi.f = _mesa_sqrtd(fi.f);
 286
 287       /*
 288        * Take the square root then strip the first 7 bits of
 289        * the mantissa into the table
 290        */
 291
 292       sqrttab[i] = (fi.i & 0x7fffff) >> 16;
 293
 294       /*
 295        * Repeat the process, this time with an exponent of
 296        * 1, stored as 128
 297        */
 298
 299       fi.i = 0;
 300       fi.i = (i << 16) | (128 << 23);
 301       fi.f = sqrt(fi.f);
 302       sqrttab[i+0x80] = (fi.i & 0x7fffff) >> 16;
 303    }
 304 #else
 305    (void) sqrttab;  /* silence compiler warnings */
 306 #endif /*HAVE_FAST_MATH*/
 307 }
 308
 309
 310 /**
 311  * Single precision square root.
 312  */
 313 float
 314 _mesa_sqrtf( float x )
 315 {
 316 #if defined(USE_IEEE) && !defined(DEBUG)
 317    fi_type num;
 318                                 /* to access the bits of a float in C
 319                                  * we use a union from glheader.h     */
 320
 321    short e;                     /* the exponent */
 322    if (x == 0.0F) return 0.0F;  /* check for square root of 0 */
 323    num.f = x;
 324    e = (num.i >> 23) - 127;     /* get the exponent - on a SPARC the */
 325                                 /* exponent is stored with 127 added */
 326    num.i &= 0x7fffff;           /* leave only the mantissa */
 327    if (e & 0x01) num.i |= 0x800000;
 328                                 /* the exponent is odd so we have to */
 329                                 /* look it up in the second half of  */
 330                                 /* the lookup table, so we set the   */
 331                                 /* high bit                                */
 332    e >>= 1;                     /* divide the exponent by two */
 333                                 /* note that in C the shift */
 334                                 /* operators are sign preserving */
 335                                 /* for signed operands */
 336    /* Do the table lookup, based on the quaternary mantissa,
 337     * then reconstruct the result back into a float
 338     */
 339    num.i = ((sqrttab[num.i >> 16]) << 16) | ((e + 127) << 23);
 340
 341    return num.f;
 342 #else
 343    return (float) _mesa_sqrtd((double) x);
 344 #endif
 345 }
 346
 347
 348 /**
 349  inv_sqrt - A single precision 1/sqrt routine for IEEE format floats.
 350  written by Josh Vanderhoof, based on newsgroup posts by James Van Buskirk
 351  and Vesa Karvonen.
 352 */
 353 float
 354 _mesa_inv_sqrtf(float n)
 355 {
 356 #if defined(USE_IEEE) && !defined(DEBUG)
 357         float r0, x0, y0;
 358         float r1, x1, y1;
 359         float r2, x2, y2;
 360 #if 0 /* not used, see below -BP */
 361         float r3, x3, y3;
 362 #endif
 363         fi_type u;
 364         unsigned int magic;
 365
 366         /*
 367          Exponent part of the magic number -
 368
 369          We want to:
 370          1. subtract the bias from the exponent,
 371          2. negate it
 372          3. divide by two (rounding towards -inf)
 373          4. add the bias back
 374
 375          Which is the same as subtracting the exponent from 381 and dividing
 376          by 2.
 377
 378          floor(-(x - 127) / 2) + 127 = floor((381 - x) / 2)
 379         */
 380
 381         magic = 381 << 23;
 382
 383         /*
 384          Significand part of magic number -
 385
 386          With the current magic number, "(magic - u.i) >> 1" will give you:
 387
 388          for 1 <= u.f <= 2: 1.25 - u.f / 4
 389          for 2 <= u.f <= 4: 1.00 - u.f / 8
 390
 391          This isn't a bad approximation of 1/sqrt.  The maximum difference from
 392          1/sqrt will be around .06.  After three Newton-Raphson iterations, the
 393          maximum difference is less than 4.5e-8.  (Which is actually close
 394          enough to make the following bias academic...)
 395
 396          To get a better approximation you can add a bias to the magic
 397          number.  For example, if you subtract 1/2 of the maximum difference in
 398          the first approximation (.03), you will get the following function:
 399
 400          for 1 <= u.f <= 2:    1.22 - u.f / 4
 401          for 2 <= u.f <= 3.76: 0.97 - u.f / 8
 402          for 3.76 <= u.f <= 4: 0.72 - u.f / 16
 403          (The 3.76 to 4 range is where the result is < .5.)
 404
 405          This is the closest possible initial approximation, but with a maximum
 406          error of 8e-11 after three NR iterations, it is still not perfect.  If
 407          you subtract 0.0332281 instead of .03, the maximum error will be
 408          2.5e-11 after three NR iterations, which should be about as close as
 409          is possible.
 410
 411          for 1 <= u.f <= 2:    1.2167719 - u.f / 4
 412          for 2 <= u.f <= 3.73: 0.9667719 - u.f / 8
 413          for 3.73 <= u.f <= 4: 0.7167719 - u.f / 16
 414
 415         */
 416
 417         magic -= (int)(0.0332281 * (1 << 25));
 418
 419         u.f = n;
 420         u.i = (magic - u.i) >> 1;
 421
 422         /*
 423          Instead of Newton-Raphson, we use Goldschmidt's algorithm, which
 424          allows more parallelism.  From what I understand, the parallelism
 425          comes at the cost of less precision, because it lets error
 426          accumulate across iterations.
 427         */
 428         x0 = 1.0f;
 429         y0 = 0.5f * n;
 430         r0 = u.f;
 431
 432         x1 = x0 * r0;
 433         y1 = y0 * r0 * r0;
 434         r1 = 1.5f - y1;
 435
 436         x2 = x1 * r1;
 437         y2 = y1 * r1 * r1;
 438         r2 = 1.5f - y2;
 439
 440 #if 1
 441         return x2 * r2;  /* we can stop here, and be conformant -BP */
 442 #else
 443         x3 = x2 * r2;
 444         y3 = y2 * r2 * r2;
 445         r3 = 1.5f - y3;
 446
 447         return x3 * r3;
 448 #endif
 449 #else
 450         return (float) (1.0 / sqrt(n));
 451 #endif
 452 }
 453
 454 #ifndef __GNUC__
 455 /**
 456  * Find the first bit set in a word.
 457  */
 458 int
 459 ffs(int i)
 460 {
 461    register int bit = 0;
 462    if (i != 0) {
 463       if ((i & 0xffff) == 0) {
 464          bit += 16;
 465          i >>= 16;
 466       }
 467       if ((i & 0xff) == 0) {
 468          bit += 8;
 469          i >>= 8;
 470       }
 471       if ((i & 0xf) == 0) {
 472          bit += 4;
 473          i >>= 4;
 474       }
 475       while ((i & 1) == 0) {
 476          bit++;
 477          i >>= 1;
 478       }
 479       bit++;
 480    }
 481    return bit;
 482 }
 483
 484
 485 /**
 486  * Find position of first bit set in given value.
 487  * XXX Warning: this function can only be used on 64-bit systems!
 488  * \return  position of least-significant bit set, starting at 1, return zero
 489  *          if no bits set.
 490  */
 491 int
 492 ffsll(long long int val)
 493 {
 494    int bit;
 495
 496    assert(sizeof(val) == 8);
 497
 498    bit = ffs((int) val);
 499    if (bit != 0)
 500       return bit;
 501
 502    bit = ffs((int) (val >> 32));
 503    if (bit != 0)
 504       return 32 + bit;
 505
 506    return 0;
 507 }
 508 #endif /* __GNUC__ */
 509
 510
 511 #if !defined(__GNUC__) ||\
 512    ((__GNUC__ * 100 + __GNUC_MINOR__) < 304) /* Not gcc 3.4 or later */
 513 /**
 514  * Return number of bits set in given GLuint.
 515  */
 516 unsigned int
 517 _mesa_bitcount(unsigned int n)
 518 {
 519    unsigned int bits;
 520    for (bits = 0; n > 0; n = n >> 1) {
 521       bits += (n & 1);
 522    }
 523    return bits;
 524 }
 525
 526 /**
 527  * Return number of bits set in given 64-bit uint.
 528  */
 529 unsigned int
 530 _mesa_bitcount_64(uint64_t n)
 531 {
 532    unsigned int bits;
 533    for (bits = 0; n > 0; n = n >> 1) {
 534       bits += (n & 1);
 535    }
 536    return bits;
 537 }
 538 #endif
 539
 540
 541 /**
 542  * Convert a 4-byte float to a 2-byte half float.
 543  * Based on code from:
 544  * http://www.opengl.org/discussion_boards/ubb/Forum3/HTML/008786.html
 545  */
 546 GLhalfARB
 547 _mesa_float_to_half(float val)
 548 {
 549    const fi_type fi = {val};
 550    const int flt_m = fi.i & 0x7fffff;
 551    const int flt_e = (fi.i >> 23) & 0xff;
 552    const int flt_s = (fi.i >> 31) & 0x1;
 553    int s, e, m = 0;
 554    GLhalfARB result;
 555
 556    /* sign bit */
 557    s = flt_s;
 558
 559    /* handle special cases */
 560    if ((flt_e == 0) && (flt_m == 0)) {
 561       /* zero */
 562       /* m = 0; - already set */
 563       e = 0;
 564    }
 565    else if ((flt_e == 0) && (flt_m != 0)) {
 566       /* denorm -- denorm float maps to 0 half */
 567       /* m = 0; - already set */
 568       e = 0;
 569    }
 570    else if ((flt_e == 0xff) && (flt_m == 0)) {
 571       /* infinity */
 572       /* m = 0; - already set */
 573       e = 31;
 574    }
 575    else if ((flt_e == 0xff) && (flt_m != 0)) {
 576       /* NaN */
 577       m = 1;
 578       e = 31;
 579    }
 580    else {
 581       /* regular number */
 582       const int new_exp = flt_e - 127;
 583       if (new_exp < -24) {
 584          /* this maps to 0 */
 585          /* m = 0; - already set */
 586          e = 0;
 587       }
 588       else if (new_exp < -14) {
 589          /* this maps to a denorm */
 590          unsigned int exp_val = (unsigned int) (-14 - new_exp); /* 2^-exp_val*/
 591          e = 0;
 592          switch (exp_val) {
 593             case 0:
 594                _mesa_warning(NULL,
 595                    "float_to_half: logical error in denorm creation!\n");
 596                /* m = 0; - already set */
 597                break;
 598             case 1: m = 512 + (flt_m >> 14); break;
 599             case 2: m = 256 + (flt_m >> 15); break;
 600             case 3: m = 128 + (flt_m >> 16); break;
 601             case 4: m = 64 + (flt_m >> 17); break;
 602             case 5: m = 32 + (flt_m >> 18); break;
 603             case 6: m = 16 + (flt_m >> 19); break;
 604             case 7: m = 8 + (flt_m >> 20); break;
 605             case 8: m = 4 + (flt_m >> 21); break;
 606             case 9: m = 2 + (flt_m >> 22); break;
 607             case 10: m = 1; break;
 608          }
 609       }
 610       else if (new_exp > 15) {
 611          /* map this value to infinity */
 612          /* m = 0; - already set */
 613          e = 31;
 614       }
 615       else {
 616          /* regular */
 617          e = new_exp + 15;
 618          m = flt_m >> 13;
 619       }
 620    }
 621
 622    result = (s << 15) | (e << 10) | m;
 623    return result;
 624 }
 625
 626
 627 /**
 628  * Convert a 2-byte half float to a 4-byte float.
 629  * Based on code from:
 630  * http://www.opengl.org/discussion_boards/ubb/Forum3/HTML/008786.html
 631  */
 632 float
 633 _mesa_half_to_float(GLhalfARB val)
 634 {
 635    /* XXX could also use a 64K-entry lookup table */
 636    const int m = val & 0x3ff;
 637    const int e = (val >> 10) & 0x1f;
 638    const int s = (val >> 15) & 0x1;
 639    int flt_m, flt_e, flt_s;
 640    fi_type fi;
 641    float result;
 642
 643    /* sign bit */
 644    flt_s = s;
 645
 646    /* handle special cases */
 647    if ((e == 0) && (m == 0)) {
 648       /* zero */
 649       flt_m = 0;
 650       flt_e = 0;
 651    }
 652    else if ((e == 0) && (m != 0)) {
 653       /* denorm -- denorm half will fit in non-denorm single */
 654       const float half_denorm = 1.0f / 16384.0f; /* 2^-14 */
 655       float mantissa = ((float) (m)) / 1024.0f;
 656       float sign = s ? -1.0f : 1.0f;
 657       return sign * mantissa * half_denorm;
 658    }
 659    else if ((e == 31) && (m == 0)) {
 660       /* infinity */
 661       flt_e = 0xff;
 662       flt_m = 0;
 663    }
 664    else if ((e == 31) && (m != 0)) {
 665       /* NaN */
 666       flt_e = 0xff;
 667       flt_m = 1;
 668    }
 669    else {
 670       /* regular */
 671       flt_e = e + 112;
 672       flt_m = m << 13;
 673    }
 674
 675    fi.i = (flt_s << 31) | (flt_e << 23) | flt_m;
 676    result = fi.f;
 677    return result;
 678 }
 679
 680 /*@}*/
 681
 682
 683 /**********************************************************************/
 684 /** \name Sort & Search */
 685 /*@{*/
 686
 687 /**
 688  * Wrapper for bsearch().
 689  */
 690 void *
 691 _mesa_bsearch( const void *key, const void *base, size_t nmemb, size_t size,
 692                int (*compar)(const void *, const void *) )
 693 {
 694 #if defined(_WIN32_WCE)
 695    void *mid;
 696    int cmp;
 697    while (nmemb) {
 698       nmemb >>= 1;
 699       mid = (char *)base + nmemb * size;
 700       cmp = (*compar)(key, mid);
 701       if (cmp == 0)
 702          return mid;
 703       if (cmp > 0) {
 704          base = (char *)mid + size;
 705          --nmemb;
 706       }
 707    }
 708    return NULL;
 709 #else
 710    return bsearch(key, base, nmemb, size, compar);
 711 #endif
 712 }
 713
 714 /*@}*/
 715
 716
 717 /**********************************************************************/
 718 /** \name Environment vars */
 719 /*@{*/
 720
 721 /**
 722  * Wrapper for getenv().
 723  */
 724 char *
 725 _mesa_getenv( const char *var )
 726 {
 727 #if defined(_XBOX) || defined(_WIN32_WCE)
 728    return NULL;
 729 #else
 730    return getenv(var);
 731 #endif
 732 }
 733
 734 /*@}*/
 735
 736
 737 /**********************************************************************/
 738 /** \name String */
 739 /*@{*/
 740
 741 /**
 742  * Implemented using malloc() and strcpy.
 743  * Note that NULL is handled accordingly.
 744  */
 745 char *
 746 _mesa_strdup( const char *s )
 747 {
 748    if (s) {
 749       size_t l = strlen(s);
 750       char *s2 = (char *) malloc(l + 1);
 751       if (s2)
 752          strcpy(s2, s);
 753       return s2;
 754    }
 755    else {
 756       return NULL;
 757    }
 758 }
 759
 760 /** Wrapper around strtof() */
 761 float
 762 _mesa_strtof( const char *s, char **end )
 763 {
 764 #if defined(_GNU_SOURCE) && !defined(__CYGWIN__) && !defined(__FreeBSD__) && \
 765    !defined(ANDROID) && !defined(__HAIKU__)
 766    static locale_t loc = NULL;
 767    if (!loc) {
 768       loc = newlocale(LC_CTYPE_MASK, "C", NULL);
 769    }
 770    return strtof_l(s, end, loc);
 771 #elif defined(_ISOC99_SOURCE) || (defined(_XOPEN_SOURCE) && _XOPEN_SOURCE >= 600)
 772    return strtof(s, end);
 773 #else
 774    return (float)strtod(s, end);
 775 #endif
 776 }
 777
 778 /** Compute simple checksum/hash for a string */
 779 unsigned int
 780 _mesa_str_checksum(const char *str)
 781 {
 782    /* This could probably be much better */
 783    unsigned int sum, i;
 784    const char *c;
 785    sum = i = 1;
 786    for (c = str; *c; c++, i++)
 787       sum += *c * (i % 100);
 788    return sum + i;
 789 }
 790
 791
 792 /*@}*/
 793
 794
 795 /** Needed due to #ifdef's, above. */
 796 int
 797 _mesa_vsnprintf(char *str, size_t size, const char *fmt, va_list args)
 798 {
 799    return vsnprintf( str, size, fmt, args);
 800 }
 801
 802 /** Wrapper around vsnprintf() */
 803 int
 804 _mesa_snprintf( char *str, size_t size, const char *fmt, ... )
 805 {
 806    int r;
 807    va_list args;
 808    va_start( args, fmt );
 809    r = vsnprintf( str, size, fmt, args );
 810    va_end( args );
 811    return r;
 812 }
 813
 814