pixman git update 18 July 2011

5 files changed, 2567 insertions, 2577 deletions

diff --git a/mesalib/src/mesa/drivers/dri/common/xmlconfig.c b/mesalib/src/mesa/drivers/dri/common/xmlconfig.c
index 30075f253..77967ac2a 100644
--- a/mesalib/src/mesa/drivers/dri/common/xmlconfig.c
+++ b/mesalib/src/mesa/drivers/dri/common/xmlconfig.c
@@ -1,1022 +1,1022 @@
-/*

- * XML DRI client-side driver configuration

- * Copyright (C) 2003 Felix Kuehling

- *

- * Permission is hereby granted, free of charge, to any person obtaining a

- * copy of this software and associated documentation files (the "Software"),

- * to deal in the Software without restriction, including without limitation

- * the rights to use, copy, modify, merge, publish, distribute, sublicense,

- * and/or sell copies of the Software, and to permit persons to whom the

- * Software is furnished to do so, subject to the following conditions:

- *

- * The above copyright notice and this permission notice shall be included

- * in all copies or substantial portions of the Software.

- *

- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL

- * FELIX KUEHLING, OR ANY OTHER CONTRIBUTORS BE LIABLE FOR ANY CLAIM, 

- * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR 

- * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE 

- * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

- * 

- */

-/**

- * \file xmlconfig.c

- * \brief Driver-independent client-side part of the XML configuration

- * \author Felix Kuehling

- */

-

-#include "main/glheader.h"

-

-#include <string.h>

-#include <assert.h>

-#include <expat.h>

-#include <fcntl.h>

-#include <unistd.h>

-#include <errno.h>

-#include "main/imports.h"

-#include "utils.h"

-#include "xmlconfig.h"

-

-#undef GET_PROGRAM_NAME

-

-#if (defined(__GNU_LIBRARY__) || defined(__GLIBC__)) && !defined(__UCLIBC__)

-#    if !defined(__GLIBC__) || (__GLIBC__ < 2)

-/* These aren't declared in any libc5 header */

-extern char *program_invocation_name, *program_invocation_short_name;

-#    endif

-#    define GET_PROGRAM_NAME() program_invocation_short_name

-#elif defined(__FreeBSD__) && (__FreeBSD__ >= 2)

-#    include <osreldate.h>

-#    if (__FreeBSD_version >= 440000)

-#        include <stdlib.h>

-#        define GET_PROGRAM_NAME() getprogname()

-#    endif

-#elif defined(__NetBSD__) && defined(__NetBSD_Version) && (__NetBSD_Version >= 106000100)

-#    include <stdlib.h>

-#    define GET_PROGRAM_NAME() getprogname()

-#elif defined(__APPLE__)

-#    include <stdlib.h>

-#    define GET_PROGRAM_NAME() getprogname()

-#elif defined(__sun)

-/* Solaris has getexecname() which returns the full path - return just

-   the basename to match BSD getprogname() */

-#    include <stdlib.h>

-#    include <libgen.h>

-

-static const char *__getProgramName () {

-    static const char *progname;

-

-    if (progname == NULL) {

-	const char *e = getexecname();

-	if (e != NULL) {

-	    /* Have to make a copy since getexecname can return a readonly

-	       string, but basename expects to be able to modify its arg. */

-	    char *n = strdup(e);

-	    if (n != NULL) {

-		progname = basename(n);

-	    }

-	}

-    }

-    return progname;

-}

-

-#    define GET_PROGRAM_NAME() __getProgramName()

-#endif

-

-#if !defined(GET_PROGRAM_NAME)

-#    if defined(__OpenBSD__) || defined(NetBSD) || defined(__UCLIBC__)

-/* This is a hack. It's said to work on OpenBSD, NetBSD and GNU.

- * Rogelio M.Serrano Jr. reported it's also working with UCLIBC. It's

- * used as a last resort, if there is no documented facility available. */

-static const char *__getProgramName () {

-    extern const char *__progname;

-    char * arg = strrchr(__progname, '/');

-    if (arg)

-        return arg+1;

-    else

-        return __progname;

-}

-#        define GET_PROGRAM_NAME() __getProgramName()

-#    else

-#        define GET_PROGRAM_NAME() ""

-#        warning "Per application configuration won't work with your OS version."

-#    endif

-#endif

-

-/** \brief Find an option in an option cache with the name as key */

-static GLuint findOption (const driOptionCache *cache, const char *name) {

-    GLuint len = strlen (name);

-    GLuint size = 1 << cache->tableSize, mask = size - 1;

-    GLuint hash = 0;

-    GLuint i, shift;

-

-  /* compute a hash from the variable length name */

-    for (i = 0, shift = 0; i < len; ++i, shift = (shift+8) & 31)

-	hash += (GLuint)name[i] << shift;

-    hash *= hash;

-    hash = (hash >> (16-cache->tableSize/2)) & mask;

-

-  /* this is just the starting point of the linear search for the option */

-    for (i = 0; i < size; ++i, hash = (hash+1) & mask) {

-      /* if we hit an empty entry then the option is not defined (yet) */

-	if (cache->info[hash].name == 0)

-	    break;

-	else if (!strcmp (name, cache->info[hash].name))

-	    break;

-    }

-  /* this assertion fails if the hash table is full */

-    assert (i < size);

-

-    return hash;

-}

-

-/** \brief Count the real number of options in an option cache */

-static GLuint countOptions (const driOptionCache *cache) {

-    GLuint size = 1 << cache->tableSize;

-    GLuint i, count = 0;

-    for (i = 0; i < size; ++i)

-	if (cache->info[i].name)

-	    count++;

-    return count;

-}

-

-/** \brief Like strdup but using MALLOC and with error checking. */

-#define XSTRDUP(dest,source) do { \

-    GLuint len = strlen (source); \

-    if (!(dest = MALLOC (len+1))) { \

-	fprintf (stderr, "%s: %d: out of memory.\n", __FILE__, __LINE__); \

-	abort(); \

-    } \

-    memcpy (dest, source, len+1); \

-} while (0)

-

-static int compare (const void *a, const void *b) {

-    return strcmp (*(char *const*)a, *(char *const*)b);

-}

-/** \brief Binary search in a string array. */

-static GLuint bsearchStr (const XML_Char *name,

-			  const XML_Char *elems[], GLuint count) {

-    const XML_Char **found;

-    found = bsearch (&name, elems, count, sizeof (XML_Char *), compare);

-    if (found)

-	return found - elems;

-    else

-	return count;

-}

-

-/** \brief Locale-independent integer parser.

- *

- * Works similar to strtol. Leading space is NOT skipped. The input

- * number may have an optional sign. Radix is specified by base. If

- * base is 0 then decimal is assumed unless the input number is

- * prefixed by 0x or 0X for hexadecimal or 0 for octal. After

- * returning tail points to the first character that is not part of

- * the integer number. If no number was found then tail points to the

- * start of the input string. */

-static GLint strToI (const XML_Char *string, const XML_Char **tail, int base) {

-    GLint radix = base == 0 ? 10 : base;

-    GLint result = 0;

-    GLint sign = 1;

-    GLboolean numberFound = GL_FALSE;

-    const XML_Char *start = string;

-

-    assert (radix >= 2 && radix <= 36);

-

-    if (*string == '-') {

-	sign = -1;

-	string++;

-    } else if (*string == '+')

-	string++;

-    if (base == 0 && *string == '0') {

-	numberFound = GL_TRUE; 

-	if (*(string+1) == 'x' || *(string+1) == 'X') {

-	    radix = 16;

-	    string += 2;

-	} else {

-	    radix = 8;

-	    string++;

-	}

-    }

-    do {

-	GLint digit = -1;

-	if (radix <= 10) {

-	    if (*string >= '0' && *string < '0' + radix)

-		digit = *string - '0';

-	} else {

-	    if (*string >= '0' && *string <= '9')

-		digit = *string - '0';

-	    else if (*string >= 'a' && *string < 'a' + radix - 10)

-		digit = *string - 'a' + 10;

-	    else if (*string >= 'A' && *string < 'A' + radix - 10)

-		digit = *string - 'A' + 10;

-	}

-	if (digit != -1) {

-	    numberFound = GL_TRUE;

-	    result = radix*result + digit;

-	    string++;

-	} else

-	    break;

-    } while (GL_TRUE);

-    *tail = numberFound ? string : start;

-    return sign * result;

-}

-

-/** \brief Locale-independent floating-point parser.

- *

- * Works similar to strtod. Leading space is NOT skipped. The input

- * number may have an optional sign. '.' is interpreted as decimal

- * point and may occur at most once. Optionally the number may end in

- * [eE]<exponent>, where <exponent> is an integer as recognized by

- * strToI. In that case the result is number * 10^exponent. After

- * returning tail points to the first character that is not part of

- * the floating point number. If no number was found then tail points

- * to the start of the input string.

- *

- * Uses two passes for maximum accuracy. */

-static GLfloat strToF (const XML_Char *string, const XML_Char **tail) {

-    GLint nDigits = 0, pointPos, exponent;

-    GLfloat sign = 1.0f, result = 0.0f, scale;

-    const XML_Char *start = string, *numStart;

-

-    /* sign */

-    if (*string == '-') {

-	sign = -1.0f;

-	string++;

-    } else if (*string == '+')

-	string++;

-

-    /* first pass: determine position of decimal point, number of

-     * digits, exponent and the end of the number. */

-    numStart = string;

-    while (*string >= '0' && *string <= '9') {

-	string++;

-	nDigits++;

-    }

-    pointPos = nDigits;

-    if (*string == '.') {

-	string++;

-	while (*string >= '0' && *string <= '9') {

-	    string++;

-	    nDigits++;

-	}

-    }

-    if (nDigits == 0) {

-	/* no digits, no number */

-	*tail = start;

-	return 0.0f;

-    }

-    *tail = string;

-    if (*string == 'e' || *string == 'E') {

-	const XML_Char *expTail;

-	exponent = strToI (string+1, &expTail, 10);

-	if (expTail == string+1)

-	    exponent = 0;

-	else

-	    *tail = expTail;

-    } else

-	exponent = 0;

-    string = numStart;

-

-    /* scale of the first digit */

-    scale = sign * (GLfloat)pow (10.0, (GLdouble)(pointPos-1 + exponent));

-

-    /* second pass: parse digits */

-    do {

-	if (*string != '.') {

-	    assert (*string >= '0' && *string <= '9');

-	    result += scale * (GLfloat)(*string - '0');

-	    scale *= 0.1f;

-	    nDigits--;

-	}

-	string++;

-    } while (nDigits > 0);

-

-    return result;

-}

-

-/** \brief Parse a value of a given type. */

-static GLboolean parseValue (driOptionValue *v, driOptionType type,

-			     const XML_Char *string) {

-    const XML_Char *tail = NULL;

-  /* skip leading white-space */

-    string += strspn (string, " \f\n\r\t\v");

-    switch (type) {

-      case DRI_BOOL:

-	if (!strcmp (string, "false")) {

-	    v->_bool = GL_FALSE;

-	    tail = string + 5;

-	} else if (!strcmp (string, "true")) {

-	    v->_bool = GL_TRUE;

-	    tail = string + 4;

-	}

-	else

-	    return GL_FALSE;

-	break;

-      case DRI_ENUM: /* enum is just a special integer */

-      case DRI_INT:

-	v->_int = strToI (string, &tail, 0);

-	break;

-      case DRI_FLOAT:

-	v->_float = strToF (string, &tail);

-	break;

-    }

-

-    if (tail == string)

-	return GL_FALSE; /* empty string (or containing only white-space) */

-  /* skip trailing white space */

-    if (*tail)

-	tail += strspn (tail, " \f\n\r\t\v");

-    if (*tail)

-	return GL_FALSE; /* something left over that is not part of value */

-

-    return GL_TRUE;

-}

-

-/** \brief Parse a list of ranges of type info->type. */

-static GLboolean parseRanges (driOptionInfo *info, const XML_Char *string) {

-    XML_Char *cp, *range;

-    GLuint nRanges, i;

-    driOptionRange *ranges;

-

-    XSTRDUP (cp, string);

-  /* pass 1: determine the number of ranges (number of commas + 1) */

-    range = cp;

-    for (nRanges = 1; *range; ++range)

-	if (*range == ',')

-	    ++nRanges;

-

-    if ((ranges = MALLOC (nRanges*sizeof(driOptionRange))) == NULL) {

-	fprintf (stderr, "%s: %d: out of memory.\n", __FILE__, __LINE__);

-	abort();

-    }

-

-  /* pass 2: parse all ranges into preallocated array */

-    range = cp;

-    for (i = 0; i < nRanges; ++i) {

-	XML_Char *end, *sep;

-	assert (range);

-	end = strchr (range, ',');

-	if (end)

-	    *end = '\0';

-	sep = strchr (range, ':');

-	if (sep) { /* non-empty interval */

-	    *sep = '\0';

-	    if (!parseValue (&ranges[i].start, info->type, range) ||

-		!parseValue (&ranges[i].end, info->type, sep+1))

-	        break;

-	    if (info->type == DRI_INT &&

-		ranges[i].start._int > ranges[i].end._int)

-		break;

-	    if (info->type == DRI_FLOAT &&

-		ranges[i].start._float > ranges[i].end._float)

-		break;

-	} else { /* empty interval */

-	    if (!parseValue (&ranges[i].start, info->type, range))

-		break;

-	    ranges[i].end = ranges[i].start;

-	}

-	if (end)

-	    range = end+1;

-	else

-	    range = NULL;

-    }

-    FREE (cp);

-    if (i < nRanges) {

-	FREE (ranges);

-	return GL_FALSE;

-    } else

-	assert (range == NULL);

-

-    info->nRanges = nRanges;

-    info->ranges = ranges;

-    return GL_TRUE;

-}

-

-/** \brief Check if a value is in one of info->ranges. */

-static GLboolean checkValue (const driOptionValue *v, const driOptionInfo *info) {

-    GLuint i;

-    assert (info->type != DRI_BOOL); /* should be caught by the parser */

-    if (info->nRanges == 0)

-	return GL_TRUE;

-    switch (info->type) {

-      case DRI_ENUM: /* enum is just a special integer */

-      case DRI_INT:

-	for (i = 0; i < info->nRanges; ++i)

-	    if (v->_int >= info->ranges[i].start._int &&

-		v->_int <= info->ranges[i].end._int)

-		return GL_TRUE;

-	break;

-      case DRI_FLOAT:

-	for (i = 0; i < info->nRanges; ++i)

-	    if (v->_float >= info->ranges[i].start._float &&

-		v->_float <= info->ranges[i].end._float)

-		return GL_TRUE;

-	break;

-      default:

-	assert (0); /* should never happen */

-    }

-    return GL_FALSE;

-}

-

-/** \brief Output a warning message. */

-#define XML_WARNING1(msg) do {\

-    __driUtilMessage ("Warning in %s line %d, column %d: "msg, data->name, \

-                      (int) XML_GetCurrentLineNumber(data->parser), \

-                      (int) XML_GetCurrentColumnNumber(data->parser)); \

-} while (0)

-#define XML_WARNING(msg,args...) do { \

-    __driUtilMessage ("Warning in %s line %d, column %d: "msg, data->name, \

-                      (int) XML_GetCurrentLineNumber(data->parser), \

-                      (int) XML_GetCurrentColumnNumber(data->parser), \

-                      args); \

-} while (0)

-/** \brief Output an error message. */

-#define XML_ERROR1(msg) do { \

-    __driUtilMessage ("Error in %s line %d, column %d: "msg, data->name, \

-                      (int) XML_GetCurrentLineNumber(data->parser), \

-                      (int) XML_GetCurrentColumnNumber(data->parser)); \

-} while (0)

-#define XML_ERROR(msg,args...) do { \

-    __driUtilMessage ("Error in %s line %d, column %d: "msg, data->name, \

-                      (int) XML_GetCurrentLineNumber(data->parser), \

-                      (int) XML_GetCurrentColumnNumber(data->parser), \

-                      args); \

-} while (0)

-/** \brief Output a fatal error message and abort. */

-#define XML_FATAL1(msg) do { \

-    fprintf (stderr, "Fatal error in %s line %d, column %d: "msg"\n", \

-             data->name, \

-             (int) XML_GetCurrentLineNumber(data->parser),	\

-             (int) XML_GetCurrentColumnNumber(data->parser)); \

-    abort();\

-} while (0)

-#define XML_FATAL(msg,args...) do { \

-    fprintf (stderr, "Fatal error in %s line %d, column %d: "msg"\n", \

-             data->name, \

-             (int) XML_GetCurrentLineNumber(data->parser),	\

-             (int) XML_GetCurrentColumnNumber(data->parser),		\

-             args); \

-    abort();\

-} while (0)

-

-/** \brief Parser context for __driConfigOptions. */

-struct OptInfoData {

-    const char *name;

-    XML_Parser parser;

-    driOptionCache *cache;

-    GLboolean inDriInfo;

-    GLboolean inSection;

-    GLboolean inDesc;

-    GLboolean inOption;

-    GLboolean inEnum;

-    int curOption;

-};

-

-/** \brief Elements in __driConfigOptions. */

-enum OptInfoElem {

-    OI_DESCRIPTION = 0, OI_DRIINFO, OI_ENUM, OI_OPTION, OI_SECTION, OI_COUNT

-};

-static const XML_Char *OptInfoElems[] = {

-    "description", "driinfo", "enum", "option", "section"

-};

-

-/** \brief Parse attributes of an enum element.

- *

- * We're not actually interested in the data. Just make sure this is ok

- * for external configuration tools.

- */

-static void parseEnumAttr (struct OptInfoData *data, const XML_Char **attr) {

-    GLuint i;

-    const XML_Char *value = NULL, *text = NULL;

-    driOptionValue v;

-    GLuint opt = data->curOption;

-    for (i = 0; attr[i]; i += 2) {

-	if (!strcmp (attr[i], "value")) value = attr[i+1];

-	else if (!strcmp (attr[i], "text")) text = attr[i+1];

-	else XML_FATAL("illegal enum attribute: %s.", attr[i]);

-    }

-    if (!value) XML_FATAL1 ("value attribute missing in enum.");

-    if (!text) XML_FATAL1 ("text attribute missing in enum.");

-     if (!parseValue (&v, data->cache->info[opt].type, value))

-	XML_FATAL ("illegal enum value: %s.", value);

-    if (!checkValue (&v, &data->cache->info[opt]))

-	XML_FATAL ("enum value out of valid range: %s.", value);

-}

-

-/** \brief Parse attributes of a description element.

- *

- * We're not actually interested in the data. Just make sure this is ok

- * for external configuration tools.

- */

-static void parseDescAttr (struct OptInfoData *data, const XML_Char **attr) {

-    GLuint i;

-    const XML_Char *lang = NULL, *text = NULL;

-    for (i = 0; attr[i]; i += 2) {

-	if (!strcmp (attr[i], "lang")) lang = attr[i+1];

-	else if (!strcmp (attr[i], "text")) text = attr[i+1];

-	else XML_FATAL("illegal description attribute: %s.", attr[i]);

-    }

-    if (!lang) XML_FATAL1 ("lang attribute missing in description.");

-    if (!text) XML_FATAL1 ("text attribute missing in description.");

-}

-

-/** \brief Parse attributes of an option element. */

-static void parseOptInfoAttr (struct OptInfoData *data, const XML_Char **attr) {

-    enum OptAttr {OA_DEFAULT = 0, OA_NAME, OA_TYPE, OA_VALID, OA_COUNT};

-    static const XML_Char *optAttr[] = {"default", "name", "type", "valid"};

-    const XML_Char *attrVal[OA_COUNT] = {NULL, NULL, NULL, NULL};

-    const char *defaultVal;

-    driOptionCache *cache = data->cache;

-    GLuint opt, i;

-    for (i = 0; attr[i]; i += 2) {

-	GLuint attrName = bsearchStr (attr[i], optAttr, OA_COUNT);

-	if (attrName >= OA_COUNT)

-	    XML_FATAL ("illegal option attribute: %s", attr[i]);

-	attrVal[attrName] = attr[i+1];

-    }

-    if (!attrVal[OA_NAME]) XML_FATAL1 ("name attribute missing in option.");

-    if (!attrVal[OA_TYPE]) XML_FATAL1 ("type attribute missing in option.");

-    if (!attrVal[OA_DEFAULT]) XML_FATAL1 ("default attribute missing in option.");

-

-    opt = findOption (cache, attrVal[OA_NAME]);

-    if (cache->info[opt].name)

-	XML_FATAL ("option %s redefined.", attrVal[OA_NAME]);

-    data->curOption = opt;

-

-    XSTRDUP (cache->info[opt].name, attrVal[OA_NAME]);

-

-    if (!strcmp (attrVal[OA_TYPE], "bool"))

-	cache->info[opt].type = DRI_BOOL;

-    else if (!strcmp (attrVal[OA_TYPE], "enum"))

-	cache->info[opt].type = DRI_ENUM;

-    else if (!strcmp (attrVal[OA_TYPE], "int"))

-	cache->info[opt].type = DRI_INT;

-    else if (!strcmp (attrVal[OA_TYPE], "float"))

-	cache->info[opt].type = DRI_FLOAT;

-    else

-	XML_FATAL ("illegal type in option: %s.", attrVal[OA_TYPE]);

-

-    defaultVal = getenv (cache->info[opt].name);

-    if (defaultVal != NULL) {

-      /* don't use XML_WARNING, we want the user to see this! */

-	fprintf (stderr,

-		 "ATTENTION: default value of option %s overridden by environment.\n",

-		 cache->info[opt].name);

-    } else

-	defaultVal = attrVal[OA_DEFAULT];

-    if (!parseValue (&cache->values[opt], cache->info[opt].type, defaultVal))

-	XML_FATAL ("illegal default value: %s.", defaultVal);

-

-    if (attrVal[OA_VALID]) {

-	if (cache->info[opt].type == DRI_BOOL)

-	    XML_FATAL1 ("boolean option with valid attribute.");

-	if (!parseRanges (&cache->info[opt], attrVal[OA_VALID]))

-	    XML_FATAL ("illegal valid attribute: %s.", attrVal[OA_VALID]);

-	if (!checkValue (&cache->values[opt], &cache->info[opt]))

-	    XML_FATAL ("default value out of valid range '%s': %s.",

-		       attrVal[OA_VALID], defaultVal);

-    } else if (cache->info[opt].type == DRI_ENUM) {

-	XML_FATAL1 ("valid attribute missing in option (mandatory for enums).");

-    } else {

-	cache->info[opt].nRanges = 0;

-	cache->info[opt].ranges = NULL;

-    }

-}

-

-/** \brief Handler for start element events. */

-static void optInfoStartElem (void *userData, const XML_Char *name,

-			      const XML_Char **attr) {

-    struct OptInfoData *data = (struct OptInfoData *)userData;

-    enum OptInfoElem elem = bsearchStr (name, OptInfoElems, OI_COUNT);

-    switch (elem) {

-      case OI_DRIINFO:

-	if (data->inDriInfo)

-	    XML_FATAL1 ("nested <driinfo> elements.");

-	if (attr[0])

-	    XML_FATAL1 ("attributes specified on <driinfo> element.");

-	data->inDriInfo = GL_TRUE;

-	break;

-      case OI_SECTION:

-	if (!data->inDriInfo)

-	    XML_FATAL1 ("<section> must be inside <driinfo>.");

-	if (data->inSection)

-	    XML_FATAL1 ("nested <section> elements.");

-	if (attr[0])

-	    XML_FATAL1 ("attributes specified on <section> element.");

-	data->inSection = GL_TRUE;

-	break;

-      case OI_DESCRIPTION:

-	if (!data->inSection && !data->inOption)

-	    XML_FATAL1 ("<description> must be inside <description> or <option.");

-	if (data->inDesc)

-	    XML_FATAL1 ("nested <description> elements.");

-	data->inDesc = GL_TRUE;

-	parseDescAttr (data, attr);

-	break;

-      case OI_OPTION:

-	if (!data->inSection)

-	    XML_FATAL1 ("<option> must be inside <section>.");

-	if (data->inDesc)

-	    XML_FATAL1 ("<option> nested in <description> element.");

-	if (data->inOption)

-	    XML_FATAL1 ("nested <option> elements.");

-	data->inOption = GL_TRUE;

-	parseOptInfoAttr (data, attr);

-	break;

-      case OI_ENUM:

-	if (!(data->inOption && data->inDesc))

-	    XML_FATAL1 ("<enum> must be inside <option> and <description>.");

-	if (data->inEnum)

-	    XML_FATAL1 ("nested <enum> elements.");

-	data->inEnum = GL_TRUE;

-	parseEnumAttr (data, attr);

-	break;

-      default:

-	XML_FATAL ("unknown element: %s.", name);

-    }

-}

-

-/** \brief Handler for end element events. */

