/** * Find the first bit set in a word. */int_mesa_ffs(int i){#if (defined(_WIN32) ) || defined(__IBMC__) || defined(__IBMCPP__)   register int bit = 0;   if (i != 0) {      if ((i & 0xffff) == 0) {         bit += 16;         i >>= 16;      }      if ((i & 0xff) == 0) {         bit += 8;         i >>= 8;      }      if ((i & 0xf) == 0) {         bit += 4;         i >>= 4;      }      while ((i & 1) == 0) {         bit++;         i >>= 1;      }      bit++;   }   return bit;#else   return ffs(i);#endif}/** * Find position of first bit set in given value. * XXX Warning: this function can only be used on 64-bit systems! * \return  position of least-significant bit set, starting at 1, return zero *          if no bits set. */int#ifdef __MINGW32___mesa_ffsll(long val)#else_mesa_ffsll(long long val)#endif{#ifdef ffsll   return ffsll(val);#else   int bit;   assert(sizeof(val) == 8);   bit = _mesa_ffs(val);   if (bit != 0)      return bit;   bit = _mesa_ffs(val >> 32);   if (bit != 0)      return 32 + bit;   return 0;#endif}/** * Return number of bits set in given GLuint. */unsigned int_mesa_bitcount(unsigned int n){   unsigned int bits;   for (bits = 0; n > 0; n = n >> 1) {      bits += (n & 1);   }   return bits;}/** * Convert a 4-byte float to a 2-byte half float. * Based on code from: * http://www.opengl.org/discussion_boards/ubb/Forum3/HTML/008786.html */GLhalfARB_mesa_float_to_half(float val){   const int flt = *((int *) (void *) &val);   const int flt_m = flt & 0x7fffff;   const int flt_e = (flt >> 23) & 0xff;   const int flt_s = (flt >> 31) & 0x1;   int s, e, m = 0;   GLhalfARB result;      /* sign bit */   s = flt_s;   /* handle special cases */   if ((flt_e == 0) && (flt_m == 0)) {      /* zero */      /* m = 0; - already set */      e = 0;   }   else if ((flt_e == 0) && (flt_m != 0)) {      /* denorm -- denorm float maps to 0 half */      /* m = 0; - already set */      e = 0;   }   else if ((flt_e == 0xff) && (flt_m == 0)) {      /* infinity */      /* m = 0; - already set */      e = 31;   }   else if ((flt_e == 0xff) && (flt_m != 0)) {      /* NaN */      m = 1;      e = 31;   }   else {      /* regular number */      const int new_exp = flt_e - 127;      if (new_exp < -24) {         /* this maps to 0 */         /* m = 0; - already set */         e = 0;      }      else if (new_exp < -14) {         /* this maps to a denorm */         unsigned int exp_val = (unsigned int) (-14 - new_exp); /* 2^-exp_val*/         e = 0;         switch (exp_val) {            case 0:               _mesa_warning(NULL,                   "float_to_half: logical error in denorm creation!\n");               /* m = 0; - already set */               break;            case 1: m = 512 + (flt_m >> 14); break;            case 2: m = 256 + (flt_m >> 15); break;            case 3: m = 128 + (flt_m >> 16); break;            case 4: m = 64 + (flt_m >> 17); break;            case 5: m = 32 + (flt_m >> 18); break;            case 6: m = 16 + (flt_m >> 19); break;            case 7: m = 8 + (flt_m >> 20); break;            case 8: m = 4 + (flt_m >> 21); break;            case 9: m = 2 + (flt_m >> 22); break;            case 10: m = 1; break;         }      }      else if (new_exp > 15) {         /* map this value to infinity */         /* m = 0; - already set */         e = 31;      }      else {         /* regular */         e = new_exp + 15;         m = flt_m >> 13;      }   }   result = (s << 15) | (e << 10) | m;   return result;}/** * Convert a 2-byte half float to a 4-byte float. * Based on code from: * http://www.opengl.org/discussion_boards/ubb/Forum3/HTML/008786.html */float_mesa_half_to_float(GLhalfARB val){   /* XXX could also use a 64K-entry lookup table */   const int m = val & 0x3ff;   const int e = (val >> 10) & 0x1f;   const int s = (val >> 15) & 0x1;   int flt_m, flt_e, flt_s, flt;   float result;   /* sign bit */   flt_s = s;   /* handle special cases */   if ((e == 0) && (m == 0)) {      /* zero */      flt_m = 0;      flt_e = 0;   }   else if ((e == 0) && (m != 0)) {      /* denorm -- denorm half will fit in non-denorm single */      const float half_denorm = 1.0f / 16384.0f; /* 2^-14 */      float mantissa = ((float) (m)) / 1024.0f;      float sign = s ? -1.0f : 1.0f;      return sign * mantissa * half_denorm;   }   else if ((e == 31) && (m == 0)) {      /* infinity */      flt_e = 0xff;      flt_m = 0;   }   else if ((e == 31) && (m != 0)) {      /* NaN */      flt_e = 0xff;      flt_m = 1;   }   else {      /* regular */      flt_e = e + 112;      flt_m = m << 13;   }   flt = (flt_s << 31) | (flt_e << 23) | flt_m;   result = *((float *) (void *) &flt);   return result;}/*@}*//**********************************************************************//** \name Sort & Search *//*@{*//** * Wrapper for bsearch(). */void *_mesa_bsearch( const void *key, const void *base, size_t nmemb, size_t size,                int (*compar)(const void *, const void *) ){   return bsearch(key, base, nmemb, size, compar);}/*@}*//**********************************************************************//** \name Environment vars *//*@{*//** * Wrapper for getenv(). */char *_mesa_getenv( const char *var ){#if defined(_XBOX)   return NULL;#else   return getenv(var);#endif}/*@}*//**********************************************************************//** \name String *//*@{*//** Wrapper around strstr() */char *_mesa_strstr( const char *haystack, const char *needle ){   return strstr(haystack, needle);}/** Wrapper around strncat() */char *_mesa_strncat( char *dest, const char *src, size_t n ){   return strncat(dest, src, n);}/** Wrapper around strcpy() */char *_mesa_strcpy( char *dest, const char *src ){   return strcpy(dest, src);}/** Wrapper around strncpy() */char *_mesa_strncpy( char *dest, const char *src, size_t n ){   return strncpy(dest, src, n);}/** Wrapper around strlen() */size_t_mesa_strlen( const char *s ){   return strlen(s);}/** Wrapper around strcmp() */int_mesa_strcmp( const char *s1, const char *s2 ){   return strcmp(s1, s2);}/** Wrapper around strncmp() */int_mesa_strncmp( const char *s1, const char *s2, size_t n ){   return strncmp(s1, s2, n);}/** * Implemented using _mesa_malloc() and _mesa_strcpy. * Note that NULL is handled accordingly. */char *_mesa_strdup( const char *s ){   if (s) {      size_t l = _mesa_strlen(s);      char *s2 = (char *) _mesa_malloc(l + 1);      if (s2)         _mesa_strcpy(s2, s);      return s2;   }   else {      return NULL;   }}/** Wrapper around atoi() */int_mesa_atoi(const char *s){   return atoi(s);}/** Wrapper around strtod() */double_mesa_strtod( const char *s, char **end ){   return strtod(s, end);}/*@}*//**********************************************************************//** \name I/O *//*@{*//** Wrapper around vsprintf() */int_mesa_sprintf( char *str, const char *fmt, ... ){   int r;   va_list args;   va_start( args, fmt );     r = vsprintf( str, fmt, args );   va_end( args );   return r;}/** Wrapper around printf(), using vsprintf() for the formatting. */void_mesa_printf( const char *fmtString, ... ){   char s[MAXSTRING];   va_list args;   va_start( args, fmtString );     vsnprintf(s, MAXSTRING, fmtString, args);   va_end( args );   fprintf(stderr,"%s", s);}/** Wrapper around vsprintf() */int_mesa_vsprintf( char *str, const char *fmt, va_list args ){   return vsprintf( str, fmt, args );}/*@}*//**********************************************************************//** \name Diagnostics *//*@{*//** * Report a warning (a recoverable error condition) to stderr if * either DEBUG is defined or the MESA_DEBUG env var is set. * * \param ctx GL context. * \param fmtString printf() alike format string. */void_mesa_warning( GLcontext *ctx, const char *fmtString, ... ){   GLboolean debug;   char str[MAXSTRING];   va_list args;   (void) ctx;   va_start( args, fmtString );     (void) vsnprintf( str, MAXSTRING, fmtString, args );   va_end( args );#ifdef DEBUG   debug = GL_TRUE; /* always print warning */#else   debug = _mesa_getenv("MESA_DEBUG") ? GL_TRUE : GL_FALSE;#endif   if (debug) {      fprintf(stderr, "Mesa warning: %s\n", str);   }}/** * Report an internla implementation problem. * Prints the message to stderr via fprintf(). * * \param ctx GL context. * \param s problem description string. */void_mesa_problem( const GLcontext *ctx, const char *fmtString, ... ){   va_list args;   char str[MAXSTRING];   (void) ctx;   va_start( args, fmtString );     vsnprintf( str, MAXSTRING, fmtString, args );   va_end( args );   fprintf(stderr, "Mesa %s implementation error: %s\n", MESA_VERSION_STRING, str);   fprintf(stderr, "Please report at bugzilla.freedesktop.org\n");}/** * Record an OpenGL state error.  These usually occur when the users * passes invalid parameters to a GL function. * * If debugging is enabled (either at compile-time via the DEBUG macro, or * run-time via the MESA_DEBUG environment variable), report the error with * _mesa_debug(). *  * \param ctx the GL context. * \param error the error value. * \param fmtString printf() style format string, followed by optional args */void_mesa_error( GLcontext *ctx, GLenum error, const char *fmtString, ... ){   const char *debugEnv;   GLboolean debug;   debugEnv = _mesa_getenv("MESA_DEBUG");#ifdef DEBUG   if (debugEnv && _mesa_strstr(debugEnv, "silent"))      debug = GL_FALSE;   else      debug = GL_TRUE;#else   if (debugEnv)      debug = GL_TRUE;   else      debug = GL_FALSE;#endif   if (debug) {      va_list args;      char where[MAXSTRING];      const char *errstr;      va_start( args, fmtString );        vsnprintf( where, MAXSTRING, fmtString, args );      va_end( args );      switch (error) {	 case GL_NO_ERROR:	    errstr = "GL_NO_ERROR";	    break;	 case GL_INVALID_VALUE:	    errstr = "GL_INVALID_VALUE";	    break;	 case GL_INVALID_ENUM:	    errstr = "GL_INVALID_ENUM";	    break;	 case GL_INVALID_OPERATION:	    errstr = "GL_INVALID_OPERATION";	    break;	 case GL_STACK_OVERFLOW:	    errstr = "GL_STACK_OVERFLOW";	    break;	 case GL_STACK_UNDERFLOW:	    errstr = "GL_STACK_UNDERFLOW";	    break;	 case GL_OUT_OF_MEMORY:	    errstr = "GL_OUT_OF_MEMORY";	    break;         case GL_TABLE_TOO_LARGE:            errstr = "GL_TABLE_TOO_LARGE";            break;         case GL_INVALID_FRAMEBUFFER_OPERATION_EXT:            errstr = "GL_INVALID_FRAMEBUFFER_OPERATION";            break;	 default:	    errstr = "unknown";	    break;      }      _mesa_debug(ctx, "User error: %s in %s\n", errstr, where);   }   _mesa_record_error(ctx, error);}  /** * Report debug information.  Print error message to stderr via fprintf(). * No-op if DEBUG mode not enabled. *  * \param ctx GL context. * \param fmtString printf()-style format string, followed by optional args. */void_mesa_debug( const GLcontext *ctx, const char *fmtString, ... ){#ifdef DEBUG   char s[MAXSTRING];   va_list args;   va_start(args, fmtString);   vsnprintf(s, MAXSTRING, fmtString, args);   va_end(args);   fprintf(stderr, "Mesa: %s", s);#endif /* DEBUG */   (void) ctx;   (void) fmtString;}/*@}*//** * Wrapper for exit(). */void_mesa_exit( int status ){   exit(status);}