-static void optInfoEndElem (void *userData, const XML_Char *name) {

-    struct OptInfoData *data = (struct OptInfoData *)userData;

-    enum OptInfoElem elem = bsearchStr (name, OptInfoElems, OI_COUNT);

-    switch (elem) {

-      case OI_DRIINFO:

-	data->inDriInfo = GL_FALSE;

-	break;

-      case OI_SECTION:

-	data->inSection = GL_FALSE;

-	break;

-      case OI_DESCRIPTION:

-	data->inDesc = GL_FALSE;

-	break;

-      case OI_OPTION:

-	data->inOption = GL_FALSE;

-	break;

-      case OI_ENUM:

-	data->inEnum = GL_FALSE;

-	break;

-      default:

-	assert (0); /* should have been caught by StartElem */

-    }

-}

-

-void driParseOptionInfo (driOptionCache *info,

-			 const char *configOptions, GLuint nConfigOptions) {

-    XML_Parser p;

-    int status;

-    struct OptInfoData userData;

-    struct OptInfoData *data = &userData;

-    GLuint realNoptions;

-

-  /* determine hash table size and allocate memory:

-   * 3/2 of the number of options, rounded up, so there remains always

-   * at least one free entry. This is needed for detecting undefined

-   * options in configuration files without getting a hash table overflow.

-   * Round this up to a power of two. */

-    GLuint minSize = (nConfigOptions*3 + 1) / 2;

-    GLuint size, log2size;

-    for (size = 1, log2size = 0; size < minSize; size <<= 1, ++log2size);

-    info->tableSize = log2size;

-    info->info = CALLOC (size * sizeof (driOptionInfo));

-    info->values = CALLOC (size * sizeof (driOptionValue));

-    if (info->info == NULL || info->values == NULL) {

-	fprintf (stderr, "%s: %d: out of memory.\n", __FILE__, __LINE__);

-	abort();

-    }

-

-    p = XML_ParserCreate ("UTF-8"); /* always UTF-8 */

-    XML_SetElementHandler (p, optInfoStartElem, optInfoEndElem);

-    XML_SetUserData (p, data);

-

-    userData.name = "__driConfigOptions";

-    userData.parser = p;

-    userData.cache = info;

-    userData.inDriInfo = GL_FALSE;

-    userData.inSection = GL_FALSE;

-    userData.inDesc = GL_FALSE;

-    userData.inOption = GL_FALSE;

-    userData.inEnum = GL_FALSE;

-    userData.curOption = -1;

-

-    status = XML_Parse (p, configOptions, strlen (configOptions), 1);

-    if (!status)

-	XML_FATAL ("%s.", XML_ErrorString(XML_GetErrorCode(p)));

-

-    XML_ParserFree (p);

-

-  /* Check if the actual number of options matches nConfigOptions.

-   * A mismatch is not fatal (a hash table overflow would be) but we

-   * want the driver developer's attention anyway. */

-    realNoptions = countOptions (info);

-    if (realNoptions != nConfigOptions) {

-	fprintf (stderr,

-		 "Error: nConfigOptions (%u) does not match the actual number of options in\n"

-		 "       __driConfigOptions (%u).\n",

-		 nConfigOptions, realNoptions);

-    }

-}

-

-/** \brief Parser context for configuration files. */

-struct OptConfData {

-    const char *name;

-    XML_Parser parser;

-    driOptionCache *cache;

-    GLint screenNum;

-    const char *driverName, *execName;

-    GLuint ignoringDevice;

-    GLuint ignoringApp;

-    GLuint inDriConf;

-    GLuint inDevice;

-    GLuint inApp;

-    GLuint inOption;

-};

-

-/** \brief Elements in configuration files. */

-enum OptConfElem {

-    OC_APPLICATION = 0, OC_DEVICE, OC_DRICONF, OC_OPTION, OC_COUNT

-};

-static const XML_Char *OptConfElems[] = {

-    "application", "device", "driconf", "option"

-};

-

-/** \brief Parse attributes of a device element. */

-static void parseDeviceAttr (struct OptConfData *data, const XML_Char **attr) {

-    GLuint i;

-    const XML_Char *driver = NULL, *screen = NULL;

-    for (i = 0; attr[i]; i += 2) {

-	if (!strcmp (attr[i], "driver")) driver = attr[i+1];

-	else if (!strcmp (attr[i], "screen")) screen = attr[i+1];

-	else XML_WARNING("unknown device attribute: %s.", attr[i]);

-    }

-    if (driver && strcmp (driver, data->driverName))

-	data->ignoringDevice = data->inDevice;

-    else if (screen) {

-	driOptionValue screenNum;

-	if (!parseValue (&screenNum, DRI_INT, screen))

-	    XML_WARNING("illegal screen number: %s.", screen);

-	else if (screenNum._int != data->screenNum)

-	    data->ignoringDevice = data->inDevice;

-    }

-}

-

-/** \brief Parse attributes of an application element. */

-static void parseAppAttr (struct OptConfData *data, const XML_Char **attr) {

-    GLuint i;

-    const XML_Char *name = NULL, *exec = NULL;

-    for (i = 0; attr[i]; i += 2) {

-	if (!strcmp (attr[i], "name")) name = attr[i+1];

-	else if (!strcmp (attr[i], "executable")) exec = attr[i+1];

-	else XML_WARNING("unknown application attribute: %s.", attr[i]);

-    }

-    if (exec && strcmp (exec, data->execName))

-	data->ignoringApp = data->inApp;

-}

-

-/** \brief Parse attributes of an option element. */

-static void parseOptConfAttr (struct OptConfData *data, const XML_Char **attr) {

-    GLuint i;

-    const XML_Char *name = NULL, *value = NULL;

-    for (i = 0; attr[i]; i += 2) {

-	if (!strcmp (attr[i], "name")) name = attr[i+1];

-	else if (!strcmp (attr[i], "value")) value = attr[i+1];

-	else XML_WARNING("unknown option attribute: %s.", attr[i]);

-    }

-    if (!name) XML_WARNING1 ("name attribute missing in option.");

-    if (!value) XML_WARNING1 ("value attribute missing in option.");

-    if (name && value) {

-	driOptionCache *cache = data->cache;

-	GLuint opt = findOption (cache, name);

-	if (cache->info[opt].name == NULL)

-	    XML_WARNING ("undefined option: %s.", name);

-	else if (getenv (cache->info[opt].name))

-	  /* don't use XML_WARNING, we want the user to see this! */

-	    fprintf (stderr, "ATTENTION: option value of option %s ignored.\n",

-		     cache->info[opt].name);

-	else if (!parseValue (&cache->values[opt], cache->info[opt].type, value))

-	    XML_WARNING ("illegal option value: %s.", value);

-    }

-}

-

-/** \brief Handler for start element events. */

-static void optConfStartElem (void *userData, const XML_Char *name,

-			      const XML_Char **attr) {

-    struct OptConfData *data = (struct OptConfData *)userData;

-    enum OptConfElem elem = bsearchStr (name, OptConfElems, OC_COUNT);

-    switch (elem) {

-      case OC_DRICONF:

-	if (data->inDriConf)

-	    XML_WARNING1 ("nested <driconf> elements.");

-	if (attr[0])

-	    XML_WARNING1 ("attributes specified on <driconf> element.");

-	data->inDriConf++;

-	break;

-      case OC_DEVICE:

-	if (!data->inDriConf)

-	    XML_WARNING1 ("<device> should be inside <driconf>.");

-	if (data->inDevice)

-	    XML_WARNING1 ("nested <device> elements.");

-	data->inDevice++;

-	if (!data->ignoringDevice && !data->ignoringApp)

-	    parseDeviceAttr (data, attr);

-	break;

-      case OC_APPLICATION:

-	if (!data->inDevice)

-	    XML_WARNING1 ("<application> should be inside <device>.");

-	if (data->inApp)

-	    XML_WARNING1 ("nested <application> elements.");

-	data->inApp++;

-	if (!data->ignoringDevice && !data->ignoringApp)

-	    parseAppAttr (data, attr);

-	break;

-      case OC_OPTION:

-	if (!data->inApp)

-	    XML_WARNING1 ("<option> should be inside <application>.");

-	if (data->inOption)

-	    XML_WARNING1 ("nested <option> elements.");

-	data->inOption++;

-	if (!data->ignoringDevice && !data->ignoringApp)

-	    parseOptConfAttr (data, attr);

-	break;

-      default:

-	XML_WARNING ("unknown element: %s.", name);

-    }

-}

-

-/** \brief Handler for end element events. */

-static void optConfEndElem (void *userData, const XML_Char *name) {

-    struct OptConfData *data = (struct OptConfData *)userData;

-    enum OptConfElem elem = bsearchStr (name, OptConfElems, OC_COUNT);

-    switch (elem) {

-      case OC_DRICONF:

-	data->inDriConf--;

-	break;

-      case OC_DEVICE:

-	if (data->inDevice-- == data->ignoringDevice)

-	    data->ignoringDevice = 0;

-	break;

-      case OC_APPLICATION:

-	if (data->inApp-- == data->ignoringApp)

-	    data->ignoringApp = 0;

-	break;

-      case OC_OPTION:

-	data->inOption--;

-	break;

-      default:

-	/* unknown element, warning was produced on start tag */;

-    }

-}

-

-/** \brief Initialize an option cache based on info */

-static void initOptionCache (driOptionCache *cache, const driOptionCache *info) {

-    cache->info = info->info;

-    cache->tableSize = info->tableSize;

-    cache->values = MALLOC ((1<<info->tableSize) * sizeof (driOptionValue));

-    if (cache->values == NULL) {

-	fprintf (stderr, "%s: %d: out of memory.\n", __FILE__, __LINE__);

-	abort();

-    }

-    memcpy (cache->values, info->values,

-	    (1<<info->tableSize) * sizeof (driOptionValue));

-}

-

-/** \brief Parse the named configuration file */

-static void parseOneConfigFile (XML_Parser p) {

-#define BUF_SIZE 0x1000

-    struct OptConfData *data = (struct OptConfData *)XML_GetUserData (p);

-    int status;

-    int fd;

-

-    if ((fd = open (data->name, O_RDONLY)) == -1) {

-	__driUtilMessage ("Can't open configuration file %s: %s.",

-			  data->name, strerror (errno));

-	return;

-    }

-

-    while (1) {

-	int bytesRead;

-	void *buffer = XML_GetBuffer (p, BUF_SIZE);

-	if (!buffer) {

-	    __driUtilMessage ("Can't allocate parser buffer.");

-	    break;

-	}

-	bytesRead = read (fd, buffer, BUF_SIZE);

-	if (bytesRead == -1) {

-	    __driUtilMessage ("Error reading from configuration file %s: %s.",

-			      data->name, strerror (errno));

-	    break;

-	}

-	status = XML_ParseBuffer (p, bytesRead, bytesRead == 0);

-	if (!status) {

-	    XML_ERROR ("%s.", XML_ErrorString(XML_GetErrorCode(p)));

-	    break;

-	}

-	if (bytesRead == 0)

-	    break;

-    }

-

-    close (fd);

-#undef BUF_SIZE

-}

-

-void driParseConfigFiles (driOptionCache *cache, const driOptionCache *info,

-			  GLint screenNum, const char *driverName) {

-    char *filenames[2] = {"/etc/drirc", NULL};

-    char *home;

-    GLuint i;

-    struct OptConfData userData;

-

-    initOptionCache (cache, info);

-

-    userData.cache = cache;

-    userData.screenNum = screenNum;

-    userData.driverName = driverName;

-    userData.execName = GET_PROGRAM_NAME();

-

-    if ((home = getenv ("HOME"))) {

-	GLuint len = strlen (home);

-	filenames[1] = MALLOC (len + 7+1);

-	if (filenames[1] == NULL)

-	    __driUtilMessage ("Can't allocate memory for %s/.drirc.", home);

-	else {

-	    memcpy (filenames[1], home, len);

-	    memcpy (filenames[1] + len, "/.drirc", 7+1);

-	}

-    }

-

-    for (i = 0; i < 2; ++i) {

-	XML_Parser p;

-	if (filenames[i] == NULL)

-	    continue;

-

-	p = XML_ParserCreate (NULL); /* use encoding specified by file */

-	XML_SetElementHandler (p, optConfStartElem, optConfEndElem);

-	XML_SetUserData (p, &userData);

-	userData.parser = p;

-	userData.name = filenames[i];

-	userData.ignoringDevice = 0;

-	userData.ignoringApp = 0;

-	userData.inDriConf = 0;

-	userData.inDevice = 0;

-	userData.inApp = 0;

-	userData.inOption = 0;

-

-	parseOneConfigFile (p);

-	XML_ParserFree (p);

-    }

-

-    if (filenames[1])

-	FREE (filenames[1]);

-}

-

-void driDestroyOptionInfo (driOptionCache *info) {

-    driDestroyOptionCache (info);

-    if (info->info) {

-	GLuint i, size = 1 << info->tableSize;

-	for (i = 0; i < size; ++i) {

-	    if (info->info[i].name) {

-		FREE (info->info[i].name);

-		if (info->info[i].ranges)

-		    FREE (info->info[i].ranges);

-	    }

-	}

-	FREE (info->info);

-    }

-}

-

-void driDestroyOptionCache (driOptionCache *cache) {

-    if (cache->values)

-	FREE (cache->values);

-}

-

-GLboolean driCheckOption (const driOptionCache *cache, const char *name,

-			  driOptionType type) {

-    GLuint i = findOption (cache, name);

-    return cache->info[i].name != NULL && cache->info[i].type == type;

-}

-

-GLboolean driQueryOptionb (const driOptionCache *cache, const char *name) {

-    GLuint i = findOption (cache, name);

-  /* make sure the option is defined and has the correct type */

-    assert (cache->info[i].name != NULL);

-    assert (cache->info[i].type == DRI_BOOL);

-    return cache->values[i]._bool;

-}

-

-GLint driQueryOptioni (const driOptionCache *cache, const char *name) {

-    GLuint i = findOption (cache, name);

-  /* make sure the option is defined and has the correct type */

-    assert (cache->info[i].name != NULL);

-    assert (cache->info[i].type == DRI_INT || cache->info[i].type == DRI_ENUM);

-    return cache->values[i]._int;

-}

-

-GLfloat driQueryOptionf (const driOptionCache *cache, const char *name) {

-    GLuint i = findOption (cache, name);

-  /* make sure the option is defined and has the correct type */

-    assert (cache->info[i].name != NULL);

-    assert (cache->info[i].type == DRI_FLOAT);

-    return cache->values[i]._float;

-}

+/*
+ * XML DRI client-side driver configuration
+ * Copyright (C) 2003 Felix Kuehling
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * FELIX KUEHLING, OR ANY OTHER CONTRIBUTORS BE LIABLE FOR ANY CLAIM, 
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR 
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE 
+ * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ * 
+ */
+/**
+ * \file xmlconfig.c
+ * \brief Driver-independent client-side part of the XML configuration
+ * \author Felix Kuehling
+ */
+
+#include "main/glheader.h"
+
+#include <string.h>
+#include <assert.h>
+#include <expat.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <errno.h>
+#include "main/imports.h"
+#include "utils.h"
+#include "xmlconfig.h"
+
+#undef GET_PROGRAM_NAME
+
+#if (defined(__GNU_LIBRARY__) || defined(__GLIBC__)) && !defined(__UCLIBC__)
+#    if !defined(__GLIBC__) || (__GLIBC__ < 2)
+/* These aren't declared in any libc5 header */
+extern char *program_invocation_name, *program_invocation_short_name;
+#    endif
+#    define GET_PROGRAM_NAME() program_invocation_short_name
+#elif defined(__FreeBSD__) && (__FreeBSD__ >= 2)
+#    include <osreldate.h>
+#    if (__FreeBSD_version >= 440000)
+#        include <stdlib.h>
+#        define GET_PROGRAM_NAME() getprogname()
+#    endif
+#elif defined(__NetBSD__) && defined(__NetBSD_Version) && (__NetBSD_Version >= 106000100)
+#    include <stdlib.h>
+#    define GET_PROGRAM_NAME() getprogname()
+#elif defined(__APPLE__)
+#    include <stdlib.h>
+#    define GET_PROGRAM_NAME() getprogname()
+#elif defined(__sun)
+/* Solaris has getexecname() which returns the full path - return just
+   the basename to match BSD getprogname() */
+#    include <stdlib.h>
+#    include <libgen.h>
+
+static const char *__getProgramName () {
+    static const char *progname;
+
+    if (progname == NULL) {
+	const char *e = getexecname();
+	if (e != NULL) {
+	    /* Have to make a copy since getexecname can return a readonly
+	       string, but basename expects to be able to modify its arg. */
+	    char *n = strdup(e);
+	    if (n != NULL) {
+		progname = basename(n);
+	    }
+	}
+    }
+    return progname;
+}
+
+#    define GET_PROGRAM_NAME() __getProgramName()
+#endif
+
+#if !defined(GET_PROGRAM_NAME)
+#    if defined(__OpenBSD__) || defined(NetBSD) || defined(__UCLIBC__)
+/* This is a hack. It's said to work on OpenBSD, NetBSD and GNU.
+ * Rogelio M.Serrano Jr. reported it's also working with UCLIBC. It's
+ * used as a last resort, if there is no documented facility available. */
+static const char *__getProgramName () {
+    extern const char *__progname;
+    char * arg = strrchr(__progname, '/');
+    if (arg)
+        return arg+1;
+    else
+        return __progname;
+}
+#        define GET_PROGRAM_NAME() __getProgramName()
+#    else
+#        define GET_PROGRAM_NAME() ""
+#        warning "Per application configuration won't work with your OS version."
+#    endif
+#endif
+
+/** \brief Find an option in an option cache with the name as key */
+static GLuint findOption (const driOptionCache *cache, const char *name) {
+    GLuint len = strlen (name);
+    GLuint size = 1 << cache->tableSize, mask = size - 1;
+    GLuint hash = 0;
+    GLuint i, shift;
+
+  /* compute a hash from the variable length name */
+    for (i = 0, shift = 0; i < len; ++i, shift = (shift+8) & 31)
+	hash += (GLuint)name[i] << shift;
+    hash *= hash;
+    hash = (hash >> (16-cache->tableSize/2)) & mask;
+
+  /* this is just the starting point of the linear search for the option */
+    for (i = 0; i < size; ++i, hash = (hash+1) & mask) {
+      /* if we hit an empty entry then the option is not defined (yet) */
+	if (cache->info[hash].name == 0)
+	    break;
+	else if (!strcmp (name, cache->info[hash].name))
+	    break;
+    }
+  /* this assertion fails if the hash table is full */
+    assert (i < size);
+
+    return hash;
+}
+
+/** \brief Count the real number of options in an option cache */
+static GLuint countOptions (const driOptionCache *cache) {
+    GLuint size = 1 << cache->tableSize;
+    GLuint i, count = 0;
+    for (i = 0; i < size; ++i)
+	if (cache->info[i].name)
+	    count++;
+    return count;
+}
+
+/** \brief Like strdup but using MALLOC and with error checking. */
+#define XSTRDUP(dest,source) do { \
+    GLuint len = strlen (source); \
+    if (!(dest = MALLOC (len+1))) { \
+	fprintf (stderr, "%s: %d: out of memory.\n", __FILE__, __LINE__); \
+	abort(); \
+    } \
+    memcpy (dest, source, len+1); \
+} while (0)
+
+static int compare (const void *a, const void *b) {
+    return strcmp (*(char *const*)a, *(char *const*)b);
+}
+/** \brief Binary search in a string array. */
+static GLuint bsearchStr (const XML_Char *name,
+			  const XML_Char *elems[], GLuint count) {
+    const XML_Char **found;
+    found = bsearch (&name, elems, count, sizeof (XML_Char *), compare);
+    if (found)
+	return found - elems;
+    else
+	return count;
+}
+
+/** \brief Locale-independent integer parser.
+ *
+ * Works similar to strtol. Leading space is NOT skipped. The input
+ * number may have an optional sign. Radix is specified by base. If
+ * base is 0 then decimal is assumed unless the input number is
+ * prefixed by 0x or 0X for hexadecimal or 0 for octal. After
+ * returning tail points to the first character that is not part of
+ * the integer number. If no number was found then tail points to the
+ * start of the input string. */
+static GLint strToI (const XML_Char *string, const XML_Char **tail, int base) {
+    GLint radix = base == 0 ? 10 : base;
+    GLint result = 0;
+    GLint sign = 1;
+    GLboolean numberFound = GL_FALSE;
+    const XML_Char *start = string;
+
+    assert (radix >= 2 && radix <= 36);
+
+    if (*string == '-') {
+	sign = -1;
+	string++;
+    } else if (*string == '+')
+	string++;
+    if (base == 0 && *string == '0') {
+	numberFound = GL_TRUE; 
+	if (*(string+1) == 'x' || *(string+1) == 'X') {
+	    radix = 16;
+	    string += 2;
+	} else {
+	    radix = 8;
+	    string++;
+	}
+    }
+    do {
+	GLint digit = -1;
+	if (radix <= 10) {
+	    if (*string >= '0' && *string < '0' + radix)
+		digit = *string - '0';
+	} else {
+	    if (*string >= '0' && *string <= '9')
+		digit = *string - '0';
+	    else if (*string >= 'a' && *string < 'a' + radix - 10)
+		digit = *string - 'a' + 10;
+	    else if (*string >= 'A' && *string < 'A' + radix - 10)
+		digit = *string - 'A' + 10;
+	}
+	if (digit != -1) {
+	    numberFound = GL_TRUE;
+	    result = radix*result + digit;
+	    string++;
+	} else
+	    break;
+    } while (GL_TRUE);
+    *tail = numberFound ? string : start;
+    return sign * result;
+}
+
+/** \brief Locale-independent floating-point parser.
+ *
+ * Works similar to strtod. Leading space is NOT skipped. The input
+ * number may have an optional sign. '.' is interpreted as decimal
+ * point and may occur at most once. Optionally the number may end in
+ * [eE]<exponent>, where <exponent> is an integer as recognized by
+ * strToI. In that case the result is number * 10^exponent. After
+ * returning tail points to the first character that is not part of
+ * the floating point number. If no number was found then tail points
+ * to the start of the input string.
+ *
+ * Uses two passes for maximum accuracy. */
+static GLfloat strToF (const XML_Char *string, const XML_Char **tail) {
+    GLint nDigits = 0, pointPos, exponent;
+    GLfloat sign = 1.0f, result = 0.0f, scale;
+    const XML_Char *start = string, *numStart;
+
+    /* sign */
+    if (*string == '-') {
+	sign = -1.0f;
+	string++;
+    } else if (*string == '+')
+	string++;
+
+    /* first pass: determine position of decimal point, number of
+     * digits, exponent and the end of the number. */
+    numStart = string;
+    while (*string >= '0' && *string <= '9') {
+	string++;
+	nDigits++;
+    }
+    pointPos = nDigits;
+    if (*string == '.') {
+	string++;
+	while (*string >= '0' && *string <= '9') {
+	    string++;
+	    nDigits++;
+	}
+    }
+    if (nDigits == 0) {
+	/* no digits, no number */
+	*tail = start;
+	return 0.0f;
+    }
+    *tail = string;
+    if (*string == 'e' || *string == 'E') {
+	const XML_Char *expTail;
+	exponent = strToI (string+1, &expTail, 10);
+	if (expTail == string+1)
+	    exponent = 0;
+	else
+	    *tail = expTail;
+    } else
+	exponent = 0;
+    string = numStart;
+
+    /* scale of the first digit */
+    scale = sign * (GLfloat)pow (10.0, (GLdouble)(pointPos-1 + exponent));
+
+    /* second pass: parse digits */
+    do {
+	if (*string != '.') {
+	    assert (*string >= '0' && *string <= '9');
+	    result += scale * (GLfloat)(*string - '0');
+	    scale *= 0.1f;
+	    nDigits--;
+	}
+	string++;
+    } while (nDigits > 0);
+
+    return result;
+}
+
+/** \brief Parse a value of a given type. */
+static GLboolean parseValue (driOptionValue *v, driOptionType type,
+			     const XML_Char *string) {
+    const XML_Char *tail = NULL;
+  /* skip leading white-space */
+    string += strspn (string, " \f\n\r\t\v");
+    switch (type) {
+      case DRI_BOOL:
+	if (!strcmp (string, "false")) {
+	    v->_bool = GL_FALSE;
+	    tail = string + 5;
+	} else if (!strcmp (string, "true")) {
+	    v->_bool = GL_TRUE;
+	    tail = string + 4;
+	}
+	else
+	    return GL_FALSE;
+	break;
+      case DRI_ENUM: /* enum is just a special integer */
+      case DRI_INT:
+	v->_int = strToI (string, &tail, 0);
+	break;
+      case DRI_FLOAT:
+	v->_float = strToF (string, &tail);
+	break;
+    }
+
+    if (tail == string)
+	return GL_FALSE; /* empty string (or containing only white-space) */
+  /* skip trailing white space */
+    if (*tail)
+	tail += strspn (tail, " \f\n\r\t\v");
+    if (*tail)
+	return GL_FALSE; /* something left over that is not part of value */
+
+    return GL_TRUE;
+}
+
+/** \brief Parse a list of ranges of type info->type. */
+static GLboolean parseRanges (driOptionInfo *info, const XML_Char *string) {
+    XML_Char *cp, *range;
+    GLuint nRanges, i;
+    driOptionRange *ranges;
+
+    XSTRDUP (cp, string);
+  /* pass 1: determine the number of ranges (number of commas + 1) */
+    range = cp;
+    for (nRanges = 1; *range; ++range)
+	if (*range == ',')
+	    ++nRanges;
+
+    if ((ranges = MALLOC (nRanges*sizeof(driOptionRange))) == NULL) {
+	fprintf (stderr, "%s: %d: out of memory.\n", __FILE__, __LINE__);
+	abort();
+    }
+
+  /* pass 2: parse all ranges into preallocated array */
+    range = cp;
+    for (i = 0; i < nRanges; ++i) {
+	XML_Char *end, *sep;
+	assert (range);
+	end = strchr (range, ',');
+	if (end)
+	    *end = '\0';
+	sep = strchr (range, ':');
+	if (sep) { /* non-empty interval */
+	    *sep = '\0';
+	    if (!parseValue (&ranges[i].start, info->type, range) ||
+		!parseValue (&ranges[i].end, info->type, sep+1))
+	        break;
+	    if (info->type == DRI_INT &&
+		ranges[i].start._int > ranges[i].end._int)
+		break;
+	    if (info->type == DRI_FLOAT &&
+		ranges[i].start._float > ranges[i].end._float)
+		break;
+	} else { /* empty interval */
+	    if (!parseValue (&ranges[i].start, info->type, range))
+		break;
+	    ranges[i].end = ranges[i].start;
+	}
+	if (end)
+	    range = end+1;
+	else
+	    range = NULL;
+    }
+    FREE (cp);
+    if (i < nRanges) {
+	FREE (ranges);
+	return GL_FALSE;
+    } else
+	assert (range == NULL);
+
+    info->nRanges = nRanges;
+    info->ranges = ranges;
+    return GL_TRUE;
+}
+
+/** \brief Check if a value is in one of info->ranges. */
+static GLboolean checkValue (const driOptionValue *v, const driOptionInfo *info) {
+    GLuint i;
+    assert (info->type != DRI_BOOL); /* should be caught by the parser */
+    if (info->nRanges == 0)
+	return GL_TRUE;
+    switch (info->type) {
+      case DRI_ENUM: /* enum is just a special integer */
+      case DRI_INT:
+	for (i = 0; i < info->nRanges; ++i)
+	    if (v->_int >= info->ranges[i].start._int &&
+		v->_int <= info->ranges[i].end._int)
+		return GL_TRUE;
+	break;
+      case DRI_FLOAT:
+	for (i = 0; i < info->nRanges; ++i)
+	    if (v->_float >= info->ranges[i].start._float &&
+		v->_float <= info->ranges[i].end._float)
+		return GL_TRUE;
+	break;
+      default:
+	assert (0); /* should never happen */
+    }
+    return GL_FALSE;
+}
+
+/** \brief Output a warning message. */
+#define XML_WARNING1(msg) do {\
+    __driUtilMessage ("Warning in %s line %d, column %d: "msg, data->name, \
+                      (int) XML_GetCurrentLineNumber(data->parser), \
+                      (int) XML_GetCurrentColumnNumber(data->parser)); \
+} while (0)
+#define XML_WARNING(msg,args...) do { \
+    __driUtilMessage ("Warning in %s line %d, column %d: "msg, data->name, \
+                      (int) XML_GetCurrentLineNumber(data->parser), \
+                      (int) XML_GetCurrentColumnNumber(data->parser), \
+                      args); \
+} while (0)
+/** \brief Output an error message. */
+#define XML_ERROR1(msg) do { \
+    __driUtilMessage ("Error in %s line %d, column %d: "msg, data->name, \
+                      (int) XML_GetCurrentLineNumber(data->parser), \
+                      (int) XML_GetCurrentColumnNumber(data->parser)); \
+} while (0)
+#define XML_ERROR(msg,args...) do { \
+    __driUtilMessage ("Error in %s line %d, column %d: "msg, data->name, \
+                      (int) XML_GetCurrentLineNumber(data->parser), \
+                      (int) XML_GetCurrentColumnNumber(data->parser), \
+                      args); \
+} while (0)
+/** \brief Output a fatal error message and abort. */
+#define XML_FATAL1(msg) do { \
+    fprintf (stderr, "Fatal error in %s line %d, column %d: "msg"\n", \
+             data->name, \
+             (int) XML_GetCurrentLineNumber(data->parser),	\
+             (int) XML_GetCurrentColumnNumber(data->parser)); \
+    abort();\
+} while (0)
+#define XML_FATAL(msg,args...) do { \
+    fprintf (stderr, "Fatal error in %s line %d, column %d: "msg"\n", \
+             data->name, \
+             (int) XML_GetCurrentLineNumber(data->parser),	\
+             (int) XML_GetCurrentColumnNumber(data->parser),		\
+             args); \
+    abort();\
+} while (0)
+
+/** \brief Parser context for __driConfigOptions. */
+struct OptInfoData {
+    const char *name;
+    XML_Parser parser;
+    driOptionCache *cache;
+    GLboolean inDriInfo;
+    GLboolean inSection;
+    GLboolean inDesc;
+    GLboolean inOption;
+    GLboolean inEnum;
+    int curOption;
+};
+
+/** \brief Elements in __driConfigOptions. */
+enum OptInfoElem {
+    OI_DESCRIPTION = 0, OI_DRIINFO, OI_ENUM, OI_OPTION, OI_SECTION, OI_COUNT
+};
+static const XML_Char *OptInfoElems[] = {
+    "description", "driinfo", "enum", "option", "section"
+};
+
+/** \brief Parse attributes of an enum element.
+ *
+ * We're not actually interested in the data. Just make sure this is ok
+ * for external configuration tools.
+ */
+static void parseEnumAttr (struct OptInfoData *data, const XML_Char **attr) {
+    GLuint i;
+    const XML_Char *value = NULL, *text = NULL;
+    driOptionValue v;
+    GLuint opt = data->curOption;
+    for (i = 0; attr[i]; i += 2) {
+	if (!strcmp (attr[i], "value")) value = attr[i+1];
+	else if (!strcmp (attr[i], "text")) text = attr[i+1];
+	else XML_FATAL("illegal enum attribute: %s.", attr[i]);
+    }
+    if (!value) XML_FATAL1 ("value attribute missing in enum.");
+    if (!text) XML_FATAL1 ("text attribute missing in enum.");
+     if (!parseValue (&v, data->cache->info[opt].type, value))
+	XML_FATAL ("illegal enum value: %s.", value);
+    if (!checkValue (&v, &data->cache->info[opt]))
+	XML_FATAL ("enum value out of valid range: %s.", value);
+}
+
+/** \brief Parse attributes of a description element.
+ *
+ * We're not actually interested in the data. Just make sure this is ok
+ * for external configuration tools.
+ */
+static void parseDescAttr (struct OptInfoData *data, const XML_Char **attr) {
+    GLuint i;
+    const XML_Char *lang = NULL, *text = NULL;
+    for (i = 0; attr[i]; i += 2) {
+	if (!strcmp (attr[i], "lang")) lang = attr[i+1];
+	else if (!strcmp (attr[i], "text")) text = attr[i+1];
+	else XML_FATAL("illegal description attribute: %s.", attr[i]);
+    }
+    if (!lang) XML_FATAL1 ("lang attribute missing in description.");
+    if (!text) XML_FATAL1 ("text attribute missing in description.");
+}
+
+/** \brief Parse attributes of an option element. */
+static void parseOptInfoAttr (struct OptInfoData *data, const XML_Char **attr) {
+    enum OptAttr {OA_DEFAULT = 0, OA_NAME, OA_TYPE, OA_VALID, OA_COUNT};
+    static const XML_Char *optAttr[] = {"default", "name", "type", "valid"};
+    const XML_Char *attrVal[OA_COUNT] = {NULL, NULL, NULL, NULL};
+    const char *defaultVal;
+    driOptionCache *cache = data->cache;
+    GLuint opt, i;
+    for (i = 0; attr[i]; i += 2) {
+	GLuint attrName = bsearchStr (attr[i], optAttr, OA_COUNT);
+	if (attrName >= OA_COUNT)
+	    XML_FATAL ("illegal option attribute: %s", attr[i]);
+	attrVal[attrName] = attr[i+1];
+    }
+    if (!attrVal[OA_NAME]) XML_FATAL1 ("name attribute missing in option.");
+    if (!attrVal[OA_TYPE]) XML_FATAL1 ("type attribute missing in option.");
+    if (!attrVal[OA_DEFAULT]) XML_FATAL1 ("default attribute missing in option.");
+
+    opt = findOption (cache, attrVal[OA_NAME]);
+    if (cache->info[opt].name)
+	XML_FATAL ("option %s redefined.", attrVal[OA_NAME]);
+    data->curOption = opt;
+
+    XSTRDUP (cache->info[opt].name, attrVal[OA_NAME]);
+
+    if (!strcmp (attrVal[OA_TYPE], "bool"))
+	cache->info[opt].type = DRI_BOOL;
+    else if (!strcmp (attrVal[OA_TYPE], "enum"))
+	cache->info[opt].type = DRI_ENUM;
+    else if (!strcmp (attrVal[OA_TYPE], "int"))
+	cache->info[opt].type = DRI_INT;
+    else if (!strcmp (attrVal[OA_TYPE], "float"))
+	cache->info[opt].type = DRI_FLOAT;
+    else
+	XML_FATAL ("illegal type in option: %s.", attrVal[OA_TYPE]);
+
+    defaultVal = getenv (cache->info[opt].name);
+    if (defaultVal != NULL) {
+      /* don't use XML_WARNING, we want the user to see this! */
+	fprintf (stderr,
+		 "ATTENTION: default value of option %s overridden by environment.\n",
+		 cache->info[opt].name);
+    } else
+	defaultVal = attrVal[OA_DEFAULT];
+    if (!parseValue (&cache->values[opt], cache->info[opt].type, defaultVal))
+	XML_FATAL ("illegal default value: %s.", defaultVal);
+
+    if (attrVal[OA_VALID]) {
+	if (cache->info[opt].type == DRI_BOOL)
+	    XML_FATAL1 ("boolean option with valid attribute.");
+	if (!parseRanges (&cache->info[opt], attrVal[OA_VALID]))
+	    XML_FATAL ("illegal valid attribute: %s.", attrVal[OA_VALID]);
+	if (!checkValue (&cache->values[opt], &cache->info[opt]))
+	    XML_FATAL ("default value out of valid range '%s': %s.",
+		       attrVal[OA_VALID], defaultVal);
+    } else if (cache->info[opt].type == DRI_ENUM) {
+	XML_FATAL1 ("valid attribute missing in option (mandatory for enums).");
+    } else {
+	cache->info[opt].nRanges = 0;
+	cache->info[opt].ranges = NULL;
+    }
+}
+
+/** \brief Handler for start element events. */
+static void optInfoStartElem (void *userData, const XML_Char *name,
+			      const XML_Char **attr) {
+    struct OptInfoData *data = (struct OptInfoData *)userData;
+    enum OptInfoElem elem = bsearchStr (name, OptInfoElems, OI_COUNT);
+    switch (elem) {
+      case OI_DRIINFO:
+	if (data->inDriInfo)
+	    XML_FATAL1 ("nested <driinfo> elements.");
+	if (attr[0])
+	    XML_FATAL1 ("attributes specified on <driinfo> element.");
+	data->inDriInfo = GL_TRUE;
+	break;
+      case OI_SECTION:
+	if (!data->inDriInfo)
+	    XML_FATAL1 ("<section> must be inside <driinfo>.");
+	if (data->inSection)
+	    XML_FATAL1 ("nested <section> elements.");
+	if (attr[0])
+	    XML_FATAL1 ("attributes specified on <section> element.");
+	data->inSection = GL_TRUE;
+	break;
+      case OI_DESCRIPTION:
+	if (!data->inSection && !data->inOption)
+	    XML_FATAL1 ("<description> must be inside <description> or <option.");
+	if (data->inDesc)
+	    XML_FATAL1 ("nested <description> elements.");
+	data->inDesc = GL_TRUE;
+	parseDescAttr (data, attr);
+	break;
+      case OI_OPTION:
+	if (!data->inSection)
+	    XML_FATAL1 ("<option> must be inside <section>.");
+	if (data->inDesc)
+	    XML_FATAL1 ("<option> nested in <description> element.");
+	if (data->inOption)
+	    XML_FATAL1 ("nested <option> elements.");
+	data->inOption = GL_TRUE;
+	parseOptInfoAttr (data, attr);
+	break;
+      case OI_ENUM:
+	if (!(data->inOption && data->inDesc))
+	    XML_FATAL1 ("<enum> must be inside <option> and <description>.");
+	if (data->inEnum)
+	    XML_FATAL1 ("nested <enum> elements.");
+	data->inEnum = GL_TRUE;
+	parseEnumAttr (data, attr);
+	break;
+      default:
+	XML_FATAL ("unknown element: %s.", name);
+    }
+}
+
+/** \brief Handler for end element events. */
+static void optInfoEndElem (void *userData, const XML_Char *name) {
+    struct OptInfoData *data = (struct OptInfoData *)userData;
+    enum OptInfoElem elem = bsearchStr (name, OptInfoElems, OI_COUNT);
+    switch (elem) {
+      case OI_DRIINFO:
+	data->inDriInfo = GL_FALSE;
+	break;
+      case OI_SECTION:
+	data->inSection = GL_FALSE;
+	break;
+      case OI_DESCRIPTION:
+	data->inDesc = GL_FALSE;
+	break;
+      case OI_OPTION:
+	data->inOption = GL_FALSE;
+	break;
+      case OI_ENUM:
+	data->inEnum = GL_FALSE;
+	break;
+      default:
+	assert (0); /* should have been caught by StartElem */
+    }
+}
+
+void driParseOptionInfo (driOptionCache *info,
+			 const char *configOptions, GLuint nConfigOptions) {
+    XML_Parser p;
+    int status;
+    struct OptInfoData userData;
+    struct OptInfoData *data = &userData;
+    GLuint realNoptions;
+
+  /* determine hash table size and allocate memory:
+   * 3/2 of the number of options, rounded up, so there remains always
+   * at least one free entry. This is needed for detecting undefined
+   * options in configuration files without getting a hash table overflow.
+   * Round this up to a power of two. */
+    GLuint minSize = (nConfigOptions*3 + 1) / 2;
+    GLuint size, log2size;
+    for (size = 1, log2size = 0; size < minSize; size <<= 1, ++log2size);
+    info->tableSize = log2size;
+    info->info = CALLOC (size * sizeof (driOptionInfo));
+    info->values = CALLOC (size * sizeof (driOptionValue));
+    if (info->info == NULL || info->values == NULL) {
+	fprintf (stderr, "%s: %d: out of memory.\n", __FILE__, __LINE__);
+	abort();
+    }
+
+    p = XML_ParserCreate ("UTF-8"); /* always UTF-8 */
+    XML_SetElementHandler (p, optInfoStartElem, optInfoEndElem);
+    XML_SetUserData (p, data);
+
+    userData.name = "__driConfigOptions";
+    userData.parser = p;
+    userData.cache = info;
+    userData.inDriInfo = GL_FALSE;
+    userData.inSection = GL_FALSE;
+    userData.inDesc = GL_FALSE;
+    userData.inOption = GL_FALSE;
+    userData.inEnum = GL_FALSE;
+    userData.curOption = -1;
+
+    status = XML_Parse (p, configOptions, strlen (configOptions), 1);
+    if (!status)
+	XML_FATAL ("%s.", XML_ErrorString(XML_GetErrorCode(p)));
+
+    XML_ParserFree (p);
+
+  /* Check if the actual number of options matches nConfigOptions.
+   * A mismatch is not fatal (a hash table overflow would be) but we
+   * want the driver developer's attention anyway. */
+    realNoptions = countOptions (info);
+    if (realNoptions != nConfigOptions) {
+	fprintf (stderr,
+		 "Error: nConfigOptions (%u) does not match the actual number of options in\n"
+		 "       __driConfigOptions (%u).\n",
+		 nConfigOptions, realNoptions);
+    }
+}
+
+/** \brief Parser context for configuration files. */
+struct OptConfData {
+    const char *name;
+    XML_Parser parser;
+    driOptionCache *cache;
+    GLint screenNum;
+    const char *driverName, *execName;
+    GLuint ignoringDevice;
+    GLuint ignoringApp;
+    GLuint inDriConf;
+    GLuint inDevice;
+    GLuint inApp;
+    GLuint inOption;
+};
+
+/** \brief Elements in configuration files. */
+enum OptConfElem {
+    OC_APPLICATION = 0, OC_DEVICE, OC_DRICONF, OC_OPTION, OC_COUNT
+};
+static const XML_Char *OptConfElems[] = {
+    "application", "device", "driconf", "option"
+};
+
+/** \brief Parse attributes of a device element. */
+static void parseDeviceAttr (struct OptConfData *data, const XML_Char **attr) {
+    GLuint i;
+    const XML_Char *driver = NULL, *screen = NULL;
+    for (i = 0; attr[i]; i += 2) {
+	if (!strcmp (attr[i], "driver")) driver = attr[i+1];
+	else if (!strcmp (attr[i], "screen")) screen = attr[i+1];
+	else XML_WARNING("unknown device attribute: %s.", attr[i]);
+    }
+    if (driver && strcmp (driver, data->driverName))
+	data->ignoringDevice = data->inDevice;
+    else if (screen) {
+	driOptionValue screenNum;
+	if (!parseValue (&screenNum, DRI_INT, screen))
+	    XML_WARNING("illegal screen number: %s.", screen);
+	else if (screenNum._int != data->screenNum)
+	    data->ignoringDevice = data->inDevice;
+    }
+}
+
+/** \brief Parse attributes of an application element. */
+static void parseAppAttr (struct OptConfData *data, const XML_Char **attr) {
+    GLuint i;
+    const XML_Char *exec = NULL;
+    for (i = 0; attr[i]; i += 2) {
+	if (!strcmp (attr[i], "name")) /* not needed here */;
+	else if (!strcmp (attr[i], "executable")) exec = attr[i+1];
+	else XML_WARNING("unknown application attribute: %s.", attr[i]);
+    }
+    if (exec && strcmp (exec, data->execName))
+	data->ignoringApp = data->inApp;
+}
+
+/** \brief Parse attributes of an option element. */
+static void parseOptConfAttr (struct OptConfData *data, const XML_Char **attr) {
+    GLuint i;
+    const XML_Char *name = NULL, *value = NULL;
+    for (i = 0; attr[i]; i += 2) {
+	if (!strcmp (attr[i], "name")) name = attr[i+1];
+	else if (!strcmp (attr[i], "value")) value = attr[i+1];
+	else XML_WARNING("unknown option attribute: %s.", attr[i]);
+    }
+    if (!name) XML_WARNING1 ("name attribute missing in option.");
+    if (!value) XML_WARNING1 ("value attribute missing in option.");
+    if (name && value) {
+	driOptionCache *cache = data->cache;
+	GLuint opt = findOption (cache, name);
+	if (cache->info[opt].name == NULL)
+	    XML_WARNING ("undefined option: %s.", name);
+	else if (getenv (cache->info[opt].name))
+	  /* don't use XML_WARNING, we want the user to see this! */
+	    fprintf (stderr, "ATTENTION: option value of option %s ignored.\n",
+		     cache->info[opt].name);
+	else if (!parseValue (&cache->values[opt], cache->info[opt].type, value))
+	    XML_WARNING ("illegal option value: %s.", value);
+    }
+}
+
+/** \brief Handler for start element events. */
+static void optConfStartElem (void *userData, const XML_Char *name,
+			      const XML_Char **attr) {
+    struct OptConfData *data = (struct OptConfData *)userData;
+    enum OptConfElem elem = bsearchStr (name, OptConfElems, OC_COUNT);
+    switch (elem) {
+      case OC_DRICONF:
+	if (data->inDriConf)
+	    XML_WARNING1 ("nested <driconf> elements.");
+	if (attr[0])
+	    XML_WARNING1 ("attributes specified on <driconf> element.");
+	data->inDriConf++;
+	break;
+      case OC_DEVICE:
+	if (!data->inDriConf)
+	    XML_WARNING1 ("<device> should be inside <driconf>.");
+	if (data->inDevice)
+	    XML_WARNING1 ("nested <device> elements.");
+	data->inDevice++;
+	if (!data->ignoringDevice && !data->ignoringApp)
+	    parseDeviceAttr (data, attr);
+	break;
+      case OC_APPLICATION:
+	if (!data->inDevice)
+	    XML_WARNING1 ("<application> should be inside <device>.");
+	if (data->inApp)
+	    XML_WARNING1 ("nested <application> elements.");
+	data->inApp++;
+	if (!data->ignoringDevice && !data->ignoringApp)
+	    parseAppAttr (data, attr);
+	break;
+      case OC_OPTION:
+	if (!data->inApp)
+	    XML_WARNING1 ("<option> should be inside <application>.");
+	if (data->inOption)
+	    XML_WARNING1 ("nested <option> elements.");
+	data->inOption++;
+	if (!data->ignoringDevice && !data->ignoringApp)
+	    parseOptConfAttr (data, attr);
+	break;
+      default:
+	XML_WARNING ("unknown element: %s.", name);
+    }
+}
+
+/** \brief Handler for end element events. */
+static void optConfEndElem (void *userData, const XML_Char *name) {
+    struct OptConfData *data = (struct OptConfData *)userData;
+    enum OptConfElem elem = bsearchStr (name, OptConfElems, OC_COUNT);
+    switch (elem) {
+      case OC_DRICONF:
+	data->inDriConf--;
+	break;
+      case OC_DEVICE:
+	if (data->inDevice-- == data->ignoringDevice)
+	    data->ignoringDevice = 0;
+	break;
+      case OC_APPLICATION:
+	if (data->inApp-- == data->ignoringApp)
+	    data->ignoringApp = 0;
+	break;
+      case OC_OPTION:
+	data->inOption--;
+	break;
+      default:
+	/* unknown element, warning was produced on start tag */;
+    }
+}
+
+/** \brief Initialize an option cache based on info */
+static void initOptionCache (driOptionCache *cache, const driOptionCache *info) {
+    cache->info = info->info;
+    cache->tableSize = info->tableSize;
+    cache->values = MALLOC ((1<<info->tableSize) * sizeof (driOptionValue));
+    if (cache->values == NULL) {
+	fprintf (stderr, "%s: %d: out of memory.\n", __FILE__, __LINE__);
+	abort();
+    }
+    memcpy (cache->values, info->values,
+	    (1<<info->tableSize) * sizeof (driOptionValue));
+}
+
+/** \brief Parse the named configuration file */
+static void parseOneConfigFile (XML_Parser p) {
+#define BUF_SIZE 0x1000
+    struct OptConfData *data = (struct OptConfData *)XML_GetUserData (p);
+    int status;
+    int fd;
+
+    if ((fd = open (data->name, O_RDONLY)) == -1) {
+	__driUtilMessage ("Can't open configuration file %s: %s.",
+			  data->name, strerror (errno));
+	return;
+    }
+
+    while (1) {
+	int bytesRead;
+	void *buffer = XML_GetBuffer (p, BUF_SIZE);
+	if (!buffer) {
+	    __driUtilMessage ("Can't allocate parser buffer.");
+	    break;
+	}
+	bytesRead = read (fd, buffer, BUF_SIZE);
+	if (bytesRead == -1) {
+	    __driUtilMessage ("Error reading from configuration file %s: %s.",
+			      data->name, strerror (errno));
+	    break;
+	}
+	status = XML_ParseBuffer (p, bytesRead, bytesRead == 0);
+	if (!status) {
+	    XML_ERROR ("%s.", XML_ErrorString(XML_GetErrorCode(p)));
+	    break;
+	}
+	if (bytesRead == 0)
+	    break;
+    }
+
+    close (fd);
+#undef BUF_SIZE
+}
+
+void driParseConfigFiles (driOptionCache *cache, const driOptionCache *info,
+			  GLint screenNum, const char *driverName) {
+    char *filenames[2] = {"/etc/drirc", NULL};
+    char *home;
+    GLuint i;
+    struct OptConfData userData;
+
+    initOptionCache (cache, info);
+
+    userData.cache = cache;
+    userData.screenNum = screenNum;
+    userData.driverName = driverName;
+    userData.execName = GET_PROGRAM_NAME();
+
+    if ((home = getenv ("HOME"))) {
+	GLuint len = strlen (home);
+	filenames[1] = MALLOC (len + 7+1);
+	if (filenames[1] == NULL)
+	    __driUtilMessage ("Can't allocate memory for %s/.drirc.", home);
+	else {
+	    memcpy (filenames[1], home, len);
+	    memcpy (filenames[1] + len, "/.drirc", 7+1);
+	}
+    }
+
+    for (i = 0; i < 2; ++i) {
+	XML_Parser p;
+	if (filenames[i] == NULL)
+	    continue;
+
+	p = XML_ParserCreate (NULL); /* use encoding specified by file */
+	XML_SetElementHandler (p, optConfStartElem, optConfEndElem);
+	XML_SetUserData (p, &userData);
+	userData.parser = p;
+	userData.name = filenames[i];
+	userData.ignoringDevice = 0;
+	userData.ignoringApp = 0;
+	userData.inDriConf = 0;
+	userData.inDevice = 0;
+	userData.inApp = 0;
+	userData.inOption = 0;
+
+	parseOneConfigFile (p);
+	XML_ParserFree (p);
+    }
+
+    if (filenames[1])
+	FREE (filenames[1]);
+}
+
+void driDestroyOptionInfo (driOptionCache *info) {
+    driDestroyOptionCache (info);
+    if (info->info) {
+	GLuint i, size = 1 << info->tableSize;
+	for (i = 0; i < size; ++i) {
+	    if (info->info[i].name) {
+		FREE (info->info[i].name);
+		if (info->info[i].ranges)
+		    FREE (info->info[i].ranges);
+	    }
+	}
+	FREE (info->info);
+    }
+}
+
+void driDestroyOptionCache (driOptionCache *cache) {
+    if (cache->values)
+	FREE (cache->values);
+}
+
+GLboolean driCheckOption (const driOptionCache *cache, const char *name,
+			  driOptionType type) {
+    GLuint i = findOption (cache, name);
+    return cache->info[i].name != NULL && cache->info[i].type == type;
+}
+
+GLboolean driQueryOptionb (const driOptionCache *cache, const char *name) {
+    GLuint i = findOption (cache, name);
+  /* make sure the option is defined and has the correct type */
+    assert (cache->info[i].name != NULL);
+    assert (cache->info[i].type == DRI_BOOL);
+    return cache->values[i]._bool;
+}
+
+GLint driQueryOptioni (const driOptionCache *cache, const char *name) {
+    GLuint i = findOption (cache, name);
+  /* make sure the option is defined and has the correct type */
+    assert (cache->info[i].name != NULL);
+    assert (cache->info[i].type == DRI_INT || cache->info[i].type == DRI_ENUM);
+    return cache->values[i]._int;
+}
+
+GLfloat driQueryOptionf (const driOptionCache *cache, const char *name) {
+    GLuint i = findOption (cache, name);
+  /* make sure the option is defined and has the correct type */
+    assert (cache->info[i].name != NULL);
+    assert (cache->info[i].type == DRI_FLOAT);
+    return cache->values[i]._float;
+}
diff --git a/mesalib/src/mesa/main/dlist.c b/mesalib/src/mesa/main/dlist.c
index 958f5a697..f9282398c 100644
--- a/mesalib/src/mesa/main/dlist.c
+++ b/mesalib/src/mesa/main/dlist.c
@@ -7542,32 +7542,32 @@ execute_list(struct gl_context *ctx, GLuint list)
             break;
          case OPCODE_CLEAR_BUFFER_IV:
             {
-               GLint value[4];
+               /*GLint value[4];
                value[0] = n[3].i;
                value[1] = n[4].i;
                value[2] = n[5].i;
                value[3] = n[6].i;
-               /*CALL_ClearBufferiv(ctx->Exec, (n[1].e, n[2].i, value));*/
+               CALL_ClearBufferiv(ctx->Exec, (n[1].e, n[2].i, value));*/
             }
             break;
          case OPCODE_CLEAR_BUFFER_UIV:
             {
-               GLuint value[4];
+               /*GLuint value[4];
                value[0] = n[3].ui;
                value[1] = n[4].ui;
                value[2] = n[5].ui;
                value[3] = n[6].ui;
-               /*CALL_ClearBufferiv(ctx->Exec, (n[1].e, n[2].i, value));*/
+               CALL_ClearBufferiv(ctx->Exec, (n[1].e, n[2].i, value));*/
             }
             break;
          case OPCODE_CLEAR_BUFFER_FV:
             {
-               GLfloat value[4];
+               /*GLfloat value[4];
                value[0] = n[3].f;
                value[1] = n[4].f;
                value[2] = n[5].f;
                value[3] = n[6].f;
-               /*CALL_ClearBufferfv(ctx->Exec, (n[1].e, n[2].i, value));*/
+               CALL_ClearBufferfv(ctx->Exec, (n[1].e, n[2].i, value));*/
             }
             break;
          case OPCODE_CLEAR_BUFFER_FI:
diff --git a/mesalib/src/mesa/program/prog_optimize.c b/mesalib/src/mesa/program/prog_optimize.c
index 11debc485..8a40fa69e 100644
--- a/mesalib/src/mesa/program/prog_optimize.c
+++ b/mesalib/src/mesa/program/prog_optimize.c
@@ -1304,6 +1304,9 @@ _mesa_simplify_cmp(struct gl_program * program)
          assert(inst->DstReg.Index < REG_ALLOCATE_MAX_PROGRAM_TEMPS);
          prevWriteMask = tempWrites[inst->DstReg.Index];
          tempWrites[inst->DstReg.Index] |= inst->DstReg.WriteMask;
+      } else {
+         /* No other register type can be a destination register. */
+         continue;
       }
 
       /* For a CMP to be considered a conditional write, the destination
diff --git a/mesalib/src/mesa/state_tracker/st_program.c b/mesalib/src/mesa/state_tracker/st_program.c
index 7a6d33d3f..132ebdbad 100644
--- a/mesalib/src/mesa/state_tracker/st_program.c
+++ b/mesalib/src/mesa/state_tracker/st_program.c
@@ -449,7 +449,6 @@ st_translate_fragment_program(struct st_context *st,
       GLuint inputMapping[FRAG_ATTRIB_MAX];
       GLuint interpMode[PIPE_MAX_SHADER_INPUTS];  /* XXX size? */
       GLuint attr;
-      enum pipe_error error;
       const GLbitfield inputsRead = stfp->Base.Base.InputsRead;
       struct ureg_program *ureg;
       GLboolean write_all = GL_FALSE;
@@ -606,21 +605,21 @@ st_translate_fragment_program(struct st_context *st,
       if (write_all == GL_TRUE)
          ureg_property_fs_color0_writes_all_cbufs(ureg, 1);
 
-      error = st_translate_mesa_program(st->ctx,
-                                        TGSI_PROCESSOR_FRAGMENT,
-                                        ureg,
-                                        &stfp->Base.Base,
-                                        /* inputs */
-                                        fs_num_inputs,
-                                        inputMapping,
-                                        input_semantic_name,
-                                        input_semantic_index,
-                                        interpMode,
-                                        /* outputs */
-                                        fs_num_outputs,
-                                        outputMapping,
-                                        fs_output_semantic_name,
-                                        fs_output_semantic_index, FALSE );
+      st_translate_mesa_program(st->ctx,
+                                TGSI_PROCESSOR_FRAGMENT,
+                                ureg,
+                                &stfp->Base.Base,
+                                /* inputs */
+                                fs_num_inputs,
+                                inputMapping,
+                                input_semantic_name,
+                                input_semantic_index,
+                                interpMode,
+                                /* outputs */
+                                fs_num_outputs,
+                                outputMapping,
+                                fs_output_semantic_name,
+                                fs_output_semantic_index, FALSE );
 
       stfp->tgsi.tokens = ureg_get_tokens( ureg, NULL );
       ureg_destroy( ureg );
@@ -687,7 +686,6 @@ st_translate_geometry_program(struct st_context *st,
    GLuint inputMapping[GEOM_ATTRIB_MAX];
    GLuint outputMapping[GEOM_RESULT_MAX];
    struct pipe_context *pipe = st->pipe;
-   enum pipe_error error;
    GLuint attr;
    const GLbitfield inputsRead = stgp->Base.Base.InputsRead;
    GLuint vslot = 0;
@@ -894,22 +892,22 @@ st_translate_geometry_program(struct st_context *st,
    ureg_property_gs_output_prim(ureg, stgp->Base.OutputType);
    ureg_property_gs_max_vertices(ureg, stgp->Base.VerticesOut);
 
-   error = st_translate_mesa_program(st->ctx,
-                                     TGSI_PROCESSOR_GEOMETRY,
-                                     ureg,
-                                     &stgp->Base.Base,
-                                     /* inputs */
-                                     gs_num_inputs,
-                                     inputMapping,
-                                     stgp->input_semantic_name,
-                                     stgp->input_semantic_index,
-                                     NULL,
-                                     /* outputs */
-                                     gs_num_outputs,
-                                     outputMapping,
-                                     gs_output_semantic_name,
-                                     gs_output_semantic_index,
-                                     FALSE);
+   st_translate_mesa_program(st->ctx,
+                             TGSI_PROCESSOR_GEOMETRY,
+                             ureg,
+                             &stgp->Base.Base,
+                             /* inputs */
+                             gs_num_inputs,
+                             inputMapping,
+                             stgp->input_semantic_name,
+                             stgp->input_semantic_index,
+                             NULL,
+                             /* outputs */
+                             gs_num_outputs,
+                             outputMapping,
+                             gs_output_semantic_name,
+                             gs_output_semantic_index,
+                             FALSE);
 
    stgp->num_inputs = gs_num_inputs;
    stgp->tgsi.tokens = ureg_get_tokens( ureg, NULL );
diff --git a/mesalib/src/mesa/swrast/s_span.c b/mesalib/src/mesa/swrast/s_span.c
index 7f88b6dd4..db102ac79 100644
--- a/mesalib/src/mesa/swrast/s_span.c
+++ b/mesalib/src/mesa/swrast/s_span.c
@@ -1,1516 +1,1505 @@
-/*

- * Mesa 3-D graphics library

- * Version:  7.5

- *

- * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.

- * Copyright (C) 2009  VMware, Inc.  All Rights Reserved.

- *

- * Permission is hereby granted, free of charge, to any person obtaining a

- * copy of this software and associated documentation files (the "Software"),

- * to deal in the Software without restriction, including without limitation

- * the rights to use, copy, modify, merge, publish, distribute, sublicense,

- * and/or sell copies of the Software, and to permit persons to whom the

- * Software is furnished to do so, subject to the following conditions:

- *

- * The above copyright notice and this permission notice shall be included

- * in all copies or substantial portions of the Software.

- *

- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL

- * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN

- * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

- */

-

-

-/**

- * \file swrast/s_span.c

- * \brief Span processing functions used by all rasterization functions.

- * This is where all the per-fragment tests are performed

- * \author Brian Paul

- */

-

-#include "main/glheader.h"

-#include "main/colormac.h"

-#include "main/macros.h"

-#include "main/imports.h"

-#include "main/image.h"

-

-#include "s_atifragshader.h"

-#include "s_alpha.h"

-#include "s_blend.h"

-#include "s_context.h"

-#include "s_depth.h"

-#include "s_fog.h"

-#include "s_logic.h"

-#include "s_masking.h"

-#include "s_fragprog.h"

-#include "s_span.h"

-#include "s_stencil.h"

-#include "s_texcombine.h"

-

-

-/**

- * Set default fragment attributes for the span using the

- * current raster values.  Used prior to glDraw/CopyPixels

- * and glBitmap.

- */

-void

-_swrast_span_default_attribs(struct gl_context *ctx, SWspan *span)

-{

-   GLchan r, g, b, a;

-   /* Z*/

-   {

-      const GLfloat depthMax = ctx->DrawBuffer->_DepthMaxF;

-      if (ctx->DrawBuffer->Visual.depthBits <= 16)

-         span->z = FloatToFixed(ctx->Current.RasterPos[2] * depthMax + 0.5F);

-      else {

-         GLfloat tmpf = ctx->Current.RasterPos[2] * depthMax; 

-         tmpf = MIN2(tmpf, depthMax);

-         span->z = (GLint)tmpf;

-      }

-      span->zStep = 0;

-      span->interpMask |= SPAN_Z;

-   }

-

-   /* W (for perspective correction) */

-   span->attrStart[FRAG_ATTRIB_WPOS][3] = 1.0;

-   span->attrStepX[FRAG_ATTRIB_WPOS][3] = 0.0;

-   span->attrStepY[FRAG_ATTRIB_WPOS][3] = 0.0;

-

-   /* primary color, or color index */

-   UNCLAMPED_FLOAT_TO_CHAN(r, ctx->Current.RasterColor[0]);

-   UNCLAMPED_FLOAT_TO_CHAN(g, ctx->Current.RasterColor[1]);

-   UNCLAMPED_FLOAT_TO_CHAN(b, ctx->Current.RasterColor[2]);

-   UNCLAMPED_FLOAT_TO_CHAN(a, ctx->Current.RasterColor[3]);

-#if CHAN_TYPE == GL_FLOAT

-   span->red = r;

-   span->green = g;

-   span->blue = b;

-   span->alpha = a;

-#else

-   span->red   = IntToFixed(r);

-   span->green = IntToFixed(g);

-   span->blue  = IntToFixed(b);

-   span->alpha = IntToFixed(a);

-#endif

-   span->redStep = 0;

-   span->greenStep = 0;

-   span->blueStep = 0;

-   span->alphaStep = 0;

-   span->interpMask |= SPAN_RGBA;

-

-   COPY_4V(span->attrStart[FRAG_ATTRIB_COL0], ctx->Current.RasterColor);

-   ASSIGN_4V(span->attrStepX[FRAG_ATTRIB_COL0], 0.0, 0.0, 0.0, 0.0);

-   ASSIGN_4V(span->attrStepY[FRAG_ATTRIB_COL0], 0.0, 0.0, 0.0, 0.0);

-

-   /* Secondary color */

-   if (ctx->Light.Enabled || ctx->Fog.ColorSumEnabled)

-   {

-      COPY_4V(span->attrStart[FRAG_ATTRIB_COL1], ctx->Current.RasterSecondaryColor);

-      ASSIGN_4V(span->attrStepX[FRAG_ATTRIB_COL1], 0.0, 0.0, 0.0, 0.0);

-      ASSIGN_4V(span->attrStepY[FRAG_ATTRIB_COL1], 0.0, 0.0, 0.0, 0.0);

-   }

-

-   /* fog */

-   {

-      const SWcontext *swrast = SWRAST_CONTEXT(ctx);

-      GLfloat fogVal; /* a coord or a blend factor */

-      if (swrast->_PreferPixelFog) {

-         /* fog blend factors will be computed from fog coordinates per pixel */

-         fogVal = ctx->Current.RasterDistance;

-      }

-      else {

-         /* fog blend factor should be computed from fogcoord now */

-         fogVal = _swrast_z_to_fogfactor(ctx, ctx->Current.RasterDistance);

-      }

-      span->attrStart[FRAG_ATTRIB_FOGC][0] = fogVal;

-      span->attrStepX[FRAG_ATTRIB_FOGC][0] = 0.0;

-      span->attrStepY[FRAG_ATTRIB_FOGC][0] = 0.0;

-   }

-

-   /* texcoords */

-   {

-      GLuint i;

-      for (i = 0; i < ctx->Const.MaxTextureCoordUnits; i++) {

-         const GLuint attr = FRAG_ATTRIB_TEX0 + i;

-         const GLfloat *tc = ctx->Current.RasterTexCoords[i];

-         if (ctx->FragmentProgram._Current || ctx->ATIFragmentShader._Enabled) {

-            COPY_4V(span->attrStart[attr], tc);

-         }

-         else if (tc[3] > 0.0F) {

-            /* use (s/q, t/q, r/q, 1) */

-            span->attrStart[attr][0] = tc[0] / tc[3];

-            span->attrStart[attr][1] = tc[1] / tc[3];

-            span->attrStart[attr][2] = tc[2] / tc[3];

-            span->attrStart[attr][3] = 1.0;

-         }

-         else {

-            ASSIGN_4V(span->attrStart[attr], 0.0F, 0.0F, 0.0F, 1.0F);

-         }

-         ASSIGN_4V(span->attrStepX[attr], 0.0F, 0.0F, 0.0F, 0.0F);

-         ASSIGN_4V(span->attrStepY[attr], 0.0F, 0.0F, 0.0F, 0.0F);

-      }

-   }

-}

-

-

-/**

- * Interpolate the active attributes (and'd with attrMask) to

- * fill in span->array->attribs[].

- * Perspective correction will be done.  The point/line/triangle function

- * should have computed attrStart/Step values for FRAG_ATTRIB_WPOS[3]!

- */

-static INLINE void

-interpolate_active_attribs(struct gl_context *ctx, SWspan *span, GLbitfield attrMask)

-{

-   const SWcontext *swrast = SWRAST_CONTEXT(ctx);

-

-   /*

-    * Don't overwrite existing array values, such as colors that may have

-    * been produced by glDraw/CopyPixels.

-    */

-   attrMask &= ~span->arrayAttribs;

-

-   ATTRIB_LOOP_BEGIN

-      if (attrMask & (1 << attr)) {

-         const GLfloat dwdx = span->attrStepX[FRAG_ATTRIB_WPOS][3];

-         GLfloat w = span->attrStart[FRAG_ATTRIB_WPOS][3];

-         const GLfloat dv0dx = span->attrStepX[attr][0];

-         const GLfloat dv1dx = span->attrStepX[attr][1];

-         const GLfloat dv2dx = span->attrStepX[attr][2];

-         const GLfloat dv3dx = span->attrStepX[attr][3];

-         GLfloat v0 = span->attrStart[attr][0] + span->leftClip * dv0dx;

-         GLfloat v1 = span->attrStart[attr][1] + span->leftClip * dv1dx;

-         GLfloat v2 = span->attrStart[attr][2] + span->leftClip * dv2dx;

-         GLfloat v3 = span->attrStart[attr][3] + span->leftClip * dv3dx;

-         GLuint k;

-         for (k = 0; k < span->end; k++) {

-            const GLfloat invW = 1.0f / w;

-            span->array->attribs[attr][k][0] = v0 * invW;

-            span->array->attribs[attr][k][1] = v1 * invW;

-            span->array->attribs[attr][k][2] = v2 * invW;

-            span->array->attribs[attr][k][3] = v3 * invW;

-            v0 += dv0dx;

-            v1 += dv1dx;

-            v2 += dv2dx;

-            v3 += dv3dx;

-            w += dwdx;

-         }

-         ASSERT((span->arrayAttribs & (1 << attr)) == 0);

-         span->arrayAttribs |= (1 << attr);

-      }

-   ATTRIB_LOOP_END

-}

-

-

-/**

- * Interpolate primary colors to fill in the span->array->rgba8 (or rgb16)

- * color array.

- */

-static INLINE void

-interpolate_int_colors(struct gl_context *ctx, SWspan *span)

-{

-   const GLuint n = span->end;

-   GLuint i;

-

-#if CHAN_BITS != 32

-   ASSERT(!(span->arrayMask & SPAN_RGBA));

-#endif

-

-   switch (span->array->ChanType) {

-#if CHAN_BITS != 32

-   case GL_UNSIGNED_BYTE:

-      {

-         GLubyte (*rgba)[4] = span->array->rgba8;

-         if (span->interpMask & SPAN_FLAT) {

-            GLubyte color[4];

-            color[RCOMP] = FixedToInt(span->red);

-            color[GCOMP] = FixedToInt(span->green);

-            color[BCOMP] = FixedToInt(span->blue);

-            color[ACOMP] = FixedToInt(span->alpha);

-            for (i = 0; i < n; i++) {

-               COPY_4UBV(rgba[i], color);

-            }

-         }

-         else {

-            GLfixed r = span->red;

-            GLfixed g = span->green;

-            GLfixed b = span->blue;

-            GLfixed a = span->alpha;

-            GLint dr = span->redStep;

-            GLint dg = span->greenStep;

-            GLint db = span->blueStep;

-            GLint da = span->alphaStep;

-            for (i = 0; i < n; i++) {

-               rgba[i][RCOMP] = FixedToChan(r);

-               rgba[i][GCOMP] = FixedToChan(g);

-               rgba[i][BCOMP] = FixedToChan(b);

-               rgba[i][ACOMP] = FixedToChan(a);

-               r += dr;

-               g += dg;

-               b += db;

-               a += da;

-            }

-         }

-      }

-      break;

-   case GL_UNSIGNED_SHORT:

-      {

-         GLushort (*rgba)[4] = span->array->rgba16;

-         if (span->interpMask & SPAN_FLAT) {

-            GLushort color[4];

-            color[RCOMP] = FixedToInt(span->red);

-            color[GCOMP] = FixedToInt(span->green);

-            color[BCOMP] = FixedToInt(span->blue);

-            color[ACOMP] = FixedToInt(span->alpha);

-            for (i = 0; i < n; i++) {

-               COPY_4V(rgba[i], color);

-            }

-         }

-         else {

-            GLushort (*rgba)[4] = span->array->rgba16;

-            GLfixed r, g, b, a;

-            GLint dr, dg, db, da;

-            r = span->red;

-            g = span->green;

-            b = span->blue;

-            a = span->alpha;

-            dr = span->redStep;

-            dg = span->greenStep;

-            db = span->blueStep;

-            da = span->alphaStep;

-            for (i = 0; i < n; i++) {

-               rgba[i][RCOMP] = FixedToChan(r);

-               rgba[i][GCOMP] = FixedToChan(g);

-               rgba[i][BCOMP] = FixedToChan(b);

-               rgba[i][ACOMP] = FixedToChan(a);

-               r += dr;

-               g += dg;

-               b += db;

-               a += da;

-            }

-         }

-      }

-      break;

-#endif

-   case GL_FLOAT:

-      interpolate_active_attribs(ctx, span, FRAG_BIT_COL0);

-      break;

-   default:

-      _mesa_problem(ctx, "bad datatype 0x%x in interpolate_int_colors",

-                    span->array->ChanType);

-   }

-   span->arrayMask |= SPAN_RGBA;

-}

-

-

-/**

- * Populate the FRAG_ATTRIB_COL0 array.

- */

-static INLINE void

-interpolate_float_colors(SWspan *span)

-{

-   GLfloat (*col0)[4] = span->array->attribs[FRAG_ATTRIB_COL0];

-   const GLuint n = span->end;

-   GLuint i;

-

-   assert(!(span->arrayAttribs & FRAG_BIT_COL0));

-

-   if (span->arrayMask & SPAN_RGBA) {

-      /* convert array of int colors */

-      for (i = 0; i < n; i++) {

-         col0[i][0] = UBYTE_TO_FLOAT(span->array->rgba8[i][0]);

-         col0[i][1] = UBYTE_TO_FLOAT(span->array->rgba8[i][1]);

-         col0[i][2] = UBYTE_TO_FLOAT(span->array->rgba8[i][2]);

-         col0[i][3] = UBYTE_TO_FLOAT(span->array->rgba8[i][3]);

-      }

-   }

-   else {

-      /* interpolate red/green/blue/alpha to get float colors */

-      ASSERT(span->interpMask & SPAN_RGBA);

-      if (span->interpMask & SPAN_FLAT) {

-         GLfloat r = FixedToFloat(span->red);

-         GLfloat g = FixedToFloat(span->green);

-         GLfloat b = FixedToFloat(span->blue);

-         GLfloat a = FixedToFloat(span->alpha);

-         for (i = 0; i < n; i++) {

-            ASSIGN_4V(col0[i], r, g, b, a);

-         }

-      }

-      else {

-         GLfloat r = FixedToFloat(span->red);

-         GLfloat g = FixedToFloat(span->green);

-         GLfloat b = FixedToFloat(span->blue);

-         GLfloat a = FixedToFloat(span->alpha);

-         GLfloat dr = FixedToFloat(span->redStep);

-         GLfloat dg = FixedToFloat(span->greenStep);

-         GLfloat db = FixedToFloat(span->blueStep);

-         GLfloat da = FixedToFloat(span->alphaStep);

-         for (i = 0; i < n; i++) {

-            col0[i][0] = r;

-            col0[i][1] = g;

-            col0[i][2] = b;

-            col0[i][3] = a;

-            r += dr;

-            g += dg;

-            b += db;

-            a += da;

-         }

-      }

-   }

-

-   span->arrayAttribs |= FRAG_BIT_COL0;

-   span->array->ChanType = GL_FLOAT;

-}

-

-

-

-/**

- * Fill in the span.zArray array from the span->z, zStep values.

- */

-void

-_swrast_span_interpolate_z( const struct gl_context *ctx, SWspan *span )

-{

-   const GLuint n = span->end;

-   GLuint i;

-

-   ASSERT(!(span->arrayMask & SPAN_Z));

-

-   if (ctx->DrawBuffer->Visual.depthBits <= 16) {

-      GLfixed zval = span->z;

-      GLuint *z = span->array->z; 

-      for (i = 0; i < n; i++) {

-         z[i] = FixedToInt(zval);

-         zval += span->zStep;

-      }

-   }

-   else {

-      /* Deep Z buffer, no fixed->int shift */

-      GLuint zval = span->z;

-      GLuint *z = span->array->z;

-      for (i = 0; i < n; i++) {

-         z[i] = zval;

-         zval += span->zStep;

-      }

-   }

-   span->interpMask &= ~SPAN_Z;

-   span->arrayMask |= SPAN_Z;

-}

-

-

-/**

- * Compute mipmap LOD from partial derivatives.

- * This the ideal solution, as given in the OpenGL spec.

- */

-GLfloat

-_swrast_compute_lambda(GLfloat dsdx, GLfloat dsdy, GLfloat dtdx, GLfloat dtdy,

-                       GLfloat dqdx, GLfloat dqdy, GLfloat texW, GLfloat texH,

-                       GLfloat s, GLfloat t, GLfloat q, GLfloat invQ)

-{

-   GLfloat dudx = texW * ((s + dsdx) / (q + dqdx) - s * invQ);

-   GLfloat dvdx = texH * ((t + dtdx) / (q + dqdx) - t * invQ);

-   GLfloat dudy = texW * ((s + dsdy) / (q + dqdy) - s * invQ);

-   GLfloat dvdy = texH * ((t + dtdy) / (q + dqdy) - t * invQ);

-   GLfloat x = SQRTF(dudx * dudx + dvdx * dvdx);

-   GLfloat y = SQRTF(dudy * dudy + dvdy * dvdy);

-   GLfloat rho = MAX2(x, y);

-   GLfloat lambda = LOG2(rho);

-   return lambda;

-}

-

-

-/**

- * Compute mipmap LOD from partial derivatives.

- * This is a faster approximation than above function.

- */

-#if 0

-GLfloat

-_swrast_compute_lambda(GLfloat dsdx, GLfloat dsdy, GLfloat dtdx, GLfloat dtdy,

-                     GLfloat dqdx, GLfloat dqdy, GLfloat texW, GLfloat texH,

-                     GLfloat s, GLfloat t, GLfloat q, GLfloat invQ)

-{

-   GLfloat dsdx2 = (s + dsdx) / (q + dqdx) - s * invQ;

-   GLfloat dtdx2 = (t + dtdx) / (q + dqdx) - t * invQ;

-   GLfloat dsdy2 = (s + dsdy) / (q + dqdy) - s * invQ;

-   GLfloat dtdy2 = (t + dtdy) / (q + dqdy) - t * invQ;

-   GLfloat maxU, maxV, rho, lambda;

-   dsdx2 = FABSF(dsdx2);

-   dsdy2 = FABSF(dsdy2);

-   dtdx2 = FABSF(dtdx2);

-   dtdy2 = FABSF(dtdy2);

-   maxU = MAX2(dsdx2, dsdy2) * texW;

-   maxV = MAX2(dtdx2, dtdy2) * texH;

-   rho = MAX2(maxU, maxV);

-   lambda = LOG2(rho);

-   return lambda;

-}

-#endif

-

-

-/**

- * Fill in the span.array->attrib[FRAG_ATTRIB_TEXn] arrays from the

- * using the attrStart/Step values.

- *

- * This function only used during fixed-function fragment processing.

- *

- * Note: in the places where we divide by Q (or mult by invQ) we're

- * really doing two things: perspective correction and texcoord

- * projection.  Remember, for texcoord (s,t,r,q) we need to index

- * texels with (s/q, t/q, r/q).

- */

-static void

-interpolate_texcoords(struct gl_context *ctx, SWspan *span)

-{

-   const GLuint maxUnit

-      = (ctx->Texture._EnabledCoordUnits > 1) ? ctx->Const.MaxTextureUnits : 1;

-   GLuint u;

-

-   /* XXX CoordUnits vs. ImageUnits */

-   for (u = 0; u < maxUnit; u++) {

-      if (ctx->Texture._EnabledCoordUnits & (1 << u)) {

-         const GLuint attr = FRAG_ATTRIB_TEX0 + u;

-         const struct gl_texture_object *obj = ctx->Texture.Unit[u]._Current;

-         GLfloat texW, texH;

-         GLboolean needLambda;

-         GLfloat (*texcoord)[4] = span->array->attribs[attr];

-         GLfloat *lambda = span->array->lambda[u];

-         const GLfloat dsdx = span->attrStepX[attr][0];

-         const GLfloat dsdy = span->attrStepY[attr][0];

-         const GLfloat dtdx = span->attrStepX[attr][1];

-         const GLfloat dtdy = span->attrStepY[attr][1];

-         const GLfloat drdx = span->attrStepX[attr][2];

-         const GLfloat dqdx = span->attrStepX[attr][3];

-         const GLfloat dqdy = span->attrStepY[attr][3];

-         GLfloat s = span->attrStart[attr][0] + span->leftClip * dsdx;

-         GLfloat t = span->attrStart[attr][1] + span->leftClip * dtdx;

-         GLfloat r = span->attrStart[attr][2] + span->leftClip * drdx;

-         GLfloat q = span->attrStart[attr][3] + span->leftClip * dqdx;

-

-         if (obj) {

-            const struct gl_texture_image *img = obj->Image[0][obj->BaseLevel];

-            needLambda = (obj->Sampler.MinFilter != obj->Sampler.MagFilter)

-               || ctx->FragmentProgram._Current;

-            /* LOD is calculated directly in the ansiotropic filter, we can

-             * skip the normal lambda function as the result is ignored.

-             */

-            if (obj->Sampler.MaxAnisotropy > 1.0 &&

-                obj->Sampler.MinFilter == GL_LINEAR_MIPMAP_LINEAR) {

-               needLambda = GL_FALSE;

-            }

-            texW = img->WidthScale;

-            texH = img->HeightScale;

-         }

-         else {

-            /* using a fragment program */

-            texW = 1.0;

-            texH = 1.0;

-            needLambda = GL_FALSE;

-         }

-

-         if (needLambda) {

-            GLuint i;

-            if (ctx->FragmentProgram._Current

-                || ctx->ATIFragmentShader._Enabled) {

-               /* do perspective correction but don't divide s, t, r by q */

-               const GLfloat dwdx = span->attrStepX[FRAG_ATTRIB_WPOS][3];

-               GLfloat w = span->attrStart[FRAG_ATTRIB_WPOS][3] + span->leftClip * dwdx;

-               for (i = 0; i < span->end; i++) {

-                  const GLfloat invW = 1.0F / w;

-                  texcoord[i][0] = s * invW;

-                  texcoord[i][1] = t * invW;

-                  texcoord[i][2] = r * invW;

-                  texcoord[i][3] = q * invW;

-                  lambda[i] = _swrast_compute_lambda(dsdx, dsdy, dtdx, dtdy,

-                                                     dqdx, dqdy, texW, texH,

-                                                     s, t, q, invW);

-                  s += dsdx;

-                  t += dtdx;

-                  r += drdx;

-                  q += dqdx;

-                  w += dwdx;

-               }

-            }

-            else {

-               for (i = 0; i < span->end; i++) {

-                  const GLfloat invQ = (q == 0.0F) ? 1.0F : (1.0F / q);

-                  texcoord[i][0] = s * invQ;

-                  texcoord[i][1] = t * invQ;

-                  texcoord[i][2] = r * invQ;

-                  texcoord[i][3] = q;

-                  lambda[i] = _swrast_compute_lambda(dsdx, dsdy, dtdx, dtdy,

-                                                     dqdx, dqdy, texW, texH,

-                                                     s, t, q, invQ);

-                  s += dsdx;

-                  t += dtdx;

-                  r += drdx;

-                  q += dqdx;

-               }

-            }

-            span->arrayMask |= SPAN_LAMBDA;

-         }

-         else {

-            GLuint i;

-            if (ctx->FragmentProgram._Current ||

-                ctx->ATIFragmentShader._Enabled) {

-               /* do perspective correction but don't divide s, t, r by q */

-               const GLfloat dwdx = span->attrStepX[FRAG_ATTRIB_WPOS][3];

-               GLfloat w = span->attrStart[FRAG_ATTRIB_WPOS][3] + span->leftClip * dwdx;

-               for (i = 0; i < span->end; i++) {

-                  const GLfloat invW = 1.0F / w;

-                  texcoord[i][0] = s * invW;

-                  texcoord[i][1] = t * invW;

-                  texcoord[i][2] = r * invW;

-                  texcoord[i][3] = q * invW;

-                  lambda[i] = 0.0;

-                  s += dsdx;

-                  t += dtdx;

-                  r += drdx;

-                  q += dqdx;

-                  w += dwdx;

-               }

-            }

-            else if (dqdx == 0.0F) {

-               /* Ortho projection or polygon's parallel to window X axis */

-               const GLfloat invQ = (q == 0.0F) ? 1.0F : (1.0F / q);

-               for (i = 0; i < span->end; i++) {

-                  texcoord[i][0] = s * invQ;

-                  texcoord[i][1] = t * invQ;

-                  texcoord[i][2] = r * invQ;

-                  texcoord[i][3] = q;

-                  lambda[i] = 0.0;

-                  s += dsdx;

-                  t += dtdx;

-                  r += drdx;

-               }

-            }

-            else {

-               for (i = 0; i < span->end; i++) {

-                  const GLfloat invQ = (q == 0.0F) ? 1.0F : (1.0F / q);

-                  texcoord[i][0] = s * invQ;

-                  texcoord[i][1] = t * invQ;

-                  texcoord[i][2] = r * invQ;

-                  texcoord[i][3] = q;

-                  lambda[i] = 0.0;

-                  s += dsdx;

-                  t += dtdx;

-                  r += drdx;

-                  q += dqdx;

-               }

-            }

-         } /* lambda */

-      } /* if */

-   } /* for */

-}

-

-

-/**

- * Fill in the arrays->attribs[FRAG_ATTRIB_WPOS] array.

- */

-static INLINE void

-interpolate_wpos(struct gl_context *ctx, SWspan *span)

-{

-   GLfloat (*wpos)[4] = span->array->attribs[FRAG_ATTRIB_WPOS];

-   GLuint i;

-   const GLfloat zScale = 1.0F / ctx->DrawBuffer->_DepthMaxF;

-   GLfloat w, dw;

-

-   if (span->arrayMask & SPAN_XY) {

-      for (i = 0; i < span->end; i++) {

-         wpos[i][0] = (GLfloat) span->array->x[i];

-         wpos[i][1] = (GLfloat) span->array->y[i];

-      }

-   }

-   else {

-      for (i = 0; i < span->end; i++) {

-         wpos[i][0] = (GLfloat) span->x + i;

-         wpos[i][1] = (GLfloat) span->y;

-      }

-   }

-

-   dw = span->attrStepX[FRAG_ATTRIB_WPOS][3];

-   w = span->attrStart[FRAG_ATTRIB_WPOS][3] + span->leftClip * dw;

-   for (i = 0; i < span->end; i++) {

-      wpos[i][2] = (GLfloat) span->array->z[i] * zScale;

-      wpos[i][3] = w;

-      w += dw;

-   }

-}

-

-

-/**

- * Apply the current polygon stipple pattern to a span of pixels.

- */

-static INLINE void

-stipple_polygon_span(struct gl_context *ctx, SWspan *span)

-{

-   GLubyte *mask = span->array->mask;

-

-   ASSERT(ctx->Polygon.StippleFlag);

-

-   if (span->arrayMask & SPAN_XY) {

-      /* arrays of x/y pixel coords */

-      GLuint i;

-      for (i = 0; i < span->end; i++) {

-         const GLint col = span->array->x[i] % 32;

-         const GLint row = span->array->y[i] % 32;

-         const GLuint stipple = ctx->PolygonStipple[row];

-         if (((1 << col) & stipple) == 0) {

-            mask[i] = 0;

-         }

-      }

-   }

-   else {

-      /* horizontal span of pixels */

-      const GLuint highBit = 1 << 31;

-      const GLuint stipple = ctx->PolygonStipple[span->y % 32];

-      GLuint i, m = highBit >> (GLuint) (span->x % 32);

-      for (i = 0; i < span->end; i++) {

-         if ((m & stipple) == 0) {

-            mask[i] = 0;

-         }

-         m = m >> 1;

-         if (m == 0) {

-            m = highBit;

-         }

-      }

-   }

-   span->writeAll = GL_FALSE;

-}

-

-

-/**

- * Clip a pixel span to the current buffer/window boundaries:

- * DrawBuffer->_Xmin, _Xmax, _Ymin, _Ymax.  This will accomplish

- * window clipping and scissoring.

- * Return:   GL_TRUE   some pixels still visible

- *           GL_FALSE  nothing visible

- */

-static INLINE GLuint

-clip_span( struct gl_context *ctx, SWspan *span )

-{

-   const GLint xmin = ctx->DrawBuffer->_Xmin;

-   const GLint xmax = ctx->DrawBuffer->_Xmax;

-   const GLint ymin = ctx->DrawBuffer->_Ymin;

-   const GLint ymax = ctx->DrawBuffer->_Ymax;

-

-   span->leftClip = 0;

-

-   if (span->arrayMask & SPAN_XY) {

-      /* arrays of x/y pixel coords */

-      const GLint *x = span->array->x;

-      const GLint *y = span->array->y;

-      const GLint n = span->end;

-      GLubyte *mask = span->array->mask;

-      GLint i;

-      if (span->arrayMask & SPAN_MASK) {

-         /* note: using & intead of && to reduce branches */

-         for (i = 0; i < n; i++) {

-            mask[i] &= (x[i] >= xmin) & (x[i] < xmax)

-                     & (y[i] >= ymin) & (y[i] < ymax);

-         }

-      }

-      else {

-         /* note: using & intead of && to reduce branches */

-         for (i = 0; i < n; i++) {

-            mask[i] = (x[i] >= xmin) & (x[i] < xmax)

-                    & (y[i] >= ymin) & (y[i] < ymax);

-         }

-      }

-      return GL_TRUE;  /* some pixels visible */

-   }

-   else {

-      /* horizontal span of pixels */

-      const GLint x = span->x;

-      const GLint y = span->y;

-      GLint n = span->end;

-

-      /* Trivial rejection tests */

-      if (y < ymin || y >= ymax || x + n <= xmin || x >= xmax) {

-         span->end = 0;

-         return GL_FALSE;  /* all pixels clipped */

-      }

-

-      /* Clip to right */

-      if (x + n > xmax) {

-         ASSERT(x < xmax);

-         n = span->end = xmax - x;

-      }

-

-      /* Clip to the left */

-      if (x < xmin) {

-         const GLint leftClip = xmin - x;

-         GLuint i;

-

-         ASSERT(leftClip > 0);

-         ASSERT(x + n > xmin);

-

-         /* Clip 'leftClip' pixels from the left side.

-          * The span->leftClip field will be applied when we interpolate

-          * fragment attributes.

-          * For arrays of values, shift them left.

-          */

-         for (i = 0; i < FRAG_ATTRIB_MAX; i++) {

-            if (span->interpMask & (1 << i)) {

-               GLuint j;

-               for (j = 0; j < 4; j++) {

-                  span->attrStart[i][j] += leftClip * span->attrStepX[i][j];

-               }

-            }

-         }

-

-         span->red += leftClip * span->redStep;

-         span->green += leftClip * span->greenStep;

-         span->blue += leftClip * span->blueStep;

-         span->alpha += leftClip * span->alphaStep;

-         span->index += leftClip * span->indexStep;

-         span->z += leftClip * span->zStep;

-         span->intTex[0] += leftClip * span->intTexStep[0];

-         span->intTex[1] += leftClip * span->intTexStep[1];

-

-#define SHIFT_ARRAY(ARRAY, SHIFT, LEN) \

-         memcpy(ARRAY, ARRAY + (SHIFT), (LEN) * sizeof(ARRAY[0]))

-

-         for (i = 0; i < FRAG_ATTRIB_MAX; i++) {

-            if (span->arrayAttribs & (1 << i)) {

-               /* shift array elements left by 'leftClip' */

-               SHIFT_ARRAY(span->array->attribs[i], leftClip, n - leftClip);

-            }

-         }

-

-         SHIFT_ARRAY(span->array->mask, leftClip, n - leftClip);

-         SHIFT_ARRAY(span->array->rgba8, leftClip, n - leftClip);

-         SHIFT_ARRAY(span->array->rgba16, leftClip, n - leftClip);

-         SHIFT_ARRAY(span->array->x, leftClip, n - leftClip);

-         SHIFT_ARRAY(span->array->y, leftClip, n - leftClip);

-         SHIFT_ARRAY(span->array->z, leftClip, n - leftClip);

-         SHIFT_ARRAY(span->array->index, leftClip, n - leftClip);

-         for (i = 0; i < MAX_TEXTURE_COORD_UNITS; i++) {

-            SHIFT_ARRAY(span->array->lambda[i], leftClip, n - leftClip);

-         }

-         SHIFT_ARRAY(span->array->coverage, leftClip, n - leftClip);

-

-#undef SHIFT_ARRAY

-

-         span->leftClip = leftClip;

-         span->x = xmin;

-         span->end -= leftClip;

-         span->writeAll = GL_FALSE;

-      }

-

-      ASSERT(span->x >= xmin);

-      ASSERT(span->x + span->end <= xmax);

-      ASSERT(span->y >= ymin);

-      ASSERT(span->y < ymax);

-

-      return GL_TRUE;  /* some pixels visible */

-   }

-}

-

-

-/**

- * Add specular colors to primary colors.

- * Only called during fixed-function operation.

- * Result is float color array (FRAG_ATTRIB_COL0).

- */

-static INLINE void

-add_specular(struct gl_context *ctx, SWspan *span)

-{

-   const SWcontext *swrast = SWRAST_CONTEXT(ctx);

-   const GLubyte *mask = span->array->mask;

-   GLfloat (*col0)[4] = span->array->attribs[FRAG_ATTRIB_COL0];

-   GLfloat (*col1)[4] = span->array->attribs[FRAG_ATTRIB_COL1];

-   GLuint i;

-

-   ASSERT(!ctx->FragmentProgram._Current);

-   ASSERT(span->arrayMask & SPAN_RGBA);

-   ASSERT(swrast->_ActiveAttribMask & FRAG_BIT_COL1);

-   (void) swrast; /* silence warning */

-

-   if (span->array->ChanType == GL_FLOAT) {

-      if ((span->arrayAttribs & FRAG_BIT_COL0) == 0) {

-         interpolate_active_attribs(ctx, span, FRAG_BIT_COL0);

-      }

-   }

-   else {

-      /* need float colors */

-      if ((span->arrayAttribs & FRAG_BIT_COL0) == 0) {

-         interpolate_float_colors(span);

-      }

-   }

-

-   if ((span->arrayAttribs & FRAG_BIT_COL1) == 0) {

-      /* XXX could avoid this and interpolate COL1 in the loop below */

-      interpolate_active_attribs(ctx, span, FRAG_BIT_COL1);

-   }

-

-   ASSERT(span->arrayAttribs & FRAG_BIT_COL0);

-   ASSERT(span->arrayAttribs & FRAG_BIT_COL1);

-

-   for (i = 0; i < span->end; i++) {

-      if (mask[i]) {

-         col0[i][0] += col1[i][0];

-         col0[i][1] += col1[i][1];

-         col0[i][2] += col1[i][2];

-      }

-   }

-

-   span->array->ChanType = GL_FLOAT;

-}

-

-

-/**

- * Apply antialiasing coverage value to alpha values.

- */

-static INLINE void

-apply_aa_coverage(SWspan *span)

-{

-   const GLfloat *coverage = span->array->coverage;

-   GLuint i;

-   if (span->array->ChanType == GL_UNSIGNED_BYTE) {

-      GLubyte (*rgba)[4] = span->array->rgba8;

-      for (i = 0; i < span->end; i++) {

-         const GLfloat a = rgba[i][ACOMP] * coverage[i];

-         rgba[i][ACOMP] = (GLubyte) CLAMP(a, 0.0, 255.0);

-         ASSERT(coverage[i] >= 0.0);

-         ASSERT(coverage[i] <= 1.0);

-      }

-   }

-   else if (span->array->ChanType == GL_UNSIGNED_SHORT) {

-      GLushort (*rgba)[4] = span->array->rgba16;

-      for (i = 0; i < span->end; i++) {

-         const GLfloat a = rgba[i][ACOMP] * coverage[i];

-         rgba[i][ACOMP] = (GLushort) CLAMP(a, 0.0, 65535.0);

-      }

-   }

-   else {

-      GLfloat (*rgba)[4] = span->array->attribs[FRAG_ATTRIB_COL0];

-      for (i = 0; i < span->end; i++) {

-         rgba[i][ACOMP] = rgba[i][ACOMP] * coverage[i];

-         /* clamp later */

-      }

-   }

-}

-

-

-/**

- * Clamp span's float colors to [0,1]

- */

-static INLINE void

-clamp_colors(SWspan *span)

-{

-   GLfloat (*rgba)[4] = span->array->attribs[FRAG_ATTRIB_COL0];

-   GLuint i;

-   ASSERT(span->array->ChanType == GL_FLOAT);

-   for (i = 0; i < span->end; i++) {

-      rgba[i][RCOMP] = CLAMP(rgba[i][RCOMP], 0.0F, 1.0F);

-      rgba[i][GCOMP] = CLAMP(rgba[i][GCOMP], 0.0F, 1.0F);

-      rgba[i][BCOMP] = CLAMP(rgba[i][BCOMP], 0.0F, 1.0F);

-      rgba[i][ACOMP] = CLAMP(rgba[i][ACOMP], 0.0F, 1.0F);

-   }

-}

-

-

-/**

- * Convert the span's color arrays to the given type.

- * The only way 'output' can be greater than zero is when we have a fragment

- * program that writes to gl_FragData[1] or higher.

- * \param output  which fragment program color output is being processed

- */

-static INLINE void

-convert_color_type(SWspan *span, GLenum newType, GLuint output)

-{

-   GLvoid *src, *dst;

-

-   if (output > 0 || span->array->ChanType == GL_FLOAT) {

-      src = span->array->attribs[FRAG_ATTRIB_COL0 + output];

-      span->array->ChanType = GL_FLOAT;

-   }

-   else if (span->array->ChanType == GL_UNSIGNED_BYTE) {

-      src = span->array->rgba8;

-   }

-   else {

-      ASSERT(span->array->ChanType == GL_UNSIGNED_SHORT);

-      src = span->array->rgba16;

-   }

-

-   if (newType == GL_UNSIGNED_BYTE) {

-      dst = span->array->rgba8;

-   }

-   else if (newType == GL_UNSIGNED_SHORT) {

-      dst = span->array->rgba16;

-   }

-   else {

-      dst = span->array->attribs[FRAG_ATTRIB_COL0];

-   }

-

-   _mesa_convert_colors(span->array->ChanType, src,

-                        newType, dst,

-                        span->end, span->array->mask);

-

-   span->array->ChanType = newType;

-   span->array->rgba = dst;

-}

-

-

-

-/**

- * Apply fragment shader, fragment program or normal texturing to span.

- */

-static INLINE void

-shade_texture_span(struct gl_context *ctx, SWspan *span)

-{

-   GLbitfield inputsRead;

-

-   /* Determine which fragment attributes are actually needed */

-   if (ctx->FragmentProgram._Current) {

-      inputsRead = ctx->FragmentProgram._Current->Base.InputsRead;

-   }

-   else {

-      /* XXX we could be a bit smarter about this */

-      inputsRead = ~0;

-   }

-

-   if (ctx->FragmentProgram._Current ||

-       ctx->ATIFragmentShader._Enabled) {

-      /* programmable shading */

-      if (span->primitive == GL_BITMAP && span->array->ChanType != GL_FLOAT) {

-         convert_color_type(span, GL_FLOAT, 0);

-      }

-      else {

-         span->array->rgba = (void *) span->array->attribs[FRAG_ATTRIB_COL0];

-      }

-

-      if (span->primitive != GL_POINT ||

-	  (span->interpMask & SPAN_RGBA) ||

-	  ctx->Point.PointSprite) {

-         /* for single-pixel points, we populated the arrays already */

-         interpolate_active_attribs(ctx, span, ~0);

-      }

-      span->array->ChanType = GL_FLOAT;

-

-      if (!(span->arrayMask & SPAN_Z))

-         _swrast_span_interpolate_z (ctx, span);

-

-#if 0

-      if (inputsRead & FRAG_BIT_WPOS)

-#else

-      /* XXX always interpolate wpos so that DDX/DDY work */

-#endif

-         interpolate_wpos(ctx, span);

-

-      /* Run fragment program/shader now */

-      if (ctx->FragmentProgram._Current) {

-         _swrast_exec_fragment_program(ctx, span);

-      }

-      else {

-         ASSERT(ctx->ATIFragmentShader._Enabled);

-         _swrast_exec_fragment_shader(ctx, span);

-      }

-   }

-   else if (ctx->Texture._EnabledCoordUnits) {

-      /* conventional texturing */

-

-#if CHAN_BITS == 32

-      if ((span->arrayAttribs & FRAG_BIT_COL0) == 0) {

-         interpolate_int_colors(ctx, span);

-      }

-#else

-      if (!(span->arrayMask & SPAN_RGBA))

-         interpolate_int_colors(ctx, span);

-#endif

-      if ((span->arrayAttribs & FRAG_BITS_TEX_ANY) == 0x0)

-         interpolate_texcoords(ctx, span);

-

-      _swrast_texture_span(ctx, span);

-   }

-}

-

-

-

-/**

- * Apply all the per-fragment operations to a span.

- * This now includes texturing (_swrast_write_texture_span() is history).

- * This function may modify any of the array values in the span.

- * span->interpMask and span->arrayMask may be changed but will be restored

- * to their original values before returning.

- */

-void

-_swrast_write_rgba_span( struct gl_context *ctx, SWspan *span)

-{

-   const SWcontext *swrast = SWRAST_CONTEXT(ctx);

-   const GLuint *colorMask = (GLuint *) ctx->Color.ColorMask;

-   const GLbitfield origInterpMask = span->interpMask;

-   const GLbitfield origArrayMask = span->arrayMask;

-   const GLbitfield origArrayAttribs = span->arrayAttribs;

-   const GLenum origChanType = span->array->ChanType;

-   void * const origRgba = span->array->rgba;

-   const GLboolean shader = (ctx->FragmentProgram._Current

-                             || ctx->ATIFragmentShader._Enabled);

-   const GLboolean shaderOrTexture = shader || ctx->Texture._EnabledCoordUnits;

-   struct gl_framebuffer *fb = ctx->DrawBuffer;

-

-   /*

-   printf("%s()  interp 0x%x  array 0x%x\n", __FUNCTION__,

-          span->interpMask, span->arrayMask);

-   */

-

-   ASSERT(span->primitive == GL_POINT ||

-          span->primitive == GL_LINE ||

-	  span->primitive == GL_POLYGON ||

-          span->primitive == GL_BITMAP);

-

-   /* Fragment write masks */

-   if (span->arrayMask & SPAN_MASK) {

-      /* mask was initialized by caller, probably glBitmap */

-      span->writeAll = GL_FALSE;

-   }

-   else {

-      memset(span->array->mask, 1, span->end);

-      span->writeAll = GL_TRUE;

-   }

-

-   /* Clip to window/scissor box */

-   if (!clip_span(ctx, span)) {

-      return;

-   }

-

-   ASSERT(span->end <= MAX_WIDTH);

-

-   /* Depth bounds test */

-   if (ctx->Depth.BoundsTest && fb->Visual.depthBits > 0) {

-      if (!_swrast_depth_bounds_test(ctx, span)) {

-         return;

-      }

-   }

-

-#ifdef DEBUG

-   /* Make sure all fragments are within window bounds */

-   if (span->arrayMask & SPAN_XY) {

-      /* array of pixel locations */

-      GLuint i;

-      for (i = 0; i < span->end; i++) {

-         if (span->array->mask[i]) {

-            assert(span->array->x[i] >= fb->_Xmin);

-            assert(span->array->x[i] < fb->_Xmax);

-            assert(span->array->y[i] >= fb->_Ymin);

-            assert(span->array->y[i] < fb->_Ymax);

-         }

-      }

-   }

-#endif

-

-   /* Polygon Stippling */

-   if (ctx->Polygon.StippleFlag && span->primitive == GL_POLYGON) {

-      stipple_polygon_span(ctx, span);

-   }

-

-   /* This is the normal place to compute the fragment color/Z

-    * from texturing or shading.

-    */

-   if (shaderOrTexture && !swrast->_DeferredTexture) {

-      shade_texture_span(ctx, span);

-   }

-

-   /* Do the alpha test */

-   if (ctx->Color.AlphaEnabled) {

-      if (!_swrast_alpha_test(ctx, span)) {

-         /* all fragments failed test */

-         goto end;

-      }

-   }

-

-   /* Stencil and Z testing */

-   if (ctx->Stencil._Enabled || ctx->Depth.Test) {

-      if (!(span->arrayMask & SPAN_Z))

-         _swrast_span_interpolate_z(ctx, span);

-

-      if (ctx->Transform.DepthClamp)

-	 _swrast_depth_clamp_span(ctx, span);

-

-      if (ctx->Stencil._Enabled) {

-         /* Combined Z/stencil tests */

-         if (!_swrast_stencil_and_ztest_span(ctx, span)) {

-            /* all fragments failed test */

-            goto end;

-         }

-      }

-      else if (fb->Visual.depthBits > 0) {

-         /* Just regular depth testing */

-         ASSERT(ctx->Depth.Test);

-         ASSERT(span->arrayMask & SPAN_Z);

-         if (!_swrast_depth_test_span(ctx, span)) {

-            /* all fragments failed test */

-            goto end;

-         }

-      }

-   }

-

-   if (ctx->Query.CurrentOcclusionObject) {

-      /* update count of 'passed' fragments */

-      struct gl_query_object *q = ctx->Query.CurrentOcclusionObject;

-      GLuint i;

-      for (i = 0; i < span->end; i++)

-         q->Result += span->array->mask[i];

-   }

-

-   /* We had to wait until now to check for glColorMask(0,0,0,0) because of

-    * the occlusion test.

-    */

-   if (fb->_NumColorDrawBuffers == 1 && colorMask[0] == 0x0) {

-      /* no colors to write */

-      goto end;

-   }

-

-   /* If we were able to defer fragment color computation to now, there's

-    * a good chance that many fragments will have already been killed by

-    * Z/stencil testing.

-    */

-   if (shaderOrTexture && swrast->_DeferredTexture) {

-      shade_texture_span(ctx, span);

-   }

-

-#if CHAN_BITS == 32

-   if ((span->arrayAttribs & FRAG_BIT_COL0) == 0) {

-      interpolate_active_attribs(ctx, span, FRAG_BIT_COL0);

-   }

-#else

-   if ((span->arrayMask & SPAN_RGBA) == 0) {

-      interpolate_int_colors(ctx, span);

-   }

-#endif

-

-   ASSERT(span->arrayMask & SPAN_RGBA);

-

-   if (span->primitive == GL_BITMAP || !swrast->SpecularVertexAdd) {

-      /* Add primary and specular (diffuse + specular) colors */

-      if (!shader) {

-         if (ctx->Fog.ColorSumEnabled ||

-             (ctx->Light.Enabled &&

-              ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR)) {

-            add_specular(ctx, span);

-         }

-      }

-   }

-

-   /* Fog */

-   if (swrast->_FogEnabled) {

-      _swrast_fog_rgba_span(ctx, span);

-   }

-

-   /* Antialias coverage application */

-   if (span->arrayMask & SPAN_COVERAGE) {

-      apply_aa_coverage(span);

-   }

-

-   /* Clamp color/alpha values over the range [0.0, 1.0] before storage */

-   if (ctx->Color.ClampFragmentColor == GL_TRUE &&

-       span->array->ChanType == GL_FLOAT) {

-      clamp_colors(span);

-   }

-

-   /*

-    * Write to renderbuffers.

-    * Depending on glDrawBuffer() state and the which color outputs are

-    * written by the fragment shader, we may either replicate one color to

-    * all renderbuffers or write a different color to each renderbuffer.

-    * multiFragOutputs=TRUE for the later case.

-    */

-   {

-      const GLuint numBuffers = fb->_NumColorDrawBuffers;

-      const struct gl_fragment_program *fp = ctx->FragmentProgram._Current;

-      const GLboolean multiFragOutputs = 

-         (fp && fp->Base.OutputsWritten >= (1 << FRAG_RESULT_DATA0));

-      GLuint buf;

-

-      for (buf = 0; buf < numBuffers; buf++) {

-         struct gl_renderbuffer *rb = fb->_ColorDrawBuffers[buf];

-

-         /* color[fragOutput] will be written to buffer[buf] */

-

-         if (rb) {

-            GLchan rgbaSave[MAX_WIDTH][4];

-            const GLuint fragOutput = multiFragOutputs ? buf : 0;

-

-            /* set span->array->rgba to colors for render buffer's datatype */

-            if (rb->DataType != span->array->ChanType || fragOutput > 0) {

-               convert_color_type(span, rb->DataType, fragOutput);

-            }

-            else {

-               if (rb->DataType == GL_UNSIGNED_BYTE) {

-                  span->array->rgba = span->array->rgba8;

-               }

-               else if (rb->DataType == GL_UNSIGNED_SHORT) {

-                  span->array->rgba = (void *) span->array->rgba16;

-               }

-               else {

-                  span->array->rgba = (void *)

-                     span->array->attribs[FRAG_ATTRIB_COL0];

-               }

-            }

-

-            if (!multiFragOutputs && numBuffers > 1) {

-               /* save colors for second, third renderbuffer writes */

-               memcpy(rgbaSave, span->array->rgba,

-                      4 * span->end * sizeof(GLchan));

-            }

-

-            ASSERT(rb->_BaseFormat == GL_RGBA || rb->_BaseFormat == GL_RGB ||

-		   rb->_BaseFormat == GL_ALPHA);

-

-            if (ctx->Color._LogicOpEnabled) {

-               _swrast_logicop_rgba_span(ctx, rb, span);

-            }

-            else if ((ctx->Color.BlendEnabled >> buf) & 1) {

-               _swrast_blend_span(ctx, rb, span);

-            }

-

-            if (colorMask[buf] != 0xffffffff) {

-               _swrast_mask_rgba_span(ctx, rb, span, buf);

-            }

-

-            if (span->arrayMask & SPAN_XY) {

-               /* array of pixel coords */

-               ASSERT(rb->PutValues);

-               rb->PutValues(ctx, rb, span->end,

-                             span->array->x, span->array->y,

-                             span->array->rgba, span->array->mask);

-            }

-            else {

-               /* horizontal run of pixels */

-               ASSERT(rb->PutRow);

-               rb->PutRow(ctx, rb, span->end, span->x, span->y,

-                          span->array->rgba,

-                          span->writeAll ? NULL: span->array->mask);

-            }

-

-            if (!multiFragOutputs && numBuffers > 1) {

-               /* restore original span values */

-               memcpy(span->array->rgba, rgbaSave,

-                      4 * span->end * sizeof(GLchan));

-            }

-

-         } /* if rb */

-      } /* for buf */

-   }

-

-end:

-   /* restore these values before returning */

-   span->interpMask = origInterpMask;

-   span->arrayMask = origArrayMask;

-   span->arrayAttribs = origArrayAttribs;

-   span->array->ChanType = origChanType;

-   span->array->rgba = origRgba;

-}

-

-

-/**

- * Read RGBA pixels from a renderbuffer.  Clipping will be done to prevent

- * reading ouside the buffer's boundaries.

- * \param dstType  datatype for returned colors

- * \param rgba  the returned colors

- */

-void

-_swrast_read_rgba_span( struct gl_context *ctx, struct gl_renderbuffer *rb,

-                        GLuint n, GLint x, GLint y, GLenum dstType,

-                        GLvoid *rgba)

-{

-   const GLint bufWidth = (GLint) rb->Width;

-   const GLint bufHeight = (GLint) rb->Height;

-

-   if (y < 0 || y >= bufHeight || x + (GLint) n < 0 || x >= bufWidth) {

-      /* completely above, below, or right */

-      /* XXX maybe leave rgba values undefined? */

-      memset(rgba, 0, 4 * n * sizeof(GLchan));

-   }

-   else {

-      GLint skip, length;

-      if (x < 0) {

-         /* left edge clipping */

-         skip = -x;

-         length = (GLint) n - skip;

-         if (length < 0) {

-            /* completely left of window */

-            return;

-         }

-         if (length > bufWidth) {

-            length = bufWidth;

-         }

-      }

-      else if ((GLint) (x + n) > bufWidth) {

-         /* right edge clipping */

-         skip = 0;

-         length = bufWidth - x;

-         if (length < 0) {

-            /* completely to right of window */

-            return;

-         }

-      }

-      else {

-         /* no clipping */

-         skip = 0;

-         length = (GLint) n;

-      }

-

-      ASSERT(rb);

-      ASSERT(rb->GetRow);

-      ASSERT(rb->_BaseFormat == GL_RGBA ||

-	     rb->_BaseFormat == GL_RGB ||

-	     rb->_BaseFormat == GL_RG ||

-	     rb->_BaseFormat == GL_RED ||

-	     rb->_BaseFormat == GL_LUMINANCE ||

-	     rb->_BaseFormat == GL_INTENSITY ||

-	     rb->_BaseFormat == GL_LUMINANCE_ALPHA ||

-	     rb->_BaseFormat == GL_ALPHA);

-

-      if (rb->DataType == dstType) {

-         rb->GetRow(ctx, rb, length, x + skip, y,

-                    (GLubyte *) rgba + skip * RGBA_PIXEL_SIZE(rb->DataType));

-      }

-      else {

-         GLuint temp[MAX_WIDTH * 4];

-         rb->GetRow(ctx, rb, length, x + skip, y, temp);

-         _mesa_convert_colors(rb->DataType, temp,

-                   dstType, (GLubyte *) rgba + skip * RGBA_PIXEL_SIZE(dstType),

-                   length, NULL);

-      }

-   }

-}

-

-

-/**

- * Wrapper for gl_renderbuffer::GetValues() which does clipping to avoid

- * reading values outside the buffer bounds.

- * We can use this for reading any format/type of renderbuffer.

- * \param valueSize is the size in bytes of each value (pixel) put into the

- *                  values array.

- */

-void

-_swrast_get_values(struct gl_context *ctx, struct gl_renderbuffer *rb,

-                   GLuint count, const GLint x[], const GLint y[],

-                   void *values, GLuint valueSize)

-{

-   GLuint i, inCount = 0, inStart = 0;

-

-   for (i = 0; i < count; i++) {

-      if (x[i] >= 0 && y[i] >= 0 &&

-	  x[i] < (GLint) rb->Width && y[i] < (GLint) rb->Height) {

-         /* inside */

-         if (inCount == 0)

-            inStart = i;

-         inCount++;

-      }

-      else {

-         if (inCount > 0) {

-            /* read [inStart, inStart + inCount) */

-            rb->GetValues(ctx, rb, inCount, x + inStart, y + inStart,

-                          (GLubyte *) values + inStart * valueSize);

-            inCount = 0;

-         }

-      }

-   }

-   if (inCount > 0) {

-      /* read last values */

-      rb->GetValues(ctx, rb, inCount, x + inStart, y + inStart,

-                    (GLubyte *) values + inStart * valueSize);

-   }

-}

-

-

-/**

- * Wrapper for gl_renderbuffer::PutRow() which does clipping.

- * \param valueSize  size of each value (pixel) in bytes

- */

-void

-_swrast_put_row(struct gl_context *ctx, struct gl_renderbuffer *rb,

-                GLuint count, GLint x, GLint y,

-                const GLvoid *values, GLuint valueSize)

-{

-   GLint skip = 0;

-

-   if (y < 0 || y >= (GLint) rb->Height)

-      return; /* above or below */

-

-   if (x + (GLint) count <= 0 || x >= (GLint) rb->Width)

-      return; /* entirely left or right */

-

-   if ((GLint) (x + count) > (GLint) rb->Width) {

-      /* right clip */

-      GLint clip = x + count - rb->Width;

-      count -= clip;

-   }

-

-   if (x < 0) {

-      /* left clip */

-      skip = -x;

-      x = 0;

-      count -= skip;

-   }

-

-   rb->PutRow(ctx, rb, count, x, y,

-              (const GLubyte *) values + skip * valueSize, NULL);

-}

-

-

-/**

- * Wrapper for gl_renderbuffer::GetRow() which does clipping.

- * \param valueSize  size of each value (pixel) in bytes

- */

-void

-_swrast_get_row(struct gl_context *ctx, struct gl_renderbuffer *rb,

-                GLuint count, GLint x, GLint y,

-                GLvoid *values, GLuint valueSize)

-{

-   GLint skip = 0;

-

-   if (y < 0 || y >= (GLint) rb->Height)

-      return; /* above or below */

-

-   if (x + (GLint) count <= 0 || x >= (GLint) rb->Width)

-      return; /* entirely left or right */

-

-   if (x + count > rb->Width) {

-      /* right clip */

-      GLint clip = x + count - rb->Width;

-      count -= clip;

-   }

-

-   if (x < 0) {

-      /* left clip */

-      skip = -x;

-      x = 0;

-      count -= skip;

-   }

-

-   rb->GetRow(ctx, rb, count, x, y, (GLubyte *) values + skip * valueSize);

-}

-

-

-/**

- * Get RGBA pixels from the given renderbuffer.

- * Used by blending, logicop and masking functions.

- * \return pointer to the colors we read.

- */

-void *

-_swrast_get_dest_rgba(struct gl_context *ctx, struct gl_renderbuffer *rb,

-                      SWspan *span)

-{

-   const GLuint pixelSize = RGBA_PIXEL_SIZE(span->array->ChanType);

-   void *rbPixels;

-

-   /* Point rbPixels to a temporary space */

-   rbPixels = span->array->attribs[FRAG_ATTRIB_MAX - 1];

-

-   /* Get destination values from renderbuffer */

-   if (span->arrayMask & SPAN_XY) {

-      _swrast_get_values(ctx, rb, span->end, span->array->x, span->array->y,

-                         rbPixels, pixelSize);

-   }

-   else {

-      _swrast_get_row(ctx, rb, span->end, span->x, span->y,

-                      rbPixels, pixelSize);

-   }

-

-   return rbPixels;

-}

+/*
+ * Mesa 3-D graphics library
+ * Version:  7.5
+ *
+ * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
+ * Copyright (C) 2009  VMware, Inc.  All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+
+/**
+ * \file swrast/s_span.c
+ * \brief Span processing functions used by all rasterization functions.
+ * This is where all the per-fragment tests are performed
+ * \author Brian Paul
+ */
+
+#include "main/glheader.h"
+#include "main/colormac.h"
+#include "main/macros.h"
+#include "main/imports.h"
+#include "main/image.h"
+
+#include "s_atifragshader.h"
+#include "s_alpha.h"
+#include "s_blend.h"
+#include "s_context.h"
+#include "s_depth.h"
+#include "s_fog.h"
+#include "s_logic.h"
+#include "s_masking.h"
+#include "s_fragprog.h"
+#include "s_span.h"
+#include "s_stencil.h"
+#include "s_texcombine.h"
+
+
+/**
+ * Set default fragment attributes for the span using the
+ * current raster values.  Used prior to glDraw/CopyPixels
+ * and glBitmap.
+ */
+void
+_swrast_span_default_attribs(struct gl_context *ctx, SWspan *span)
+{
+   GLchan r, g, b, a;
+   /* Z*/
+   {
+      const GLfloat depthMax = ctx->DrawBuffer->_DepthMaxF;
+      if (ctx->DrawBuffer->Visual.depthBits <= 16)
+         span->z = FloatToFixed(ctx->Current.RasterPos[2] * depthMax + 0.5F);
+      else {
+         GLfloat tmpf = ctx->Current.RasterPos[2] * depthMax; 
+         tmpf = MIN2(tmpf, depthMax);
+         span->z = (GLint)tmpf;
+      }
+      span->zStep = 0;
+      span->interpMask |= SPAN_Z;
+   }
+
+   /* W (for perspective correction) */
+   span->attrStart[FRAG_ATTRIB_WPOS][3] = 1.0;
+   span->attrStepX[FRAG_ATTRIB_WPOS][3] = 0.0;
+   span->attrStepY[FRAG_ATTRIB_WPOS][3] = 0.0;
+
+   /* primary color, or color index */
+   UNCLAMPED_FLOAT_TO_CHAN(r, ctx->Current.RasterColor[0]);
+   UNCLAMPED_FLOAT_TO_CHAN(g, ctx->Current.RasterColor[1]);
+   UNCLAMPED_FLOAT_TO_CHAN(b, ctx->Current.RasterColor[2]);
+   UNCLAMPED_FLOAT_TO_CHAN(a, ctx->Current.RasterColor[3]);
+#if CHAN_TYPE == GL_FLOAT
+   span->red = r;
+   span->green = g;
+   span->blue = b;
+   span->alpha = a;
+#else
+   span->red   = IntToFixed(r);
+   span->green = IntToFixed(g);
+   span->blue  = IntToFixed(b);
+   span->alpha = IntToFixed(a);
+#endif
+   span->redStep = 0;
+   span->greenStep = 0;
+   span->blueStep = 0;
+   span->alphaStep = 0;
+   span->interpMask |= SPAN_RGBA;
+
+   COPY_4V(span->attrStart[FRAG_ATTRIB_COL0], ctx->Current.RasterColor);
+   ASSIGN_4V(span->attrStepX[FRAG_ATTRIB_COL0], 0.0, 0.0, 0.0, 0.0);
+   ASSIGN_4V(span->attrStepY[FRAG_ATTRIB_COL0], 0.0, 0.0, 0.0, 0.0);
+
+   /* Secondary color */
+   if (ctx->Light.Enabled || ctx->Fog.ColorSumEnabled)
+   {
+      COPY_4V(span->attrStart[FRAG_ATTRIB_COL1], ctx->Current.RasterSecondaryColor);
+      ASSIGN_4V(span->attrStepX[FRAG_ATTRIB_COL1], 0.0, 0.0, 0.0, 0.0);
+      ASSIGN_4V(span->attrStepY[FRAG_ATTRIB_COL1], 0.0, 0.0, 0.0, 0.0);
+   }
+
+   /* fog */
+   {
+      const SWcontext *swrast = SWRAST_CONTEXT(ctx);
+      GLfloat fogVal; /* a coord or a blend factor */
+      if (swrast->_PreferPixelFog) {
+         /* fog blend factors will be computed from fog coordinates per pixel */
+         fogVal = ctx->Current.RasterDistance;
+      }
+      else {
+         /* fog blend factor should be computed from fogcoord now */
+         fogVal = _swrast_z_to_fogfactor(ctx, ctx->Current.RasterDistance);
+      }
+      span->attrStart[FRAG_ATTRIB_FOGC][0] = fogVal;
+      span->attrStepX[FRAG_ATTRIB_FOGC][0] = 0.0;
+      span->attrStepY[FRAG_ATTRIB_FOGC][0] = 0.0;
+   }
+
+   /* texcoords */
+   {
+      GLuint i;
+      for (i = 0; i < ctx->Const.MaxTextureCoordUnits; i++) {
+         const GLuint attr = FRAG_ATTRIB_TEX0 + i;
+         const GLfloat *tc = ctx->Current.RasterTexCoords[i];
+         if (ctx->FragmentProgram._Current || ctx->ATIFragmentShader._Enabled) {
+            COPY_4V(span->attrStart[attr], tc);
+         }
+         else if (tc[3] > 0.0F) {
+            /* use (s/q, t/q, r/q, 1) */
+            span->attrStart[attr][0] = tc[0] / tc[3];
+            span->attrStart[attr][1] = tc[1] / tc[3];
+            span->attrStart[attr][2] = tc[2] / tc[3];
+            span->attrStart[attr][3] = 1.0;
+         }
+         else {
+            ASSIGN_4V(span->attrStart[attr], 0.0F, 0.0F, 0.0F, 1.0F);
+         }
+         ASSIGN_4V(span->attrStepX[attr], 0.0F, 0.0F, 0.0F, 0.0F);
+         ASSIGN_4V(span->attrStepY[attr], 0.0F, 0.0F, 0.0F, 0.0F);
+      }
+   }
+}
+
+
+/**
+ * Interpolate the active attributes (and'd with attrMask) to
+ * fill in span->array->attribs[].
+ * Perspective correction will be done.  The point/line/triangle function
+ * should have computed attrStart/Step values for FRAG_ATTRIB_WPOS[3]!
+ */
+static INLINE void
+interpolate_active_attribs(struct gl_context *ctx, SWspan *span, GLbitfield attrMask)
+{
+   const SWcontext *swrast = SWRAST_CONTEXT(ctx);
+
+   /*
+    * Don't overwrite existing array values, such as colors that may have
+    * been produced by glDraw/CopyPixels.
+    */
+   attrMask &= ~span->arrayAttribs;
+
+   ATTRIB_LOOP_BEGIN
+      if (attrMask & (1 << attr)) {
+         const GLfloat dwdx = span->attrStepX[FRAG_ATTRIB_WPOS][3];
+         GLfloat w = span->attrStart[FRAG_ATTRIB_WPOS][3];
+         const GLfloat dv0dx = span->attrStepX[attr][0];
+         const GLfloat dv1dx = span->attrStepX[attr][1];
+         const GLfloat dv2dx = span->attrStepX[attr][2];
+         const GLfloat dv3dx = span->attrStepX[attr][3];
+         GLfloat v0 = span->attrStart[attr][0] + span->leftClip * dv0dx;
+         GLfloat v1 = span->attrStart[attr][1] + span->leftClip * dv1dx;
+         GLfloat v2 = span->attrStart[attr][2] + span->leftClip * dv2dx;
+         GLfloat v3 = span->attrStart[attr][3] + span->leftClip * dv3dx;
+         GLuint k;
+         for (k = 0; k < span->end; k++) {
+            const GLfloat invW = 1.0f / w;
+            span->array->attribs[attr][k][0] = v0 * invW;
+            span->array->attribs[attr][k][1] = v1 * invW;
+            span->array->attribs[attr][k][2] = v2 * invW;
+            span->array->attribs[attr][k][3] = v3 * invW;
+            v0 += dv0dx;
+            v1 += dv1dx;
+            v2 += dv2dx;
+            v3 += dv3dx;
+            w += dwdx;
+         }
+         ASSERT((span->arrayAttribs & (1 << attr)) == 0);
+         span->arrayAttribs |= (1 << attr);
+      }
+   ATTRIB_LOOP_END
+}
+
+
+/**
+ * Interpolate primary colors to fill in the span->array->rgba8 (or rgb16)
+ * color array.
+ */
+static INLINE void
+interpolate_int_colors(struct gl_context *ctx, SWspan *span)
+{
+   const GLuint n = span->end;
+   GLuint i;
+
+#if CHAN_BITS != 32
+   ASSERT(!(span->arrayMask & SPAN_RGBA));
+#endif
+
+   switch (span->array->ChanType) {
+#if CHAN_BITS != 32
+   case GL_UNSIGNED_BYTE:
+      {
+         GLubyte (*rgba)[4] = span->array->rgba8;
+         if (span->interpMask & SPAN_FLAT) {
+            GLubyte color[4];
+            color[RCOMP] = FixedToInt(span->red);
+            color[GCOMP] = FixedToInt(span->green);
+            color[BCOMP] = FixedToInt(span->blue);
+            color[ACOMP] = FixedToInt(span->alpha);
+            for (i = 0; i < n; i++) {
+               COPY_4UBV(rgba[i], color);
+            }
+         }
+         else {
+            GLfixed r = span->red;
+            GLfixed g = span->green;
+            GLfixed b = span->blue;
+            GLfixed a = span->alpha;
+            GLint dr = span->redStep;
+            GLint dg = span->greenStep;
+            GLint db = span->blueStep;
+            GLint da = span->alphaStep;
+            for (i = 0; i < n; i++) {
+               rgba[i][RCOMP] = FixedToChan(r);
+               rgba[i][GCOMP] = FixedToChan(g);
+               rgba[i][BCOMP] = FixedToChan(b);
+               rgba[i][ACOMP] = FixedToChan(a);
+               r += dr;
+               g += dg;
+               b += db;
+               a += da;
+            }
+         }
+      }
+      break;
+   case GL_UNSIGNED_SHORT:
+      {
+         GLushort (*rgba)[4] = span->array->rgba16;
+         if (span->interpMask & SPAN_FLAT) {
+            GLushort color[4];
+            color[RCOMP] = FixedToInt(span->red);
+            color[GCOMP] = FixedToInt(span->green);
+            color[BCOMP] = FixedToInt(span->blue);
+            color[ACOMP] = FixedToInt(span->alpha);
+            for (i = 0; i < n; i++) {
+               COPY_4V(rgba[i], color);
+            }
+         }
+         else {
+            GLushort (*rgba)[4] = span->array->rgba16;
+            GLfixed r, g, b, a;
+            GLint dr, dg, db, da;
+            r = span->red;
+            g = span->green;
+            b = span->blue;
+            a = span->alpha;
+            dr = span->redStep;
+            dg = span->greenStep;
+            db = span->blueStep;
+            da = span->alphaStep;
+            for (i = 0; i < n; i++) {
+               rgba[i][RCOMP] = FixedToChan(r);
+               rgba[i][GCOMP] = FixedToChan(g);
+               rgba[i][BCOMP] = FixedToChan(b);
+               rgba[i][ACOMP] = FixedToChan(a);
+               r += dr;
+               g += dg;
+               b += db;
+               a += da;
+            }
+         }
+      }
+      break;
+#endif
+   case GL_FLOAT:
+      interpolate_active_attribs(ctx, span, FRAG_BIT_COL0);
+      break;
+   default:
+      _mesa_problem(ctx, "bad datatype 0x%x in interpolate_int_colors",
+                    span->array->ChanType);
+   }
+   span->arrayMask |= SPAN_RGBA;
+}
+
+
+/**
+ * Populate the FRAG_ATTRIB_COL0 array.
+ */
+static INLINE void
+interpolate_float_colors(SWspan *span)
+{
+   GLfloat (*col0)[4] = span->array->attribs[FRAG_ATTRIB_COL0];
+   const GLuint n = span->end;
+   GLuint i;
+
+   assert(!(span->arrayAttribs & FRAG_BIT_COL0));
+
+   if (span->arrayMask & SPAN_RGBA) {
+      /* convert array of int colors */
+      for (i = 0; i < n; i++) {
+         col0[i][0] = UBYTE_TO_FLOAT(span->array->rgba8[i][0]);
+         col0[i][1] = UBYTE_TO_FLOAT(span->array->rgba8[i][1]);
+         col0[i][2] = UBYTE_TO_FLOAT(span->array->rgba8[i][2]);
+         col0[i][3] = UBYTE_TO_FLOAT(span->array->rgba8[i][3]);
+      }
+   }
+   else {
+      /* interpolate red/green/blue/alpha to get float colors */
+      ASSERT(span->interpMask & SPAN_RGBA);
+      if (span->interpMask & SPAN_FLAT) {
+         GLfloat r = FixedToFloat(span->red);
+         GLfloat g = FixedToFloat(span->green);
+         GLfloat b = FixedToFloat(span->blue);
+         GLfloat a = FixedToFloat(span->alpha);
+         for (i = 0; i < n; i++) {
+            ASSIGN_4V(col0[i], r, g, b, a);
+         }
+      }
+      else {
+         GLfloat r = FixedToFloat(span->red);
+         GLfloat g = FixedToFloat(span->green);
+         GLfloat b = FixedToFloat(span->blue);
+         GLfloat a = FixedToFloat(span->alpha);
+         GLfloat dr = FixedToFloat(span->redStep);
+         GLfloat dg = FixedToFloat(span->greenStep);
+         GLfloat db = FixedToFloat(span->blueStep);
+         GLfloat da = FixedToFloat(span->alphaStep);
+         for (i = 0; i < n; i++) {
+            col0[i][0] = r;
+            col0[i][1] = g;
+            col0[i][2] = b;
+            col0[i][3] = a;
+            r += dr;
+            g += dg;
+            b += db;
+            a += da;
+         }
+      }
+   }
+
+   span->arrayAttribs |= FRAG_BIT_COL0;
+   span->array->ChanType = GL_FLOAT;
+}
+
+
+
+/**
+ * Fill in the span.zArray array from the span->z, zStep values.
+ */
+void
+_swrast_span_interpolate_z( const struct gl_context *ctx, SWspan *span )
+{
+   const GLuint n = span->end;
+   GLuint i;
+
+   ASSERT(!(span->arrayMask & SPAN_Z));
+
+   if (ctx->DrawBuffer->Visual.depthBits <= 16) {
+      GLfixed zval = span->z;
+      GLuint *z = span->array->z; 
+      for (i = 0; i < n; i++) {
+         z[i] = FixedToInt(zval);
+         zval += span->zStep;
+      }
+   }
+   else {
+      /* Deep Z buffer, no fixed->int shift */
+      GLuint zval = span->z;
+      GLuint *z = span->array->z;
+      for (i = 0; i < n; i++) {
+         z[i] = zval;
+         zval += span->zStep;
+      }
+   }
+   span->interpMask &= ~SPAN_Z;
+   span->arrayMask |= SPAN_Z;
+}
+
+
+/**
+ * Compute mipmap LOD from partial derivatives.
+ * This the ideal solution, as given in the OpenGL spec.
+ */
+GLfloat
+_swrast_compute_lambda(GLfloat dsdx, GLfloat dsdy, GLfloat dtdx, GLfloat dtdy,
+                       GLfloat dqdx, GLfloat dqdy, GLfloat texW, GLfloat texH,
+                       GLfloat s, GLfloat t, GLfloat q, GLfloat invQ)
+{
+   GLfloat dudx = texW * ((s + dsdx) / (q + dqdx) - s * invQ);
+   GLfloat dvdx = texH * ((t + dtdx) / (q + dqdx) - t * invQ);
+   GLfloat dudy = texW * ((s + dsdy) / (q + dqdy) - s * invQ);
+   GLfloat dvdy = texH * ((t + dtdy) / (q + dqdy) - t * invQ);
+   GLfloat x = SQRTF(dudx * dudx + dvdx * dvdx);
+   GLfloat y = SQRTF(dudy * dudy + dvdy * dvdy);
+   GLfloat rho = MAX2(x, y);
+   GLfloat lambda = LOG2(rho);
+   return lambda;
+}
+
+
+/**
+ * Compute mipmap LOD from partial derivatives.
+ * This is a faster approximation than above function.
+ */
+#if 0
+GLfloat
+_swrast_compute_lambda(GLfloat dsdx, GLfloat dsdy, GLfloat dtdx, GLfloat dtdy,
+                     GLfloat dqdx, GLfloat dqdy, GLfloat texW, GLfloat texH,
+                     GLfloat s, GLfloat t, GLfloat q, GLfloat invQ)
+{
+   GLfloat dsdx2 = (s + dsdx) / (q + dqdx) - s * invQ;
+   GLfloat dtdx2 = (t + dtdx) / (q + dqdx) - t * invQ;
+   GLfloat dsdy2 = (s + dsdy) / (q + dqdy) - s * invQ;
+   GLfloat dtdy2 = (t + dtdy) / (q + dqdy) - t * invQ;
+   GLfloat maxU, maxV, rho, lambda;
+   dsdx2 = FABSF(dsdx2);
+   dsdy2 = FABSF(dsdy2);
+   dtdx2 = FABSF(dtdx2);
+   dtdy2 = FABSF(dtdy2);
+   maxU = MAX2(dsdx2, dsdy2) * texW;
+   maxV = MAX2(dtdx2, dtdy2) * texH;
+   rho = MAX2(maxU, maxV);
+   lambda = LOG2(rho);
+   return lambda;
+}
+#endif
+
+
+/**
+ * Fill in the span.array->attrib[FRAG_ATTRIB_TEXn] arrays from the
+ * using the attrStart/Step values.
+ *
+ * This function only used during fixed-function fragment processing.
+ *
+ * Note: in the places where we divide by Q (or mult by invQ) we're
+ * really doing two things: perspective correction and texcoord
+ * projection.  Remember, for texcoord (s,t,r,q) we need to index
+ * texels with (s/q, t/q, r/q).
+ */
+static void
+interpolate_texcoords(struct gl_context *ctx, SWspan *span)
+{
+   const GLuint maxUnit
+      = (ctx->Texture._EnabledCoordUnits > 1) ? ctx->Const.MaxTextureUnits : 1;
+   GLuint u;
+
+   /* XXX CoordUnits vs. ImageUnits */
+   for (u = 0; u < maxUnit; u++) {
+      if (ctx->Texture._EnabledCoordUnits & (1 << u)) {
+         const GLuint attr = FRAG_ATTRIB_TEX0 + u;
+         const struct gl_texture_object *obj = ctx->Texture.Unit[u]._Current;
+         GLfloat texW, texH;
+         GLboolean needLambda;
+         GLfloat (*texcoord)[4] = span->array->attribs[attr];
+         GLfloat *lambda = span->array->lambda[u];
+         const GLfloat dsdx = span->attrStepX[attr][0];
+         const GLfloat dsdy = span->attrStepY[attr][0];
+         const GLfloat dtdx = span->attrStepX[attr][1];
+         const GLfloat dtdy = span->attrStepY[attr][1];
+         const GLfloat drdx = span->attrStepX[attr][2];
+         const GLfloat dqdx = span->attrStepX[attr][3];
+         const GLfloat dqdy = span->attrStepY[attr][3];
+         GLfloat s = span->attrStart[attr][0] + span->leftClip * dsdx;
+         GLfloat t = span->attrStart[attr][1] + span->leftClip * dtdx;
+         GLfloat r = span->attrStart[attr][2] + span->leftClip * drdx;
+         GLfloat q = span->attrStart[attr][3] + span->leftClip * dqdx;
+
+         if (obj) {
+            const struct gl_texture_image *img = obj->Image[0][obj->BaseLevel];
+            needLambda = (obj->Sampler.MinFilter != obj->Sampler.MagFilter)
+               || ctx->FragmentProgram._Current;
+            /* LOD is calculated directly in the ansiotropic filter, we can
+             * skip the normal lambda function as the result is ignored.
+             */
+            if (obj->Sampler.MaxAnisotropy > 1.0 &&
+                obj->Sampler.MinFilter == GL_LINEAR_MIPMAP_LINEAR) {
+               needLambda = GL_FALSE;
+            }
+            texW = img->WidthScale;
+            texH = img->HeightScale;
+         }
+         else {
+            /* using a fragment program */
+            texW = 1.0;
+            texH = 1.0;
+            needLambda = GL_FALSE;
+         }
+
+         if (needLambda) {
+            GLuint i;
+            if (ctx->FragmentProgram._Current
+                || ctx->ATIFragmentShader._Enabled) {
+               /* do perspective correction but don't divide s, t, r by q */
+               const GLfloat dwdx = span->attrStepX[FRAG_ATTRIB_WPOS][3];
+               GLfloat w = span->attrStart[FRAG_ATTRIB_WPOS][3] + span->leftClip * dwdx;
+               for (i = 0; i < span->end; i++) {
+                  const GLfloat invW = 1.0F / w;
+                  texcoord[i][0] = s * invW;
+                  texcoord[i][1] = t * invW;
+                  texcoord[i][2] = r * invW;
+                  texcoord[i][3] = q * invW;
+                  lambda[i] = _swrast_compute_lambda(dsdx, dsdy, dtdx, dtdy,
+                                                     dqdx, dqdy, texW, texH,
+                                                     s, t, q, invW);
+                  s += dsdx;
+                  t += dtdx;
+                  r += drdx;
+                  q += dqdx;
+                  w += dwdx;
+               }
+            }
+            else {
+               for (i = 0; i < span->end; i++) {
+                  const GLfloat invQ = (q == 0.0F) ? 1.0F : (1.0F / q);
+                  texcoord[i][0] = s * invQ;
+                  texcoord[i][1] = t * invQ;
+                  texcoord[i][2] = r * invQ;
+                  texcoord[i][3] = q;
+                  lambda[i] = _swrast_compute_lambda(dsdx, dsdy, dtdx, dtdy,
+                                                     dqdx, dqdy, texW, texH,
+                                                     s, t, q, invQ);
+                  s += dsdx;
+                  t += dtdx;
+                  r += drdx;
+                  q += dqdx;
+               }
+            }
+            span->arrayMask |= SPAN_LAMBDA;
+         }
+         else {
+            GLuint i;
+            if (ctx->FragmentProgram._Current ||
+                ctx->ATIFragmentShader._Enabled) {
+               /* do perspective correction but don't divide s, t, r by q */
+               const GLfloat dwdx = span->attrStepX[FRAG_ATTRIB_WPOS][3];
+               GLfloat w = span->attrStart[FRAG_ATTRIB_WPOS][3] + span->leftClip * dwdx;
+               for (i = 0; i < span->end; i++) {
+                  const GLfloat invW = 1.0F / w;
+                  texcoord[i][0] = s * invW;
+                  texcoord[i][1] = t * invW;
+                  texcoord[i][2] = r * invW;
+                  texcoord[i][3] = q * invW;
+                  lambda[i] = 0.0;
+                  s += dsdx;
+                  t += dtdx;
+                  r += drdx;
+                  q += dqdx;
+                  w += dwdx;
+               }
+            }
+            else if (dqdx == 0.0F) {
+               /* Ortho projection or polygon's parallel to window X axis */
+               const GLfloat invQ = (q == 0.0F) ? 1.0F : (1.0F / q);
+               for (i = 0; i < span->end; i++) {
+                  texcoord[i][0] = s * invQ;
+                  texcoord[i][1] = t * invQ;
+                  texcoord[i][2] = r * invQ;
+                  texcoord[i][3] = q;
+                  lambda[i] = 0.0;
+                  s += dsdx;
+                  t += dtdx;
+                  r += drdx;
+               }
+            }
+            else {
+               for (i = 0; i < span->end; i++) {
+                  const GLfloat invQ = (q == 0.0F) ? 1.0F : (1.0F / q);
+                  texcoord[i][0] = s * invQ;
+                  texcoord[i][1] = t * invQ;
+                  texcoord[i][2] = r * invQ;
+                  texcoord[i][3] = q;
+                  lambda[i] = 0.0;
+                  s += dsdx;
+                  t += dtdx;
+                  r += drdx;
+                  q += dqdx;
+               }
+            }
+         } /* lambda */
+      } /* if */
+   } /* for */
+}
+
+
+/**
+ * Fill in the arrays->attribs[FRAG_ATTRIB_WPOS] array.
+ */
+static INLINE void
+interpolate_wpos(struct gl_context *ctx, SWspan *span)
+{
+   GLfloat (*wpos)[4] = span->array->attribs[FRAG_ATTRIB_WPOS];
+   GLuint i;
+   const GLfloat zScale = 1.0F / ctx->DrawBuffer->_DepthMaxF;
+   GLfloat w, dw;
+
+   if (span->arrayMask & SPAN_XY) {
+      for (i = 0; i < span->end; i++) {
+         wpos[i][0] = (GLfloat) span->array->x[i];
+         wpos[i][1] = (GLfloat) span->array->y[i];
+      }
+   }
+   else {
+      for (i = 0; i < span->end; i++) {
+         wpos[i][0] = (GLfloat) span->x + i;
+         wpos[i][1] = (GLfloat) span->y;
+      }
+   }
+
+   dw = span->attrStepX[FRAG_ATTRIB_WPOS][3];
+   w = span->attrStart[FRAG_ATTRIB_WPOS][3] + span->leftClip * dw;
+   for (i = 0; i < span->end; i++) {
+      wpos[i][2] = (GLfloat) span->array->z[i] * zScale;
+      wpos[i][3] = w;
+      w += dw;
+   }
+}
+
+
+/**
+ * Apply the current polygon stipple pattern to a span of pixels.
+ */
+static INLINE void
+stipple_polygon_span(struct gl_context *ctx, SWspan *span)
+{
+   GLubyte *mask = span->array->mask;
+
+   ASSERT(ctx->Polygon.StippleFlag);
+
+   if (span->arrayMask & SPAN_XY) {
+      /* arrays of x/y pixel coords */
+      GLuint i;
+      for (i = 0; i < span->end; i++) {
+         const GLint col = span->array->x[i] % 32;
+         const GLint row = span->array->y[i] % 32;
+         const GLuint stipple = ctx->PolygonStipple[row];
+         if (((1 << col) & stipple) == 0) {
+            mask[i] = 0;
+         }
+      }
+   }
+   else {
+      /* horizontal span of pixels */
+      const GLuint highBit = 1 << 31;
+      const GLuint stipple = ctx->PolygonStipple[span->y % 32];
+      GLuint i, m = highBit >> (GLuint) (span->x % 32);
+      for (i = 0; i < span->end; i++) {
+         if ((m & stipple) == 0) {
+            mask[i] = 0;
+         }
+         m = m >> 1;
+         if (m == 0) {
+            m = highBit;
+         }
+      }
+   }
+   span->writeAll = GL_FALSE;
+}
+
+
+/**
+ * Clip a pixel span to the current buffer/window boundaries:
+ * DrawBuffer->_Xmin, _Xmax, _Ymin, _Ymax.  This will accomplish
+ * window clipping and scissoring.
+ * Return:   GL_TRUE   some pixels still visible
+ *           GL_FALSE  nothing visible
+ */
+static INLINE GLuint
+clip_span( struct gl_context *ctx, SWspan *span )
+{
+   const GLint xmin = ctx->DrawBuffer->_Xmin;
+   const GLint xmax = ctx->DrawBuffer->_Xmax;
+   const GLint ymin = ctx->DrawBuffer->_Ymin;
+   const GLint ymax = ctx->DrawBuffer->_Ymax;
+
+   span->leftClip = 0;
+
+   if (span->arrayMask & SPAN_XY) {
+      /* arrays of x/y pixel coords */
+      const GLint *x = span->array->x;
+      const GLint *y = span->array->y;
+      const GLint n = span->end;
+      GLubyte *mask = span->array->mask;
+      GLint i;
+      if (span->arrayMask & SPAN_MASK) {
+         /* note: using & intead of && to reduce branches */
+         for (i = 0; i < n; i++) {
+            mask[i] &= (x[i] >= xmin) & (x[i] < xmax)
+                     & (y[i] >= ymin) & (y[i] < ymax);
+         }
+      }
+      else {
+         /* note: using & intead of && to reduce branches */
+         for (i = 0; i < n; i++) {
+            mask[i] = (x[i] >= xmin) & (x[i] < xmax)
+                    & (y[i] >= ymin) & (y[i] < ymax);
+         }
+      }
+      return GL_TRUE;  /* some pixels visible */
+   }
+   else {
+      /* horizontal span of pixels */
+      const GLint x = span->x;
+      const GLint y = span->y;
+      GLint n = span->end;
+
+      /* Trivial rejection tests */
+      if (y < ymin || y >= ymax || x + n <= xmin || x >= xmax) {
+         span->end = 0;
+         return GL_FALSE;  /* all pixels clipped */
+      }
+
+      /* Clip to right */
+      if (x + n > xmax) {
+         ASSERT(x < xmax);
+         n = span->end = xmax - x;
+      }
+
+      /* Clip to the left */
+      if (x < xmin) {
+         const GLint leftClip = xmin - x;
+         GLuint i;
+
+         ASSERT(leftClip > 0);
+         ASSERT(x + n > xmin);
+
+         /* Clip 'leftClip' pixels from the left side.
+          * The span->leftClip field will be applied when we interpolate
+          * fragment attributes.
+          * For arrays of values, shift them left.
+          */
+         for (i = 0; i < FRAG_ATTRIB_MAX; i++) {
+            if (span->interpMask & (1 << i)) {
+               GLuint j;
+               for (j = 0; j < 4; j++) {
+                  span->attrStart[i][j] += leftClip * span->attrStepX[i][j];
+               }
+            }
+         }
+
+         span->red += leftClip * span->redStep;
+         span->green += leftClip * span->greenStep;
+         span->blue += leftClip * span->blueStep;
+         span->alpha += leftClip * span->alphaStep;
+         span->index += leftClip * span->indexStep;
+         span->z += leftClip * span->zStep;
+         span->intTex[0] += leftClip * span->intTexStep[0];
+         span->intTex[1] += leftClip * span->intTexStep[1];
+
+#define SHIFT_ARRAY(ARRAY, SHIFT, LEN) \
+         memcpy(ARRAY, ARRAY + (SHIFT), (LEN) * sizeof(ARRAY[0]))
+
+         for (i = 0; i < FRAG_ATTRIB_MAX; i++) {
+            if (span->arrayAttribs & (1 << i)) {
+               /* shift array elements left by 'leftClip' */
+               SHIFT_ARRAY(span->array->attribs[i], leftClip, n - leftClip);
+            }
+         }
+
+         SHIFT_ARRAY(span->array->mask, leftClip, n - leftClip);
+         SHIFT_ARRAY(span->array->rgba8, leftClip, n - leftClip);
+         SHIFT_ARRAY(span->array->rgba16, leftClip, n - leftClip);
+         SHIFT_ARRAY(span->array->x, leftClip, n - leftClip);
+         SHIFT_ARRAY(span->array->y, leftClip, n - leftClip);
+         SHIFT_ARRAY(span->array->z, leftClip, n - leftClip);
+         SHIFT_ARRAY(span->array->index, leftClip, n - leftClip);
+         for (i = 0; i < MAX_TEXTURE_COORD_UNITS; i++) {
+            SHIFT_ARRAY(span->array->lambda[i], leftClip, n - leftClip);
+         }
+         SHIFT_ARRAY(span->array->coverage, leftClip, n - leftClip);
+
+#undef SHIFT_ARRAY
+
+         span->leftClip = leftClip;
+         span->x = xmin;
+         span->end -= leftClip;
+         span->writeAll = GL_FALSE;
+      }
+
+      ASSERT(span->x >= xmin);
+      ASSERT(span->x + span->end <= xmax);
+      ASSERT(span->y >= ymin);
+      ASSERT(span->y < ymax);
+
+      return GL_TRUE;  /* some pixels visible */
+   }
+}
+
+
+/**
+ * Add specular colors to primary colors.
+ * Only called during fixed-function operation.
+ * Result is float color array (FRAG_ATTRIB_COL0).
+ */
+static INLINE void
+add_specular(struct gl_context *ctx, SWspan *span)
+{
+   const SWcontext *swrast = SWRAST_CONTEXT(ctx);
+   const GLubyte *mask = span->array->mask;
+   GLfloat (*col0)[4] = span->array->attribs[FRAG_ATTRIB_COL0];
+   GLfloat (*col1)[4] = span->array->attribs[FRAG_ATTRIB_COL1];
+   GLuint i;
+
+   ASSERT(!ctx->FragmentProgram._Current);
+   ASSERT(span->arrayMask & SPAN_RGBA);
+   ASSERT(swrast->_ActiveAttribMask & FRAG_BIT_COL1);
+   (void) swrast; /* silence warning */
+
+   if (span->array->ChanType == GL_FLOAT) {
+      if ((span->arrayAttribs & FRAG_BIT_COL0) == 0) {
+         interpolate_active_attribs(ctx, span, FRAG_BIT_COL0);
+      }
+   }
+   else {
+      /* need float colors */
+      if ((span->arrayAttribs & FRAG_BIT_COL0) == 0) {
+         interpolate_float_colors(span);
+      }
+   }
+
+   if ((span->arrayAttribs & FRAG_BIT_COL1) == 0) {
+      /* XXX could avoid this and interpolate COL1 in the loop below */
+      interpolate_active_attribs(ctx, span, FRAG_BIT_COL1);
+   }
+
+   ASSERT(span->arrayAttribs & FRAG_BIT_COL0);
+   ASSERT(span->arrayAttribs & FRAG_BIT_COL1);
+
+   for (i = 0; i < span->end; i++) {
+      if (mask[i]) {
+         col0[i][0] += col1[i][0];
+         col0[i][1] += col1[i][1];
+         col0[i][2] += col1[i][2];
+      }
+   }
+
+   span->array->ChanType = GL_FLOAT;
+}
+
+
+/**
+ * Apply antialiasing coverage value to alpha values.
+ */
+static INLINE void
+apply_aa_coverage(SWspan *span)
+{
+   const GLfloat *coverage = span->array->coverage;
+   GLuint i;
+   if (span->array->ChanType == GL_UNSIGNED_BYTE) {
+      GLubyte (*rgba)[4] = span->array->rgba8;
+      for (i = 0; i < span->end; i++) {
+         const GLfloat a = rgba[i][ACOMP] * coverage[i];
+         rgba[i][ACOMP] = (GLubyte) CLAMP(a, 0.0, 255.0);
+         ASSERT(coverage[i] >= 0.0);
+         ASSERT(coverage[i] <= 1.0);
+      }
+   }
+   else if (span->array->ChanType == GL_UNSIGNED_SHORT) {
+      GLushort (*rgba)[4] = span->array->rgba16;
+      for (i = 0; i < span->end; i++) {
+         const GLfloat a = rgba[i][ACOMP] * coverage[i];
+         rgba[i][ACOMP] = (GLushort) CLAMP(a, 0.0, 65535.0);
+      }
+   }
+   else {
+      GLfloat (*rgba)[4] = span->array->attribs[FRAG_ATTRIB_COL0];
+      for (i = 0; i < span->end; i++) {
+         rgba[i][ACOMP] = rgba[i][ACOMP] * coverage[i];
+         /* clamp later */
+      }
+   }
+}
+
+
+/**
+ * Clamp span's float colors to [0,1]
+ */
+static INLINE void
+clamp_colors(SWspan *span)
+{
+   GLfloat (*rgba)[4] = span->array->attribs[FRAG_ATTRIB_COL0];
+   GLuint i;
+   ASSERT(span->array->ChanType == GL_FLOAT);
+   for (i = 0; i < span->end; i++) {
+      rgba[i][RCOMP] = CLAMP(rgba[i][RCOMP], 0.0F, 1.0F);
+      rgba[i][GCOMP] = CLAMP(rgba[i][GCOMP], 0.0F, 1.0F);
+      rgba[i][BCOMP] = CLAMP(rgba[i][BCOMP], 0.0F, 1.0F);
+      rgba[i][ACOMP] = CLAMP(rgba[i][ACOMP], 0.0F, 1.0F);
+   }
+}
+
+
+/**
+ * Convert the span's color arrays to the given type.
+ * The only way 'output' can be greater than zero is when we have a fragment
+ * program that writes to gl_FragData[1] or higher.
+ * \param output  which fragment program color output is being processed
+ */
+static INLINE void
+convert_color_type(SWspan *span, GLenum newType, GLuint output)
+{
+   GLvoid *src, *dst;
+
+   if (output > 0 || span->array->ChanType == GL_FLOAT) {
+      src = span->array->attribs[FRAG_ATTRIB_COL0 + output];
+      span->array->ChanType = GL_FLOAT;
+   }
+   else if (span->array->ChanType == GL_UNSIGNED_BYTE) {
+      src = span->array->rgba8;
+   }
+   else {
+      ASSERT(span->array->ChanType == GL_UNSIGNED_SHORT);
+      src = span->array->rgba16;
+   }
+
+   if (newType == GL_UNSIGNED_BYTE) {
+      dst = span->array->rgba8;
+   }
+   else if (newType == GL_UNSIGNED_SHORT) {
+      dst = span->array->rgba16;
+   }
+   else {
+      dst = span->array->attribs[FRAG_ATTRIB_COL0];
+   }
+
+   _mesa_convert_colors(span->array->ChanType, src,
+                        newType, dst,
+                        span->end, span->array->mask);
+
+   span->array->ChanType = newType;
+   span->array->rgba = dst;
+}
+
+
+
+/**
+ * Apply fragment shader, fragment program or normal texturing to span.
+ */
+static INLINE void
+shade_texture_span(struct gl_context *ctx, SWspan *span)
+{
+   if (ctx->FragmentProgram._Current ||
+       ctx->ATIFragmentShader._Enabled) {
+      /* programmable shading */
+      if (span->primitive == GL_BITMAP && span->array->ChanType != GL_FLOAT) {
+         convert_color_type(span, GL_FLOAT, 0);
+      }
+      else {
+         span->array->rgba = (void *) span->array->attribs[FRAG_ATTRIB_COL0];
+      }
+
+      if (span->primitive != GL_POINT ||
+	  (span->interpMask & SPAN_RGBA) ||
+	  ctx->Point.PointSprite) {
+         /* for single-pixel points, we populated the arrays already */
+         interpolate_active_attribs(ctx, span, ~0);
+      }
+      span->array->ChanType = GL_FLOAT;
+
+      if (!(span->arrayMask & SPAN_Z))
+         _swrast_span_interpolate_z (ctx, span);
+
+#if 0
+      if (inputsRead & FRAG_BIT_WPOS)
+#else
+      /* XXX always interpolate wpos so that DDX/DDY work */
+#endif
+         interpolate_wpos(ctx, span);
+
+      /* Run fragment program/shader now */
+      if (ctx->FragmentProgram._Current) {
+         _swrast_exec_fragment_program(ctx, span);
+      }
+      else {
+         ASSERT(ctx->ATIFragmentShader._Enabled);
+         _swrast_exec_fragment_shader(ctx, span);
+      }
+   }
+   else if (ctx->Texture._EnabledCoordUnits) {
+      /* conventional texturing */
+
+#if CHAN_BITS == 32
+      if ((span->arrayAttribs & FRAG_BIT_COL0) == 0) {
+         interpolate_int_colors(ctx, span);
+      }
+#else
+      if (!(span->arrayMask & SPAN_RGBA))
+         interpolate_int_colors(ctx, span);
+#endif
+      if ((span->arrayAttribs & FRAG_BITS_TEX_ANY) == 0x0)
+         interpolate_texcoords(ctx, span);
+
+      _swrast_texture_span(ctx, span);
+   }
+}
+
+
+
+/**
+ * Apply all the per-fragment operations to a span.
+ * This now includes texturing (_swrast_write_texture_span() is history).
+ * This function may modify any of the array values in the span.
+ * span->interpMask and span->arrayMask may be changed but will be restored
+ * to their original values before returning.
+ */
+void
+_swrast_write_rgba_span( struct gl_context *ctx, SWspan *span)
+{
+   const SWcontext *swrast = SWRAST_CONTEXT(ctx);
+   const GLuint *colorMask = (GLuint *) ctx->Color.ColorMask;
+   const GLbitfield origInterpMask = span->interpMask;
+   const GLbitfield origArrayMask = span->arrayMask;
+   const GLbitfield origArrayAttribs = span->arrayAttribs;
+   const GLenum origChanType = span->array->ChanType;
+   void * const origRgba = span->array->rgba;
+   const GLboolean shader = (ctx->FragmentProgram._Current
+                             || ctx->ATIFragmentShader._Enabled);
+   const GLboolean shaderOrTexture = shader || ctx->Texture._EnabledCoordUnits;
+   struct gl_framebuffer *fb = ctx->DrawBuffer;
+
+   /*
+   printf("%s()  interp 0x%x  array 0x%x\n", __FUNCTION__,
+          span->interpMask, span->arrayMask);
+   */
+
+   ASSERT(span->primitive == GL_POINT ||
+          span->primitive == GL_LINE ||
+	  span->primitive == GL_POLYGON ||
+          span->primitive == GL_BITMAP);
+
+   /* Fragment write masks */
+   if (span->arrayMask & SPAN_MASK) {
+      /* mask was initialized by caller, probably glBitmap */
+      span->writeAll = GL_FALSE;
+   }
+   else {
+      memset(span->array->mask, 1, span->end);
+      span->writeAll = GL_TRUE;
+   }
+
+   /* Clip to window/scissor box */
+   if (!clip_span(ctx, span)) {
+      return;
+   }
+
+   ASSERT(span->end <= MAX_WIDTH);
+
+   /* Depth bounds test */
+   if (ctx->Depth.BoundsTest && fb->Visual.depthBits > 0) {
+      if (!_swrast_depth_bounds_test(ctx, span)) {
+         return;
+      }
+   }
+
+#ifdef DEBUG
+   /* Make sure all fragments are within window bounds */
+   if (span->arrayMask & SPAN_XY) {
+      /* array of pixel locations */
+      GLuint i;
+      for (i = 0; i < span->end; i++) {
+         if (span->array->mask[i]) {
+            assert(span->array->x[i] >= fb->_Xmin);
+            assert(span->array->x[i] < fb->_Xmax);
+            assert(span->array->y[i] >= fb->_Ymin);
+            assert(span->array->y[i] < fb->_Ymax);
+         }
+      }
+   }
+#endif
+
+   /* Polygon Stippling */
+   if (ctx->Polygon.StippleFlag && span->primitive == GL_POLYGON) {
+      stipple_polygon_span(ctx, span);
+   }
+
+   /* This is the normal place to compute the fragment color/Z
+    * from texturing or shading.
+    */
+   if (shaderOrTexture && !swrast->_DeferredTexture) {
+      shade_texture_span(ctx, span);
+   }
+
+   /* Do the alpha test */
+   if (ctx->Color.AlphaEnabled) {
+      if (!_swrast_alpha_test(ctx, span)) {
+         /* all fragments failed test */
+         goto end;
+      }
+   }
+
+   /* Stencil and Z testing */
+   if (ctx->Stencil._Enabled || ctx->Depth.Test) {
+      if (!(span->arrayMask & SPAN_Z))
+         _swrast_span_interpolate_z(ctx, span);
+
+      if (ctx->Transform.DepthClamp)
+	 _swrast_depth_clamp_span(ctx, span);
+
+      if (ctx->Stencil._Enabled) {
+         /* Combined Z/stencil tests */
+         if (!_swrast_stencil_and_ztest_span(ctx, span)) {
+            /* all fragments failed test */
+            goto end;
+         }
+      }
+      else if (fb->Visual.depthBits > 0) {
+         /* Just regular depth testing */
+         ASSERT(ctx->Depth.Test);
+         ASSERT(span->arrayMask & SPAN_Z);
+         if (!_swrast_depth_test_span(ctx, span)) {
+            /* all fragments failed test */
+            goto end;
+         }
+      }
+   }
+
+   if (ctx->Query.CurrentOcclusionObject) {
+      /* update count of 'passed' fragments */
+      struct gl_query_object *q = ctx->Query.CurrentOcclusionObject;
+      GLuint i;
+      for (i = 0; i < span->end; i++)
+         q->Result += span->array->mask[i];
+   }
+
+   /* We had to wait until now to check for glColorMask(0,0,0,0) because of
+    * the occlusion test.
+    */
+   if (fb->_NumColorDrawBuffers == 1 && colorMask[0] == 0x0) {
+      /* no colors to write */
+      goto end;
+   }
+
+   /* If we were able to defer fragment color computation to now, there's
+    * a good chance that many fragments will have already been killed by
+    * Z/stencil testing.
+    */
+   if (shaderOrTexture && swrast->_DeferredTexture) {
+      shade_texture_span(ctx, span);
+   }
+
+#if CHAN_BITS == 32
+   if ((span->arrayAttribs & FRAG_BIT_COL0) == 0) {
+      interpolate_active_attribs(ctx, span, FRAG_BIT_COL0);
+   }
+#else
+   if ((span->arrayMask & SPAN_RGBA) == 0) {
+      interpolate_int_colors(ctx, span);
+   }
+#endif
+
+   ASSERT(span->arrayMask & SPAN_RGBA);
+
+   if (span->primitive == GL_BITMAP || !swrast->SpecularVertexAdd) {
+      /* Add primary and specular (diffuse + specular) colors */
+      if (!shader) {
+         if (ctx->Fog.ColorSumEnabled ||
+             (ctx->Light.Enabled &&
+              ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR)) {
+            add_specular(ctx, span);
+         }
+      }
+   }
+
+   /* Fog */
+   if (swrast->_FogEnabled) {
+      _swrast_fog_rgba_span(ctx, span);
+   }
+
+   /* Antialias coverage application */
+   if (span->arrayMask & SPAN_COVERAGE) {
+      apply_aa_coverage(span);
+   }
+
+   /* Clamp color/alpha values over the range [0.0, 1.0] before storage */
+   if (ctx->Color.ClampFragmentColor == GL_TRUE &&
+       span->array->ChanType == GL_FLOAT) {
+      clamp_colors(span);
+   }
+
+   /*
+    * Write to renderbuffers.
+    * Depending on glDrawBuffer() state and the which color outputs are
+    * written by the fragment shader, we may either replicate one color to
+    * all renderbuffers or write a different color to each renderbuffer.
+    * multiFragOutputs=TRUE for the later case.
+    */
+   {
+      const GLuint numBuffers = fb->_NumColorDrawBuffers;
+      const struct gl_fragment_program *fp = ctx->FragmentProgram._Current;
+      const GLboolean multiFragOutputs = 
+         (fp && fp->Base.OutputsWritten >= (1 << FRAG_RESULT_DATA0));
+      GLuint buf;
+
+      for (buf = 0; buf < numBuffers; buf++) {
+         struct gl_renderbuffer *rb = fb->_ColorDrawBuffers[buf];
+
+         /* color[fragOutput] will be written to buffer[buf] */
+
+         if (rb) {
+            GLchan rgbaSave[MAX_WIDTH][4];
+            const GLuint fragOutput = multiFragOutputs ? buf : 0;
+
+            /* set span->array->rgba to colors for render buffer's datatype */
+            if (rb->DataType != span->array->ChanType || fragOutput > 0) {
+               convert_color_type(span, rb->DataType, fragOutput);
+            }
+            else {
+               if (rb->DataType == GL_UNSIGNED_BYTE) {
+                  span->array->rgba = span->array->rgba8;
+               }
+               else if (rb->DataType == GL_UNSIGNED_SHORT) {
+                  span->array->rgba = (void *) span->array->rgba16;
+               }
+               else {
+                  span->array->rgba = (void *)
+                     span->array->attribs[FRAG_ATTRIB_COL0];
+               }
+            }
+
+            if (!multiFragOutputs && numBuffers > 1) {
+               /* save colors for second, third renderbuffer writes */
+               memcpy(rgbaSave, span->array->rgba,
+                      4 * span->end * sizeof(GLchan));
+            }
+
+            ASSERT(rb->_BaseFormat == GL_RGBA || rb->_BaseFormat == GL_RGB ||
+		   rb->_BaseFormat == GL_ALPHA);
+
+            if (ctx->Color._LogicOpEnabled) {
+               _swrast_logicop_rgba_span(ctx, rb, span);
+            }
+            else if ((ctx->Color.BlendEnabled >> buf) & 1) {
+               _swrast_blend_span(ctx, rb, span);
+            }
+
+            if (colorMask[buf] != 0xffffffff) {
+               _swrast_mask_rgba_span(ctx, rb, span, buf);
+            }
+
+            if (span->arrayMask & SPAN_XY) {
+               /* array of pixel coords */
+               ASSERT(rb->PutValues);
+               rb->PutValues(ctx, rb, span->end,
+                             span->array->x, span->array->y,
+                             span->array->rgba, span->array->mask);
+            }
+            else {
+               /* horizontal run of pixels */
+               ASSERT(rb->PutRow);
+               rb->PutRow(ctx, rb, span->end, span->x, span->y,
+                          span->array->rgba,
+                          span->writeAll ? NULL: span->array->mask);
+            }
+
+            if (!multiFragOutputs && numBuffers > 1) {
+               /* restore original span values */
+               memcpy(span->array->rgba, rgbaSave,
+                      4 * span->end * sizeof(GLchan));
+            }
+
+         } /* if rb */
+      } /* for buf */
+   }
+
+end:
+   /* restore these values before returning */
+   span->interpMask = origInterpMask;
+   span->arrayMask = origArrayMask;
+   span->arrayAttribs = origArrayAttribs;
+   span->array->ChanType = origChanType;
+   span->array->rgba = origRgba;
+}
+
+
+/**
+ * Read RGBA pixels from a renderbuffer.  Clipping will be done to prevent
+ * reading ouside the buffer's boundaries.
+ * \param dstType  datatype for returned colors
+ * \param rgba  the returned colors
+ */
+void
+_swrast_read_rgba_span( struct gl_context *ctx, struct gl_renderbuffer *rb,
+                        GLuint n, GLint x, GLint y, GLenum dstType,
+                        GLvoid *rgba)
+{
+   const GLint bufWidth = (GLint) rb->Width;
+   const GLint bufHeight = (GLint) rb->Height;
+
+   if (y < 0 || y >= bufHeight || x + (GLint) n < 0 || x >= bufWidth) {
+      /* completely above, below, or right */
+      /* XXX maybe leave rgba values undefined? */
+      memset(rgba, 0, 4 * n * sizeof(GLchan));
+   }
+   else {
+      GLint skip, length;
+      if (x < 0) {
+         /* left edge clipping */
+         skip = -x;
+         length = (GLint) n - skip;
+         if (length < 0) {
+            /* completely left of window */
+            return;
+         }
+         if (length > bufWidth) {
+            length = bufWidth;
+         }
+      }
+      else if ((GLint) (x + n) > bufWidth) {
+         /* right edge clipping */
+         skip = 0;
+         length = bufWidth - x;
+         if (length < 0) {
+            /* completely to right of window */
+            return;
+         }
+      }
+      else {
+         /* no clipping */
+         skip = 0;
+         length = (GLint) n;
+      }
+
+      ASSERT(rb);
+      ASSERT(rb->GetRow);
+      ASSERT(rb->_BaseFormat == GL_RGBA ||
+	     rb->_BaseFormat == GL_RGB ||
+	     rb->_BaseFormat == GL_RG ||
+	     rb->_BaseFormat == GL_RED ||
+	     rb->_BaseFormat == GL_LUMINANCE ||
+	     rb->_BaseFormat == GL_INTENSITY ||
+	     rb->_BaseFormat == GL_LUMINANCE_ALPHA ||
+	     rb->_BaseFormat == GL_ALPHA);
+
+      if (rb->DataType == dstType) {
+         rb->GetRow(ctx, rb, length, x + skip, y,
+                    (GLubyte *) rgba + skip * RGBA_PIXEL_SIZE(rb->DataType));
+      }
+      else {
+         GLuint temp[MAX_WIDTH * 4];
+         rb->GetRow(ctx, rb, length, x + skip, y, temp);
+         _mesa_convert_colors(rb->DataType, temp,
+                   dstType, (GLubyte *) rgba + skip * RGBA_PIXEL_SIZE(dstType),
+                   length, NULL);
+      }
+   }
+}
+
+
+/**
+ * Wrapper for gl_renderbuffer::GetValues() which does clipping to avoid
+ * reading values outside the buffer bounds.
+ * We can use this for reading any format/type of renderbuffer.
+ * \param valueSize is the size in bytes of each value (pixel) put into the
+ *                  values array.
+ */
+void
+_swrast_get_values(struct gl_context *ctx, struct gl_renderbuffer *rb,
+                   GLuint count, const GLint x[], const GLint y[],
+                   void *values, GLuint valueSize)
+{
+   GLuint i, inCount = 0, inStart = 0;
+
+   for (i = 0; i < count; i++) {
+      if (x[i] >= 0 && y[i] >= 0 &&
+	  x[i] < (GLint) rb->Width && y[i] < (GLint) rb->Height) {
+         /* inside */
+         if (inCount == 0)
+            inStart = i;
+         inCount++;
+      }
+      else {
+         if (inCount > 0) {
+            /* read [inStart, inStart + inCount) */
+            rb->GetValues(ctx, rb, inCount, x + inStart, y + inStart,
+                          (GLubyte *) values + inStart * valueSize);
+            inCount = 0;
+         }
+      }
+   }
+   if (inCount > 0) {
+      /* read last values */
+      rb->GetValues(ctx, rb, inCount, x + inStart, y + inStart,
+                    (GLubyte *) values + inStart * valueSize);
+   }
+}
+
+
+/**
+ * Wrapper for gl_renderbuffer::PutRow() which does clipping.
+ * \param valueSize  size of each value (pixel) in bytes
+ */
+void
+_swrast_put_row(struct gl_context *ctx, struct gl_renderbuffer *rb,
+                GLuint count, GLint x, GLint y,
+                const GLvoid *values, GLuint valueSize)
+{
+   GLint skip = 0;
+
+   if (y < 0 || y >= (GLint) rb->Height)
+      return; /* above or below */
+
+   if (x + (GLint) count <= 0 || x >= (GLint) rb->Width)
+      return; /* entirely left or right */
+
+   if ((GLint) (x + count) > (GLint) rb->Width) {
+      /* right clip */
+      GLint clip = x + count - rb->Width;
+      count -= clip;
+   }
+
+   if (x < 0) {
+      /* left clip */
+      skip = -x;
+      x = 0;
+      count -= skip;
+   }
+
+   rb->PutRow(ctx, rb, count, x, y,
+              (const GLubyte *) values + skip * valueSize, NULL);
+}
+
+
+/**
+ * Wrapper for gl_renderbuffer::GetRow() which does clipping.
+ * \param valueSize  size of each value (pixel) in bytes
+ */
+void
+_swrast_get_row(struct gl_context *ctx, struct gl_renderbuffer *rb,
+                GLuint count, GLint x, GLint y,
+                GLvoid *values, GLuint valueSize)
+{
+   GLint skip = 0;
+
+   if (y < 0 || y >= (GLint) rb->Height)
+      return; /* above or below */
+
+   if (x + (GLint) count <= 0 || x >= (GLint) rb->Width)
+      return; /* entirely left or right */
+
+   if (x + count > rb->Width) {
+      /* right clip */
+      GLint clip = x + count - rb->Width;
+      count -= clip;
+   }
+
+   if (x < 0) {
+      /* left clip */
+      skip = -x;
+      x = 0;
+      count -= skip;
+   }
+
+   rb->GetRow(ctx, rb, count, x, y, (GLubyte *) values + skip * valueSize);
+}
+
+
+/**
+ * Get RGBA pixels from the given renderbuffer.
+ * Used by blending, logicop and masking functions.
+ * \return pointer to the colors we read.
+ */
+void *
+_swrast_get_dest_rgba(struct gl_context *ctx, struct gl_renderbuffer *rb,
+                      SWspan *span)
+{
+   const GLuint pixelSize = RGBA_PIXEL_SIZE(span->array->ChanType);
+   void *rbPixels;
+
+   /* Point rbPixels to a temporary space */
+   rbPixels = span->array->attribs[FRAG_ATTRIB_MAX - 1];
+
+   /* Get destination values from renderbuffer */
+   if (span->arrayMask & SPAN_XY) {
+      _swrast_get_values(ctx, rb, span->end, span->array->x, span->array->y,
+                         rbPixels, pixelSize);
+   }
+   else {
+      _swrast_get_row(ctx, rb, span->end, span->x, span->y,
+                      rbPixels, pixelSize);
+   }
+
+   return rbPixels;
+}